{

bool fusedWeights, fusedBias;

std::vector<double> weightsMultipliers;

BaseConvolutionLayerImpl(const LayerParams &params)

{

setParamsFrom(params);

getConvolutionKernelParams(params, kernel_size, pads_begin, pads_end, strides, dilations, padMode, adjust_pads);

numOutput = params.get<int>("num_output");

int ngroups = params.get<int>("group", 1);

CV_Assert(numOutput % ngroups == 0);

if (kernel_size.size() == 2) {

kernel = Size(kernel_size[1], kernel_size[0]);

stride = Size(strides[1], strides[0]);

for (int i = 0; i < pads_begin.size(); i++) {

if (pads_begin[i] != pads_end[i])

CV_Error(Error::StsNotImplemented, "Unsupported asymmetric padding in convolution layer");

}

pad = Size(pads_begin[1], pads_begin[0]);

dilation = Size(dilations[1], dilations[0]);

adjustPad.height = adjust_pads[0];

adjustPad.width = adjust_pads[1];

}

for (int i = 0; i < adjust_pads.size(); i++) {

CV_Assert(adjust_pads[i] < strides[i]);

}

fusedWeights = false;

fusedBias = false;

}

virtual void finalize(InputArrayOfArrays inputs_arr, OutputArrayOfArrays outputs_arr) CV_OVERRIDE

{

std::vector<Mat> inputs, outputs;

inputs_arr.getMatVector(inputs);

outputs_arr.getMatVector(outputs);

CV_Assert((inputs.size() > outputs.size() && blobs.empty()) ||

(!inputs.empty() && (blobs.size() == 1 || blobs.size() == 2)));

MatSize weightShape = blobs.empty() ? inputs[1].size : blobs[0].size;

CV_Assert(inputs[0].dims == outputs[0].dims);

CV_Assert(weightShape.dims() == kernel_size.size() + 2);

for (int i = 0; i < kernel_size.size(); i++) {

CV_Assert(weightShape[i + 2] == kernel_size[i]);

}

const Mat &input = inputs[0];

CV_Assert((input.dims == 4 || input.dims == 5) && (input.type() == CV_32F || input.type() == CV_16S));

for (size_t i = 0; i < outputs.size(); i++)

{

CV_Assert(inputs[i].type() == input.type());

CV_Assert((inputs[i].dims == 4 || inputs[i].dims == 5) && inputs[i].size[1] == input.size[1]);

for (int j = 0; j < inputs[i].dims; j++) {

CV_Assert(inputs[i].size[j] == input.size[j]);

}

}

std::vector<int> inpShape;

std::vector<int> outShape;

for (int i = 2; i < inputs[0].dims; i++) {

inpShape.push_back(inputs[0].size[i]);

outShape.push_back(outputs[0].size[i]);

}

getConvPoolPaddings(inpShape, kernel_size, strides, padMode, pads_begin, pads_end);

if (pads_begin.size() == 2) {

for (int i = 0; i < pads_begin.size(); i++) {

if (pads_begin[i] != pads_end[i])

CV_Error(Error::StsNotImplemented, "Unsupported asymmetric padding in convolution layer");

}

pad = Size(pads_begin[1], pads_begin[0]);

}

fusedWeights = false;

fusedBias = false;

}

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 bool tryFuse(Ptr<Layer>& top) CV_OVERRIDE

{

Ptr<BlankLayer> blank_layer = top.dynamicCast<BlankLayer>();

if (blank_layer)

return true;

Mat w, b;

top->getScaleShift(w, b);

if (!w.empty() || !b.empty())

{

fuseWeights(w, b);

fusedWeights = fusedWeights || !w.empty();

fusedBias = fusedBias || (hasBias() && !w.empty()) || !b.empty();

return true;

}

return false;

}

virtual void fuseWeights(const Mat& w_, const Mat& b_) = 0;

virtual void applyHalideScheduler(Ptr<BackendNode>& node,

const std::vector<Mat*> &inputs,

const std::vector<Mat> &outputs,

int targetId) const CV_OVERRIDE

{

#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

}

{

#ifdef HAVE_OPENCL

newActiv = false;

activType = OCL4DNN_CONV_FUSED_ACTIV_NONE;

power = 0.f;

#endif

#ifdef HAVE_CUDA

cudaFusionMode = cuda4dnn::ConvolutionConfiguration::FusionMode::NONE;

cudaActType = cuda4dnn::ConvolutionConfiguration::ActivationType::IDENTITY;

#endif

#ifdef HAVE_TENGINE

tengine_graph=NULL;

#endif

{

CV_Assert(!blobs.empty());

int dims = inpShape.size();

int inpD = dims == 5 ? inpShape[2] : 1;

int inpH = inpShape[dims - 2];

int inpW = inpShape.back();

int inpGroupCn = blobs[0].size[1];

int ksize = inpGroupCn * std::accumulate(kernel_size.begin(), kernel_size.end(),

1, std::multiplies<size_t>());

return shape(inpD * inpH * inpW, ksize);

{

if (backendId == DNN_BACKEND_CUDA)

{

/* only convolution 2d and 3d supported */

if(kernel_size.size() == 2 || kernel_size.size() == 3)

return true;

return false;

}

#ifdef HAVE_INF_ENGINE

if (backendId == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 || backendId == DNN_BACKEND_INFERENCE_ENGINE_NGRAPH)

{

if (kernel_size.size() == 3)

return preferableTarget == DNN_TARGET_CPU;

if ((backendId == DNN_BACKEND_INFERENCE_ENGINE_NN_BUILDER_2019 || preferableTarget != DNN_TARGET_MYRIAD) && blobs.empty())

return false;

return (preferableTarget != DNN_TARGET_MYRIAD || dilation.width == dilation.height);

}

else

#endif

{

if (kernel_size.size() == 3)

return (preferableTarget == DNN_TARGET_CPU && backendId == DNN_BACKEND_OPENCV);

else if (kernel_size.size() == 2)

return backendId == DNN_BACKEND_OPENCV ||

(backendId == DNN_BACKEND_HALIDE && !blobs.empty()) ||

(backendId == DNN_BACKEND_VKCOM && haveVulkan());

else

return false;

}

const int requiredOutputs,

std::vector<MatShape> &outputs,

std::vector<MatShape> &internals) const CV_OVERRIDE

{

CV_Assert(!blobs.empty() || inputs.size() > 1);

const int* weightShape = blobs.empty() ? &inputs[1][0] : blobs[0].size.p;

CV_Assert(!hasBias() || blobs[1].total() == (size_t)weightShape[0]);

internals.clear();

CV_Assert(inputs.size() != 0);

std::vector<int> inpShape(inputs[0].begin() + 2, inputs[0].end());

int outCn = weightShape[0];

std::vector<int> outShape;

outShape.push_back(inputs[0][0]);

outShape.push_back(outCn);

int inpCn = inputs[0][1];

if (padMode.empty())

{

for (int i = 0; i < inpShape.size(); i++)

outShape.push_back((inpShape[i] + pads_begin[i] + pads_end[i] - dilations[i] * (kernel_size[i] - 1) - 1) / strides[i] + 1);

}

else

{

getConvPoolOutParams(inpShape, kernel_size, strides, padMode, dilations, outShape);

}

int ngroups = inpCn / weightShape[1];

if (ngroups == 0 || ngroups * weightShape[1] != inpCn)

CV_Error(Error::StsError, format("Number of input channels should "

"be multiple of %d but got %d", weightShape[1], inpCn));

CV_Assert(ngroups > 0 && inpCn % ngroups == 0 && outCn % ngroups == 0);

outputs.resize(1, outShape);

return false;

{

BaseConvolutionLayerImpl::finalize(inputs_arr, outputs_arr);

std::vector<Mat> inputs;

inputs_arr.getMatVector(inputs);

// 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.empty() ? inputs[1].reshape(1, numOutput) : blobs[0].reshape(1, numOutput);

if( wm.step1() % VEC_ALIGN != 0 )

{

int newcols = (int)alignSize(wm.step1(), VEC_ALIGN);

Mat wm_buffer = Mat(numOutput, 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;

weightsMultipliers.assign(numOutput, 1.0);

Mat biasMat = hasBias() ? blobs[1].reshape(1, numOutput) : Mat();

biasvec.resize(numOutput+2);

if( biasMat.empty() )

{

for(int i = 0; i < numOutput; i++ )

biasvec[i] = 0.f;

}

else

{

for(int i = 0; i < numOutput; i++ )

biasvec[i] = biasMat.at<float>(i);

}

#ifdef HAVE_TENGINE

if(NULL != tengine_graph )

{

tengine_release(tengine_graph);

tengine_graph = NULL ;

}

#endif

#ifdef HAVE_OPENCL

convolutionOp.release();

#endif

{

if ((!activ.empty() && !layer.empty()) || blobs.empty())

return false;

activ = layer;

if (activ.empty())

reluslope.clear();

#ifdef HAVE_OPENCL

newActiv = true;

activType = OCL4DNN_CONV_FUSED_ACTIV_NONE;

if (IS_DNN_OPENCL_TARGET(preferableTarget))

{

Ptr<PowerLayer> activ_power = activ.dynamicCast<PowerLayer>();

if (!activ_power.empty())

{

if (activ_power->scale != 1.0f) // not supported well by implementation, #17964

{

// FIXIT no way to check number of blobs (like, eltwise input)

CV_LOG_DEBUG(NULL, "DNN/OpenCL: can't configure Power activation (scale != 1.0f)");

activ.release();

newActiv = false;

return false;

}

if (activ_power->scale != 1.f || activ_power->shift != 0.f)

{

const int outCh = blobs[0].size[0];

fuseWeights(Mat(1, outCh, CV_32F, Scalar(activ_power->scale)),

Mat(1, outCh, CV_32F, Scalar(activ_power->shift)));

}

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

#ifdef HAVE_CUDA

if (activ.empty())

{

/* setActivation was called with empty argument => reset all fusions */

cudaFusionMode = cuda4dnn::ConvolutionConfiguration::FusionMode::NONE;

cudaActType = cuda4dnn::ConvolutionConfiguration::ActivationType::IDENTITY;

}

if(IS_DNN_CUDA_TARGET(preferableTarget))

{

CV_Assert(cudaFusionMode == ConvolutionConfiguration::FusionMode::NONE ||

cudaFusionMode == ConvolutionConfiguration::FusionMode::ELTWISE_SUM);

Ptr<ReLULayer> activ_relu = activ.dynamicCast<ReLULayer>();

if(!activ_relu.empty())

{

cudaActType = cuda4dnn::ConvolutionConfiguration::ActivationType::RELU;

cuda_relu_slope = activ_relu->negativeSlope;

}

Ptr<ReLU6Layer> activ_relu6 = activ.dynamicCast<ReLU6Layer>();

if(!activ_relu6.empty())

{

cudaActType = cuda4dnn::ConvolutionConfiguration::ActivationType::CLIPPED_RELU;

cuda_crelu_floor = activ_relu6->minValue;

cuda_crelu_ceil = activ_relu6->maxValue;

}

Ptr<PowerLayer> activ_power = activ.dynamicCast<PowerLayer>();

if (!activ_power.empty())

{

cuda_power_scale = activ_power->scale;

cuda_power_shift = activ_power->shift;

cuda_power_exp = activ_power->power;

cudaActType = cuda4dnn::ConvolutionConfiguration::ActivationType::POWER;

}

Ptr<TanHLayer> activ_tanh = activ.dynamicCast<TanHLayer>();

if(!activ_tanh.empty())

cudaActType = cuda4dnn::ConvolutionConfiguration::ActivationType::TANH;

Ptr<SigmoidLayer> activ_sigmoid = activ.dynamicCast<SigmoidLayer>();

if(!activ_sigmoid.empty())

cudaActType = cuda4dnn::ConvolutionConfiguration::ActivationType::SIGMOID;

Ptr<SwishLayer> activ_swish = activ.dynamicCast<SwishLayer>();

if(!activ_swish.empty())

cudaActType = cuda4dnn::ConvolutionConfiguration::ActivationType::SWISH;

Ptr<MishLayer> activ_mish = activ.dynamicCast<MishLayer>();

if(!activ_mish.empty())

cudaActType = cuda4dnn::ConvolutionConfiguration::ActivationType::MISH;

if (cudaActType == cuda4dnn::ConvolutionConfiguration::ActivationType::IDENTITY)

{

/* no activation fused */

activ.reset();

}

else

{

/* activation was fused */

if (cudaFusionMode == ConvolutionConfiguration::FusionMode::NONE) /* no previous fusion */

cudaFusionMode = ConvolutionConfiguration::FusionMode::ACTIVATION; /* now activation */

else if (cudaFusionMode == ConvolutionConfiguration::FusionMode::ELTWISE_SUM) /* previously eltwise was fused */

cudaFusionMode = ConvolutionConfiguration::FusionMode::ELTWISE_SUM_THEN_ACTIVATION; /* now activation on eltwise output */

}

}

#endif

return !activ.empty();

{

#ifdef HAVE_CUDA

if(IS_DNN_CUDA_TARGET(preferableTarget))

{

Ptr<EltwiseLayer> eltwise = top.dynamicCast<EltwiseLayer>();

if (!eltwise.empty()) // && eltwise->op == EltwiseLayer::SUM && eltwise->coeffs.empty())

{

/* we also need to check that the eltwise input does not require shortcut mechanism

if (cudaFusionMode == ConvolutionConfiguration::FusionMode::NONE)

{

/* no previous fusion */

cudaFusionMode = ConvolutionConfiguration::FusionMode::ELTWISE_SUM; /* now eltwise */

return true;

}

else if(cudaFusionMode == ConvolutionConfiguration::FusionMode::ACTIVATION)

{

/* previously an activation was fused */

cudaFusionMode = ConvolutionConfiguration::FusionMode::ACTIVATION_THEN_ELTWISE_SUM;

return true;

}

return false;

}

}

#endif

return BaseConvolutionLayerImpl::tryFuse(top);

{

// Convolution weights have OIHW data layout. Parameters fusion in case of

// (conv(I) + b1 ) * w + b2

// means to replace convolution's weights to [w*conv(I)] and bias to [b1 * w + b2]

const int outCn = weightsMat.size[0];

Mat w = w_.total() == 1 ? Mat(1, outCn, CV_32F, Scalar(w_.at<float>(0))) : w_;

Mat b = b_.total() == 1 ? Mat(1, outCn, CV_32F, Scalar(b_.at<float>(0))) : b_;

CV_Assert_N(!weightsMat.empty(), biasvec.size() == outCn + 2,

w.empty() || outCn == w.total(), b.empty() || outCn == b.total());

if (!w.empty())

{

// Keep origin weights unchanged.

if (weightsMat.data == blobs[0].data)

weightsMat = weightsMat.clone();

Mat originWeights = blobs[0].reshape(1, outCn);

for (int i = 0; i < outCn; ++i)

{

double wi = w.at<float>(i);

weightsMultipliers[i] *= wi;

cv::multiply(originWeights.row(i), weightsMultipliers[i], weightsMat.row(i));

biasvec[i] *= wi;

}

}

if (!b.empty())

{

for (int i = 0; i < outCn; ++i)

biasvec[i] += b.at<float>(i);

}

biasvec[outCn] = biasvec[outCn+1] = biasvec[outCn-1];

{

#ifdef HAVE_VULKAN

int out_channel = blobs[0].size[0];

bool has_bias = hasBias() || fusedBias;

int filter_size[2] = {kernel.height, kernel.width};

int pad_size[2] = {pad.height, pad.width};

int stride_size[2] = {stride.height, stride.width};

int dilation_size[2] = {dilation.height, dilation.width};

int activation = 0;

vkcom::Tensor input_tensor = VkComTensor(inputs[0]);

int in_channel = input_tensor.dimSize(1);

int group = in_channel / blobs[0].size[1];

// TODO: support group > 1

if (group != 1)

return Ptr<BackendNode>();

int padding_mode;

if (padMode.empty())

{

padding_mode = vkcom::kPaddingModeCaffe;

}

else if (padMode == "VALID")

{

padding_mode = vkcom::kPaddingModeValid;

}

else if (padMode == "SAME")

{

padding_mode = vkcom::kPaddingModeSame;

}

else

CV_Error(Error::StsError, "Unsupported padding mode " + padMode);

std::shared_ptr<vkcom::OpBase> op(new vkcom::OpConv(out_channel, has_bias,

filter_size, pad_size,

stride_size, dilation_size,

activation, group,

padding_mode));

std::vector<Ptr<BackendWrapper> > blobsWrapper;

if (fusedWeights)

{

Mat wm;

weightsMat.copyTo(wm); // to handle the case of isContinuous() == false

wm = wm.reshape(1, blobs[0].dims, blobs[0].size);

blobsWrapper.push_back(Ptr<BackendWrapper>(new VkComBackendWrapper(wm)));

}

else

{

blobsWrapper.push_back(Ptr<BackendWrapper>(new VkComBackendWrapper(blobs[0])));

}

if (has_bias)

{

Mat biasesMat({out_channel}, CV_32F, &biasvec[0]);

blobsWrapper.push_back(Ptr<BackendWrapper>(new VkComBackendWrapper(biasesMat)));

}

return Ptr<BackendNode>(new VkComBackendNode(inputs, op, blobsWrapper));

#endif // HAVE_VULKAN

return Ptr<BackendNode>();

{

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

{

InferenceEngine::DataPtr input = infEngineDataNode(inputs[0]);

std::vector<size_t> dims = input->getDims();

CV_Assert(dims.size() == 4 || dims.size() == 5);

const int inpCn = dims[1];

const int outCn = blobs[0].size[0];

const int inpGroupCn = blobs[0].size[1];

const int group = inpCn / inpGroupCn;

InferenceEngine::Layout layout = (dims.size() == 4) ? InferenceEngine::Layout::OIHW :

InferenceEngine::Layout::NCDHW;

auto ieWeights = wrapToInfEngineBlob(blobs[0], layout);

if (fusedWeights)

{

if (weightsMat.isContinuous())

{

Mat cvWeights = weightsMat.reshape(1, blobs[0].dims, blobs[0].size);

ieWeights = wrapToInfEngineBlob(cvWeights, layout);

}

else

{

ieWeights = InferenceEngine::make_shared_blob<float>({

InferenceEngine::Precision::FP32,

ieWeights->getTensorDesc().getDims(), layout

});

ieWeights->allocate();

Mat newWeights = infEngineBlobToMat(ieWeights).reshape(1, outCn);

Mat cvWeights = weightsMat.colRange(0, newWeights.cols);

cvWeights.copyTo(newWeights);

}

}

InferenceEngine::Blob::Ptr ieBiases;

if (hasBias() || fusedBias)

{

Mat biasesMat({outCn}, CV_32F, &biasvec[0]);

ieBiases = wrapToInfEngineBlob(biasesMat, {(size_t)outCn}, InferenceEngine::Layout::C);

}

InferenceEngine::Builder::ConvolutionLayer ieLayer(name);

ieLayer.setKernel(kernel_size);

ieLayer.setStrides(strides);

ieLayer.setDilation(dilations);

ieLayer.setPaddingsBegin(pads_begin);

ieLayer.setPaddingsEnd(pads_end);

ieLayer.setGroup((size_t)group);

ieLayer.setOutDepth((size_t)outCn);

InferenceEngine::Builder::Layer l = ieLayer;

addConstantData("weights", ieWeights, l);

if (ieBiases)

addConstantData("biases", ieBiases, l);

if (!padMode.empty())

l.getParameters()["auto_pad"] = padMode == "VALID" ? std::string("valid") : std::string("same_upper");

return Ptr<BackendNode>(new InfEngineBackendNode(l));

const std::vector<Ptr<BackendNode> >& nodes) CV_OVERRIDE

{

CV_Assert_N(inputs.size() >= 1, nodes.size() >= 1);

auto& ieInpNode = nodes[0].dynamicCast<InfEngineNgraphNode>()->node;

std::vector<size_t> dims = ieInpNode->get_shape();

CV_Assert(dims.size() == 4 || dims.size() == 5);

std::shared_ptr<ngraph::Node> ieWeights = nodes.size() > 1 ? nodes[1].dynamicCast<InfEngineNgraphNode>()->node : nullptr;

if (nodes.size() > 1)

CV_Assert(ieWeights); // dynamic_cast should not fail

const int inpCn = dims[1];

const int inpGroupCn = nodes.size() > 1 ? ieWeights->get_shape()[1] : blobs[0].size[1];

const int group = inpCn / inpGroupCn;

std::vector<size_t> kernel_shape;

if (group != 1)

{

kernel_shape.push_back(group);

}

kernel_shape.push_back(numOutput / group);

kernel_shape.push_back(inpCn / group);

std::copy(kernel_size.begin(), kernel_size.end(), back_inserter(kernel_shape));

if (nodes.size() == 1)

{

ieWeights = std::make_shared<ngraph::op::Constant>(ngraph::element::f32, kernel_shape, blobs[0].data);

if (fusedWeights)

{

if (weightsMat.isContinuous())

{

ieWeights = std::make_shared<ngraph::op::Constant>(ngraph::element::f32, kernel_shape, weightsMat.data);

}

else

{

Mat newWeights;

Mat cvWeights = weightsMat.colRange(0, blobs[0].total() / numOutput);

cvWeights.copyTo(newWeights);

ieWeights = std::make_shared<ngraph::op::Constant>(ngraph::element::f32, kernel_shape, newWeights.data);

}

}

}

else

{

auto shape = std::make_shared<ngraph::op::Constant>(ngraph::element::i64,

ngraph::Shape{kernel_shape.size()}, kernel_shape.data());

ieWeights = std::make_shared<ngraph::op::v1::Reshape>(ieWeights, shape, true);

}

ngraph::op::PadType pad_type = ngraph::op::PadType::EXPLICIT;

if (!padMode.empty())

pad_type = padMode == "VALID" ? ngraph::op::PadType::VALID : ngraph::op::PadType::SAME_UPPER;

std::shared_ptr<ngraph::Node> conv_node;

if (group != 1) {

conv_node = std::make_shared<ngraph::op::v1::GroupConvolution>(

ieInpNode, ieWeights,

ngraph::Strides(strides),

ngraph::CoordinateDiff(std::vector<std::ptrdiff_t>(pads_begin.begin(), pads_begin.end())),

ngraph::CoordinateDiff(std::vector<std::ptrdiff_t>(pads_end.begin(), pads_end.end())),

ngraph::Strides(dilations),

pad_type);

} else {

conv_node = std::make_shared<ngraph::op::v1::Convolution>(

ieInpNode, ieWeights,

ngraph::Strides(strides),

ngraph::CoordinateDiff(std::vector<std::ptrdiff_t>(pads_begin.begin(), pads_begin.end())),

ngraph::CoordinateDiff(std::vector<std::ptrdiff_t>(pads_end.begin(), pads_end.end())),

ngraph::Strides(dilations),

pad_type);

}

if (hasBias() || fusedBias || nodes.size() == 3)

{

std::vector<size_t> shape(conv_node->get_shape().size(), 1);

shape[1] = conv_node->get_shape()[1];

std::shared_ptr<ngraph::Node> bias;

if (nodes.size() == 3)

{

auto bias_shape = std::make_shared<ngraph::op::Constant>(ngraph::element::i64,

ngraph::Shape{shape.size()}, shape.data());

bias = std::make_shared<ngraph::op::v1::Reshape>(nodes[2].dynamicCast<InfEngineNgraphNode>()->node, bias_shape, true);

}

else

{

bias = std::make_shared<ngraph::op::Constant>(ngraph::element::f32, ngraph::Shape(shape), biasvec.data());

}

auto conv_bias = std::make_shared<ngraph::op::v1::Add>(conv_node, bias, ngraph::op::AutoBroadcastType::NUMPY);

return Ptr<BackendNode>(new InfEngineNgraphNode(conv_bias));

}

return Ptr<BackendNode>(new InfEngineNgraphNode(conv_node));

{

public:

enum { BLK_SIZE = 32, BLK_SIZE_CN = 64 };

const Mat* input_;

const Mat* weights_;

Mat* output_;

int outShape[4]; // used only for conv2d

std::vector<size_t> kernel_size, pads_begin, pads_end, strides, dilations;

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;

int blk_size_cn;

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)

, blk_size_cn(0)

{}

static void run( const Mat& input, Mat& output, const Mat& weights,

const std::vector<float>& biasvec,

const std::vector<float>& reluslope,

const std::vector<size_t>& kernel_size, const std::vector<size_t>& strides,

const std::vector<size_t>& pads_begin, const std::vector<size_t>& pads_end,

const std::vector<size_t>& dilations,

const ActivationLayer* activ, int ngroups, int nstripes )

{

size_t karea = std::accumulate(kernel_size.begin(), kernel_size.end(),

1, std::multiplies<size_t>());

CV_Assert_N(

(input.dims == 4 || input.dims == 5) && (input.dims == output.dims),

input.size[0] == output.size[0],

weights.rows == output.size[1],

weights.cols == (input.size[1]/ngroups)*karea,

input.type() == output.type(),

input.type() == weights.type(),

input.type() == CV_32FC1,

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_size = kernel_size; p.strides = strides; p.dilations = dilations;

p.pads_begin = pads_begin; p.pads_end = pads_end;

p.ngroups_ = ngroups;

p.nstripes_ = nstripes;

int inpCnAll = input.size[1];

int depth = (input.dims == 5) ? input.size[2] : 1;

int width = input.size[input.dims - 1];

int height = input.size[input.dims - 2];

int inpCn = inpCnAll / ngroups;

bool isConv2D = kernel_size.size() == 2;

p.is1x1_ = isConv2D && kernel_size[0] == 1 && kernel_size[1] == 1 &&

pads_begin[0] == 0 && pads_begin[1] == 0;

p.useAVX = checkHardwareSupport(CPU_AVX) && isConv2D;

p.useAVX2 = checkHardwareSupport(CPU_AVX2) && isConv2D;

p.useAVX512 = CV_CPU_HAS_SUPPORT_AVX512_SKX && isConv2D;

int kernel_d = !isConv2D? kernel_size[0] : 1;

int kernel_h = kernel_size[kernel_size.size() - 2];

int kernel_w = kernel_size.back();

int blk_size_cn0 = cvCeil(800./(kernel_w*kernel_h));

int ncn = 16;

while (ncn*2 < blk_size_cn0 && ncn < inpCn)

ncn *= 2;

ncn = std::min(ncn, inpCn);

p.blk_size_cn = ncn;

int dil_d = !isConv2D? dilations[0] : 1;

int dil_h = dilations[dilations.size() - 2];

int dil_w = dilations.back();

p.ofstab_.resize(karea * ncn);

int* ofstab = &p.ofstab_[0];

if (isConv2D)

{

for( int k = 0; k < ncn; k++ )

for( int k_r = 0; k_r < kernel_h; k_r++ )

for( int k_c = 0; k_c < kernel_w; k_c++ )

ofstab[(k*kernel_h + k_r)*kernel_w + k_c] =

(k*height + k_r*dil_h)*width + k_c*dil_w;

}

else

{

for( int k = 0; k < ncn; k++ )

for (int k_d = 0; k_d < kernel_d; k_d++)

for( int k_r = 0; k_r < kernel_h; k_r++ )

for( int k_c = 0; k_c < kernel_w; k_c++ )

ofstab[(k*kernel_d*kernel_h + k_d*kernel_h + k_r)*kernel_w + k_c] =

(k*depth*height + k_d*dil_d*height + k_r*dil_h)*width + k_c*dil_w;

}

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 CV_OVERRIDE

{

const int valign = ConvolutionLayerImpl::VEC_ALIGN;

int ngroups = ngroups_, batchSize = input_->size[0]*ngroups;

bool isConv2D = input_->dims == 4;

int outW = output_->size[output_->dims - 1];

int outH = output_->size[output_->dims - 2];