modules/dnn/src/layers/convolution_layer.cpp

   1 /*M///////////////////////////////////////////////////////////////////////////////////////
   2 //
   3 //  IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
   4 //
   5 //  By downloading, copying, installing or using the software you agree to this license.
   6 //  If you do not agree to this license, do not download, install,
   7 //  copy or use the software.
   8 //
   9 //
  10 //                           License Agreement
  11 //                For Open Source Computer Vision Library
  12 //
  13 // Copyright (C) 2013, OpenCV Foundation, all rights reserved.
  14 // Copyright (C) 2017, Intel Corporation, all rights reserved.
  15 // Third party copyrights are property of their respective owners.
  16 //
  17 // Redistribution and use in source and binary forms, with or without modification,
  18 // are permitted provided that the following conditions are met:
  19 //
  20 //   * Redistribution's of source code must retain the above copyright notice,
  21 //     this list of conditions and the following disclaimer.
  22 //
  23 //   * Redistribution's in binary form must reproduce the above copyright notice,
  24 //     this list of conditions and the following disclaimer in the documentation
  25 //     and/or other materials provided with the distribution.
  26 //
  27 //   * The name of the copyright holders may not be used to endorse or promote products
  28 //     derived from this software without specific prior written permission.
  29 //
  30 // This software is provided by the copyright holders and contributors "as is" and
  31 // any express or implied warranties, including, but not limited to, the implied
  32 // warranties of merchantability and fitness for a particular purpose are disclaimed.
  33 // In no event shall the Intel Corporation or contributors be liable for any direct,
  34 // indirect, incidental, special, exemplary, or consequential damages
  35 // (including, but not limited to, procurement of substitute goods or services;
  36 // loss of use, data, or profits; or business interruption) however caused
  37 // and on any theory of liability, whether in contract, strict liability,
  38 // or tort (including negligence or otherwise) arising in any way out of
  39 // the use of this software, even if advised of the possibility of such damage.
  40 //
  41 //M*/
  42
  43 #include "../precomp.hpp"
  44 #include "layers_common.hpp"
  45 #include "../op_halide.hpp"
  46 #include "../op_inf_engine.hpp"
  47 #include "opencv2/core/hal/hal.hpp"
  48 #include "opencv2/core/hal/intrin.hpp"
  49 #include <iostream>
  50
  51 #ifdef HAVE_OPENCL
  52 #include "opencl_kernels_dnn.hpp"
  53 using namespace cv::dnn::ocl4dnn;
  54 #endif
  55
  56 namespace cv
  57 {
  58 namespace dnn
  59 {
  60
  61 class BaseConvolutionLayerImpl : public ConvolutionLayer
  62 {
  63 public:
  64     bool newWeightAndBias;
  65     std::vector<double> weightsMultipliers;
  66     BaseConvolutionLayerImpl(const LayerParams &params)
  67     {
  68         setParamsFrom(params);
  69         getConvolutionKernelParams(params, kernel_size, pads_begin, pads_end, strides, dilations, padMode);
  70
  71         numOutput = params.get<int>("num_output");
  72         int ngroups = params.get<int>("group", 1);
  73         CV_Assert(numOutput % ngroups == 0);
  74
  75         if (kernel_size.size() == 2) {
  76             kernel = Size(kernel_size[1], kernel_size[0]);
  77             stride = Size(strides[1], strides[0]);
  78             for (int i = 0; i < pads_begin.size(); i++) {
  79                 if (pads_begin[i] != pads_end[i])
  80                     CV_Error(Error::StsNotImplemented, "Unsupported asymmetric padding in convolution layer");
  81             }
  82             pad = Size(pads_begin[1], pads_begin[0]);
  83             dilation = Size(dilations[1], dilations[0]);
  84
  85             adjust_pads.push_back(params.get<int>("adj_h", 0));
  86             adjust_pads.push_back(params.get<int>("adj_w", 0));
  87
  88             adjustPad.height = adjust_pads[0];
  89             adjustPad.width = adjust_pads[1];
  90             CV_Assert(adjustPad.width < stride.width &&
  91                       adjustPad.height < stride.height);
  92         }
  93         newWeightAndBias = false;
  94     }
  95
  96     virtual void finalize(InputArrayOfArrays inputs_arr, OutputArrayOfArrays outputs_arr) CV_OVERRIDE
  97     {
  98         std::vector<Mat> inputs, outputs;
  99         inputs_arr.getMatVector(inputs);
 100         outputs_arr.getMatVector(outputs);
 101
 102         CV_Assert(inputs.size() > 0);
 103
 104         CV_Assert(blobs.size() == 1 || blobs.size() == 2);
 105         CV_Assert(inputs[0].dims == outputs[0].dims);
 106         CV_Assert(blobs[0].dims == kernel_size.size() + 2);
 107         for (int i = 0; i < kernel_size.size(); i++) {
 108             CV_Assert(blobs[0].size[i + 2] == kernel_size[i]);
 109         }
 110
 111         const Mat &input = inputs[0];
 112         CV_Assert((input.dims == 4 || input.dims == 5) && (input.type() == CV_32F || input.type() == CV_16S));
 113         for (size_t i = 0; i < inputs.size(); i++)
 114         {
 115             CV_Assert(inputs[i].type() == input.type());
 116             CV_Assert((inputs[i].dims == 4 || inputs[i].dims == 5) && inputs[i].size[1] == input.size[1]);
 117             for (int j = 0; j < inputs[i].dims; j++) {
 118                 CV_Assert(inputs[i].size[j] == input.size[j]);
 119             }
 120         }
 121
 122         std::vector<int> inpShape;
 123         std::vector<int> outShape;
 124         for (int i = 2; i < inputs[0].dims; i++) {
 125             inpShape.push_back(inputs[0].size[i]);
 126             outShape.push_back(outputs[0].size[i]);
 127         }
 128         getConvPoolPaddings(inpShape, outShape, kernel_size, strides, padMode, dilations, pads_begin, pads_end);
 129         if (pads_begin.size() == 2) {
 130             for (int i = 0; i < pads_begin.size(); i++) {
 131                 if (pads_begin[i] != pads_end[i])
 132                     CV_Error(Error::StsNotImplemented, "Unsupported asymmetric padding in convolution layer");
 133             }
 134             pad = Size(pads_begin[1], pads_begin[0]);
 135         }
 136     }
 137
 138     bool hasBias() const
 139     {
 140         return blobs.size() >= 2;
 141     }
 142
 143     virtual MatShape computeColRowShape(const MatShape &inpShape, const MatShape &outShape) const = 0;
 144     bool is1x1() const
 145     {
 146         return (kernel.height == 1 && kernel.width == 1) &&
 147                (stride.height == 1 && stride.width == 1) &&
 148                (dilation.height == 1 && dilation.width == 1);
 149     }
 150
 151     virtual bool tryFuse(Ptr<Layer>& top) CV_OVERRIDE
 152     {
 153         Mat w, b;
 154         top->getScaleShift(w, b);
 155         if (!w.empty() || !b.empty())
 156         {
 157             fuseWeights(w, b);
 158             return true;
 159         }
 160         return false;
 161     }
 162
 163     virtual void fuseWeights(const Mat& w_, const Mat& b_) = 0;
 164
 165     virtual void applyHalideScheduler(Ptr<BackendNode>& node,
 166                                       const std::vector<Mat*> &inputs,
 167                                       const std::vector<Mat> &outputs,
 168                                       int targetId) const CV_OVERRIDE
 169     {
 170 #ifdef HAVE_HALIDE
 171         if (targetId != DNN_TARGET_CPU)
 172         {
 173             Layer::applyHalideScheduler(node, inputs, outputs, targetId);
 174             return;
 175         }
 176         Halide::Var x("x"), y("y"), c("c"), n("n"), tile("tile"), yi("yi"), yo("yo"), co("co"), ci("ci");
 177         Halide::Func& top = node.dynamicCast<HalideBackendNode>()->funcs[1];
 178         Halide::Func& padded_input = node.dynamicCast<HalideBackendNode>()->funcs[0];
 179
 180         int outW, outH, outC, outN;
 181         getCanonicalSize(outputs[0].size, &outW, &outH, &outC, &outN);
 182
 183         if (outW == 1 || outH <= 2)
 184             return;
 185
 186         if (is1x1() || outC <= 16)
 187             top.reorder(x, c, y)
 188                .split(y, yo, yi, 2)
 189                .fuse(yo, n, tile)
 190                .parallel(tile)
 191                .unroll(yi)
 192                .vectorize(x, outW >= 16 ? 16 : outW);
 193         else
 194             top.reorder(x, c, y)
 195                .split(y, yo, yi, 2)
 196                .split(c, co, ci, 16)
 197                .fuse(yo, co, tile).fuse(n, tile, tile)
 198                .parallel(tile)
 199                .unroll(yi)
 200                .vectorize(x, outW >= 16 ? 16 : outW);
 201         padded_input.compute_at(top, yi);
 202 #endif  // HAVE_HALIDE
 203     }
 204 };
 205
 206
 207 #define IS_POWER_LAYER(layer) \
 208             (!layer.empty() && !layer->type.compare("Power"))
 209 //TODO: simultaneously convolution and bias addition for cache optimization
 210 class ConvolutionLayerImpl CV_FINAL : public BaseConvolutionLayerImpl
 211 {
 212 public:
 213     enum { VEC_ALIGN = 8, DFT_TYPE = CV_32F };
 214     Mat weightsMat;
 215     std::vector<float> biasvec;
 216     std::vector<float> reluslope;
 217     Ptr<ActivationLayer> activ;
 218     bool fusedBias;
 219
 220 #ifdef HAVE_OPENCL
 221     Ptr<OCL4DNNConvSpatial<float> > convolutionOp;
 222     std::vector<UMat> umat_blobs;
 223     bool newActiv;
 224     ocl4dnnFusedActiv_t activType;
 225     float power;
 226 #endif
 227     ConvolutionLayerImpl(const LayerParams &params) : BaseConvolutionLayerImpl(params)
 228     {
 229         fusedBias = false;
 230 #ifdef HAVE_OPENCL
 231         newActiv = false;
 232         activType = OCL4DNN_CONV_FUSED_ACTIV_NONE;
 233         power = 0.f;
 234 #endif
 235     }
 236
 237     MatShape computeColRowShape(const MatShape &inpShape, const MatShape &outShape) const CV_OVERRIDE
 238     {
 239         Size out(outShape[3], outShape[2]);
 240         int inpGroupCn = blobs[0].size[1];
 241         int ksize = inpGroupCn * kernel.height * kernel.width;
 242         return shape(out.area(), ksize);
 243     }
 244
 245     virtual bool supportBackend(int backendId) CV_OVERRIDE
 246     {
 247 #ifdef HAVE_INF_ENGINE
 248         if (backendId == DNN_BACKEND_INFERENCE_ENGINE)
 249         {
 250             if (kernel_size.size() == 3)
 251                 return preferableTarget == DNN_TARGET_CPU;
 252             return INF_ENGINE_VER_MAJOR_GE(INF_ENGINE_RELEASE_2018R4) ||
 253                    (preferableTarget != DNN_TARGET_MYRIAD || dilation.width == dilation.height);
 254         }
 255         else
 256 #endif
 257             return (kernel_size.size() == 2) && (backendId == DNN_BACKEND_OPENCV || backendId == DNN_BACKEND_HALIDE);
 258     }
 259
 260     bool getMemoryShapes(const std::vector<MatShape> &inputs,
 261                          const int requiredOutputs,
 262                          std::vector<MatShape> &outputs,
 263                          std::vector<MatShape> &internals) const CV_OVERRIDE
 264     {
 265         CV_Assert(blobs.size() != 0);
 266         CV_Assert(!hasBias() || blobs[1].total() == (size_t)blobs[0].size[0]);
 267         CV_Assert(inputs.size() == (size_t)1);
 268
 269         internals.clear();
 270
 271         CV_Assert(inputs.size() != 0);
 272         std::vector<int> inpShape(inputs[0].begin() + 2, inputs[0].end());
 273
 274         int outCn = blobs[0].size[0];
 275         std::vector<int> outShape;
 276         outShape.push_back(inputs[0][0]);
 277         outShape.push_back(outCn);
 278
 279         int inpCn = inputs[0][1];
 280         if (padMode.empty())
 281         {
 282             for (int i = 0; i < inpShape.size(); i++)
 283                 outShape.push_back((inpShape[i] + pads_begin[i] + pads_end[i] - dilations[i] * (kernel_size[i] - 1) - 1) / strides[i] + 1);
 284         }
 285         else
 286         {
 287             getConvPoolOutParams(inpShape, kernel_size, strides, padMode, dilations, outShape);
 288         }
 289
 290         int ngroups = inpCn / blobs[0].size[1];
 291         if (ngroups == 0 || ngroups * blobs[0].size[1] != inpCn)
 292             CV_Error(Error::StsError, format("Number of input channels should "
 293                      "be multiple of %d but got %d", blobs[0].size[1], inpCn));
 294         CV_Assert(ngroups > 0 && inpCn % ngroups == 0 && outCn % ngroups == 0);
 295
 296         outputs.resize(1, outShape);
 297
 298         return false;
 299     }
 300
 301     virtual void finalize(InputArrayOfArrays inputs_arr, OutputArrayOfArrays outputs_arr) CV_OVERRIDE
 302     {
 303         BaseConvolutionLayerImpl::finalize(inputs_arr, outputs_arr);
 304
 305         CV_Assert(!blobs.empty());
 306         const int outCn = blobs[0].size[0];
 307         // prepare weightsMat where each row is aligned and has enough zero padding on the right to
 308         // use vectorized (i.e. with intrinsics) loops without tail processing
 309         Mat wm = blobs[0].reshape(1, outCn);
 310         if( wm.step1() % VEC_ALIGN != 0 )
 311         {
 312             int newcols = (int)alignSize(wm.step1(), VEC_ALIGN);
 313             Mat wm_buffer = Mat(outCn, newcols, wm.type());
 314             Mat wm_padding = wm_buffer.colRange(wm.cols, newcols);
 315             wm_padding.setTo(Scalar::all(0.));
 316             Mat wm_aligned = wm_buffer.colRange(0, wm.cols);
 317             wm.copyTo(wm_aligned);
 318             wm = wm_aligned;
 319         }
 320         weightsMat = wm;
 321         weightsMultipliers.assign(outCn, 1.0);
 322
 323         Mat biasMat = hasBias() ? blobs[1].reshape(1, outCn) : Mat();
 324         biasvec.resize(outCn+2);
 325         if( biasMat.empty() )
 326         {
 327             for(int i = 0; i < outCn; i++ )
 328                 biasvec[i] = 0.f;
 329         }
 330         else
 331         {
 332             for(int i = 0; i < outCn; i++ )
 333                 biasvec[i] = biasMat.at<float>(i);
 334         }
 335 #ifdef HAVE_OPENCL
 336         convolutionOp.release();
 337 #endif
 338     }
 339
 340     bool setActivation(const Ptr<ActivationLayer>& layer) CV_OVERRIDE
 341     {
 342         if (!activ.empty() && !layer.empty())
 343             return false;
 344
 345         activ = layer;
 346         if (activ.empty())
 347             reluslope.clear();
 348 #ifdef HAVE_OPENCL
 349         newActiv = true;
 350         activType = OCL4DNN_CONV_FUSED_ACTIV_NONE;
 351
 352         if (IS_DNN_OPENCL_TARGET(preferableTarget))
 353         {
 354             Ptr<PowerLayer> activ_power = activ.dynamicCast<PowerLayer>();
 355             if (!activ_power.empty())
 356             {
 357                 if (activ_power->scale != 1.f || activ_power->shift != 0.f)
 358                 {
 359                     const int outCh = blobs[0].size[0];
 360                     fuseWeights(Mat(1, outCh, CV_32F, Scalar(activ_power->scale)),
 361                                 Mat(1, outCh, CV_32F, Scalar(activ_power->shift)));
 362                 }
 363
 364                 power = activ_power->power;
 365                 activType = OCL4DNN_CONV_FUSED_ACTIV_POWER;
 366             }
 367             Ptr<TanHLayer> activ_tanh = activ.dynamicCast<TanHLayer>();
 368             if (!activ_tanh.empty())
 369             {
 370                 activType = OCL4DNN_CONV_FUSED_ACTIV_TANH;
 371             }
 372         }
 373 #endif
 374         return !activ.empty();
 375     }
 376
 377     void fuseWeights(const Mat& w_, const Mat& b_) CV_OVERRIDE
 378     {
 379         // Convolution weights have OIHW data layout. Parameters fusion in case of
 380         // (conv(I) + b1 ) * w + b2
 381         // means to replace convolution's weights to [w*conv(I)] and bias to [b1 * w + b2]
 382         const int outCn = weightsMat.size[0];
 383         Mat w = w_.total() == 1 ? Mat(1, outCn, CV_32F, Scalar(w_.at<float>(0))) : w_;
 384         Mat b = b_.total() == 1 ? Mat(1, outCn, CV_32F, Scalar(b_.at<float>(0))) : b_;
 385         CV_Assert_N(!weightsMat.empty(), biasvec.size() == outCn + 2,
 386                     w.empty() || outCn == w.total(), b.empty() || outCn == b.total());
 387
 388         if (!w.empty())
 389         {
 390             // Keep origin weights unchanged.
 391             if (weightsMat.data == blobs[0].data)
 392                 weightsMat = weightsMat.clone();
 393
 394             Mat originWeights = blobs[0].reshape(1, outCn);
 395             for (int i = 0; i < outCn; ++i)
 396             {
 397                 double wi = w.at<float>(i);
 398                 weightsMultipliers[i] *= wi;
 399                 cv::multiply(originWeights.row(i), weightsMultipliers[i], weightsMat.row(i));
 400                 biasvec[i] *= wi;
 401             }
 402         }
 403
 404         if (!b.empty())
 405         {
 406             for (int i = 0; i < outCn; ++i)
 407                 biasvec[i] += b.at<float>(i);
 408         }
 409
 410         newWeightAndBias = !w.empty() || !b.empty();
 411         fusedBias = hasBias() || !b.empty();
 412         biasvec[outCn] = biasvec[outCn+1] = biasvec[outCn-1];
 413     }
 414
 415     virtual Ptr<BackendNode> initHalide(const std::vector<Ptr<BackendWrapper> > &inputs) CV_OVERRIDE
 416     {
 417 #ifdef HAVE_HALIDE
 418         Halide::Buffer<float> inputBuffer = halideBuffer(inputs[0]);
 419
 420         const int inpCn = inputBuffer.channels();
 421         const int outCn = blobs[0].size[0];
 422         const int inpGroupCn = blobs[0].size[1];
 423         const int group = inpCn / inpGroupCn;
 424         const int outGroupCn = outCn / group;
 425
 426         Halide::Buffer<float> weights = wrapToHalideBuffer(blobs[0]);
 427
 428         Halide::Var x("x"), y("y"), c("c"), n("n");
 429         Halide::Func top = (name.empty() ? Halide::Func() : Halide::Func(name));
 430         Halide::Func padded_input(name + "_constant_exterior");
 431         if (pad.width || pad.height)
 432         {
 433             Halide::Func bounded =
 434                 Halide::BoundaryConditions::constant_exterior(inputBuffer, 0);
 435             padded_input(x, y, c, n) = bounded(x, y, c, n);
 436         }
 437         else
 438         {
 439             padded_input(x, y, c, n) = inputBuffer(x, y, c, n);
 440         }
 441
 442         Halide::RDom r(0, kernel.width, 0, kernel.height, 0, inpGroupCn);
 443         Halide::Expr kx = x * stride.width - pad.width + r.x * dilation.width;
 444         Halide::Expr ky = y * stride.height - pad.height + r.y * dilation.height;
 445         Halide::Expr kc = r.z;
 446         for (int i = 1; i < group; ++i)
 447         {
 448             kc = select(c < outGroupCn * i, kc, inpGroupCn * i + r.z);
 449         }
 450         Halide::Expr topExpr = sum(padded_input(kx, ky, kc, n) *
 451                                    weights(r.x, r.y, r.z, c));
 452         if (hasBias())
 453         {
 454             Halide::Buffer<float> bias = wrapToHalideBuffer(blobs[1], {outCn});
 455             topExpr += bias(c);
 456         }
 457         top(x, y, c, n) = topExpr;
 458         return Ptr<BackendNode>(new HalideBackendNode({ padded_input, top }));
 459 #endif  // HAVE_HALIDE
 460         return Ptr<BackendNode>();
 461     }
 462
 463     virtual Ptr<BackendNode> initInfEngine(const std::vector<Ptr<BackendWrapper> > &inputs) CV_OVERRIDE
 464     {
 465 #ifdef HAVE_INF_ENGINE
 466         InferenceEngine::DataPtr input = infEngineDataNode(inputs[0]);
 467         CV_Assert(input->dims.size() == 4 || input->dims.size() == 5);
 468
 469         const int inpCn = input->dims[input->dims.size() - 2];  // NOTE: input->dims are reversed (WHIO or WHDIO)
 470         const int outCn = blobs[0].size[0];
 471         const int inpGroupCn = blobs[0].size[1];
 472         const int group = inpCn / inpGroupCn;
 473
 474         InferenceEngine::Layout layout = (input->dims.size() == 4) ? InferenceEngine::Layout::OIHW :
 475                                                                      InferenceEngine::Layout::NCDHW;
 476
 477         auto ieWeights = wrapToInfEngineBlob(blobs[0], layout);
 478         if (newWeightAndBias)
 479         {
 480             if (weightsMat.isContinuous())
 481             {
 482                 Mat fusedWeights = weightsMat.reshape(1, blobs[0].dims, blobs[0].size);
 483                 ieWeights = wrapToInfEngineBlob(fusedWeights, layout);
 484             }
 485             else
 486             {
 487                 ieWeights = InferenceEngine::make_shared_blob<float>(
 488                                     InferenceEngine::Precision::FP32, layout,
 489                                     ieWeights->dims());
 490                 ieWeights->allocate();
 491
 492                 Mat newWeights = infEngineBlobToMat(ieWeights).reshape(1, outCn);
 493                 Mat fusedWeights = weightsMat.colRange(0, newWeights.cols);
 494                 fusedWeights.copyTo(newWeights);
 495             }
 496         }
 497         InferenceEngine::Blob::Ptr ieBiases;
 498         if (hasBias() || fusedBias)
 499         {
 500             Mat biasesMat({outCn}, CV_32F, &biasvec[0]);
 501             ieBiases = wrapToInfEngineBlob(biasesMat, {(size_t)outCn}, InferenceEngine::Layout::C);
 502         }
 503
 504 #if INF_ENGINE_VER_MAJOR_GE(INF_ENGINE_RELEASE_2018R5)
 505         InferenceEngine::Builder::ConvolutionLayer ieLayer(name);
 506
 507         ieLayer.setKernel(kernel_size);
 508         ieLayer.setStrides(strides);
 509         ieLayer.setDilation(dilations);
 510         ieLayer.setPaddingsBegin(pads_begin);
 511         ieLayer.setPaddingsEnd(pads_end);
 512         ieLayer.setGroup((size_t)group);
 513         ieLayer.setOutDepth((size_t)outCn);
 514
 515         InferenceEngine::Builder::Layer l = ieLayer;
 516         addConstantData("weights", ieWeights, l);
 517         if (ieBiases)
 518             addConstantData("biases", ieBiases, l);
 519
 520         if (!padMode.empty())
 521             l.getParameters()["auto_pad"] = padMode == "VALID" ? std::string("valid") : std::string("same_upper");
 522
 523         return Ptr<BackendNode>(new InfEngineBackendNode(l));
 524 #else
 525         InferenceEngine::LayerParams lp;
 526         lp.name = name;
 527         lp.type = "Convolution";
 528         lp.precision = InferenceEngine::Precision::FP32;
 529         std::shared_ptr<InferenceEngine::ConvolutionLayer> ieLayer(new InferenceEngine::ConvolutionLayer(lp));
 530
 531 #if INF_ENGINE_VER_MAJOR_GT(INF_ENGINE_RELEASE_2018R3)
 532         ieLayer->_kernel.insert(InferenceEngine::X_AXIS, kernel.width);
 533         ieLayer->_kernel.insert(InferenceEngine::Y_AXIS, kernel.height);
 534         ieLayer->_stride.insert(InferenceEngine::X_AXIS, stride.width);
 535         ieLayer->_stride.insert(InferenceEngine::Y_AXIS, stride.height);
 536         ieLayer->_padding.insert(InferenceEngine::X_AXIS, pad.width);
 537         ieLayer->_padding.insert(InferenceEngine::Y_AXIS, pad.height);
 538         ieLayer->_pads_end.insert(InferenceEngine::X_AXIS, pad.width);
 539         ieLayer->_pads_end.insert(InferenceEngine::Y_AXIS, pad.height);
 540         ieLayer->_dilation.insert(InferenceEngine::X_AXIS, dilation.width);
 541         ieLayer->_dilation.insert(InferenceEngine::Y_AXIS, dilation.height);
 542         ieLayer->params["output"] = format("%d", outCn);
 543         ieLayer->params["kernel"] = format("%d,%d,%d,%d", outCn, inpGroupCn, kernel.height, kernel.width);
 544         ieLayer->params["pads_begin"] = format("%d,%d", pad.height, pad.width);
 545         ieLayer->params["pads_end"] = format("%d,%d", pad.height, pad.width);
 546         ieLayer->params["strides"] = format("%d,%d", stride.height, stride.width);
 547         ieLayer->params["dilations"] = format("%d,%d", dilation.height, dilation.width);
 548 #else
 549         ieLayer->_kernel_x = kernel.width;
 550         ieLayer->_kernel_y = kernel.height;
 551         ieLayer->_stride_x = stride.width;
 552         ieLayer->_stride_y = stride.height;
 553         ieLayer->_padding_x = pad.width;
 554         ieLayer->_padding_y = pad.height;
 555         ieLayer->_dilation_x = dilation.width;
 556         ieLayer->_dilation_y = dilation.height;
 557 #endif
 558         ieLayer->_out_depth = outCn;
 559         ieLayer->_group = group;
 560
 561         ieLayer->_weights = ieWeights;
 562         if (ieBiases)
 563             ieLayer->_biases = ieBiases;
 564         return Ptr<BackendNode>(new InfEngineBackendNode(ieLayer));
 565 #endif
 566 #endif  // HAVE_INF_ENGINE
 567         return Ptr<BackendNode>();
 568     }
 569
 570     class ParallelConv : public cv::ParallelLoopBody
 571     {
 572     public:
 573         enum { BLK_SIZE = 32, BLK_SIZE_CN = 64 };
 574
 575         const Mat* input_;
 576         const Mat* weights_;
 577         Mat* output_;
 578         int outShape[4];
 579         Size kernel_, pad_, stride_, dilation_;
 580         int ngroups_, nstripes_;
 581         std::vector<int> ofstab_;
 582         const std::vector<float>* biasvec_;
 583         const std::vector<float>* reluslope_;
 584         const ActivationLayer* activ_;
 585         bool is1x1_;
 586         bool useAVX;
 587         bool useAVX2;
 588         bool useAVX512;
 589
 590         ParallelConv()
 591             : input_(0), weights_(0), output_(0), ngroups_(0), nstripes_(0),
 592               biasvec_(0), reluslope_(0), activ_(0), is1x1_(false), useAVX(false), useAVX2(false), useAVX512(false)
 593         {}
 594
 595         static void run( const Mat& input, Mat& output, const Mat& weights,
 596                          const std::vector<float>& biasvec,
 597                          const std::vector<float>& reluslope,
 598                          Size kernel, Size pad, Size stride, Size dilation,
 599                          const ActivationLayer* activ, int ngroups, int nstripes )
 600         {
 601             CV_Assert_N(
 602                        input.dims == 4 && output.dims == 4,
 603                        input.size[0] == output.size[0],
 604                        weights.rows == output.size[1],
 605                        weights.cols == (input.size[1]/ngroups)*kernel.width*kernel.height,
 606                        input.type() == output.type(),
 607                        input.type() == weights.type(),
 608                        input.type() == CV_32FC1,
 609                        input.isContinuous(),
 610                        output.isContinuous(),
 611                        biasvec.size() == (size_t)output.size[1]+2);
 612             ParallelConv p;
 613
 614             p.input_ = &input;
 615             p.weights_ = &weights;
 616             p.output_ = &output;
 617             for( int i = 0; i < 4; i++ ) p.outShape[i] = output.size[i];
 618             p.outShape[1] /= ngroups;
 619             p.kernel_ = kernel; p.pad_ = pad; p.stride_ = stride; p.dilation_ = dilation;
 620             p.ngroups_ = ngroups;
 621             p.nstripes_ = nstripes;
 622
 623             int inpCnAll = input.size[1], width = input.size[3], height = input.size[2];
 624             int inpCn = inpCnAll / ngroups;
 625             p.is1x1_ = kernel == Size(1,1) && pad == Size(0, 0);
 626             p.useAVX = checkHardwareSupport(CPU_AVX);
 627             p.useAVX2 = checkHardwareSupport(CPU_AVX2);
 628             p.useAVX512 = CV_CPU_HAS_SUPPORT_AVX512_SKX;
 629
 630             int ncn = std::min(inpCn, (int)BLK_SIZE_CN);
 631             p.ofstab_.resize(kernel.width*kernel.height*ncn);
 632             int* ofstab = &p.ofstab_[0];
 633
 634             for( int k = 0; k < ncn; k++ )
 635                 for( int k_r = 0; k_r < kernel.height; k_r++ )
 636                     for( int k_c = 0; k_c < kernel.width; k_c++ )
 637                         ofstab[(k*kernel.height + k_r)*kernel.width + k_c] =
 638                         (k*height + k_r*dilation.height)*width + k_c*dilation.width;
 639
 640             p.biasvec_ = &biasvec;
 641             p.reluslope_ = &reluslope;
 642             p.activ_ = p.reluslope_->empty() ? activ : 0;
 643
 644             parallel_for_(Range(0, nstripes), p, nstripes);
 645         }
 646
 647         virtual void operator ()(const Range &r0) const CV_OVERRIDE
 648         {
 649             const int valign = ConvolutionLayerImpl::VEC_ALIGN;
 650             int ngroups = ngroups_, batchSize = input_->size[0]*ngroups;
 651             int outW = output_->size[3], outH = output_->size[2], outCn = output_->size[1]/ngroups;
 652             int width = input_->size[3], height = input_->size[2], inpCn = input_->size[1]/ngroups;
 653             const int nstripes = nstripes_;
 654             int kernel_w = kernel_.width, kernel_h = kernel_.height;
 655             int pad_w = pad_.width, pad_h = pad_.height;
 656             int stride_w = stride_.width, stride_h = stride_.height;
 657             int dilation_w = dilation_.width, dilation_h = dilation_.height;
 658             int karea = kernel_w*kernel_h;
 659             int i, j, k;
 660             size_t inpPlaneSize = width*height;
 661             size_t outPlaneSize = outW*outH;
 662             bool is1x1 = is1x1_;
 663
 664             int stripesPerSample;
 665             size_t stripeSize;
 666             Range r = r0;
 667
 668             if( nstripes >= batchSize*2 )
 669             {
 670                 stripesPerSample = nstripes/batchSize;
 671                 stripeSize = alignSize((outPlaneSize + stripesPerSample - 1)/stripesPerSample, valign);
 672                 stripeSize = std::min(stripeSize, outPlaneSize);
 673             }
 674             else
 675             {
 676                 stripesPerSample = 1;
 677                 int samplesPerStripe = std::max((batchSize + nstripes - 1)/nstripes, 1);
 678                 r.start *= samplesPerStripe;
 679                 r.end *= samplesPerStripe;
 680                 stripeSize = outPlaneSize;
 681             }
 682
 683             const float* data_inp0_ = input_->ptr<float>();
 684             const int* ofstab = &ofstab_[0];
 685             const float* wptr_orig_ = weights_->ptr<float>();
 686             size_t wstep = weights_->step1();
 687             const float* biasptr_ = &biasvec_->at(0);
 688             const float* reluptr_ = reluslope_->empty() ? 0 : &reluslope_->at(0);
 689             float* data_out0_ = output_->ptr<float>();
 690             size_t rowbufsz = (size_t)karea*BLK_SIZE_CN*BLK_SIZE;
 691             AutoBuffer<float> rowbuf0_(rowbufsz + valign);
 692             float* rowbuf0 = alignPtr(rowbuf0_.data(), (int)(valign*sizeof(float)));
 693
 694             // we clear the buffer once; ultimately, it lets us to avoid
 695             // tail processing after running the unrolled/vectorized loop.
 696             // the main idea is to make sure that the tail (a.k.a. padding) of each row
 697             // (i.e. the elements with indices between vsz=karea*ncn and vsz_a)
 698             // does not contain NaNs or Infs. Because the padding in the weights
 699             // matrix is explicitly initialized with 0's, we handle all other
 700             // cases nicely, i.e. we can skip expliciting re-initialization
 701             // of the padding - we just retain elements from the previous iteration
 702             // of the loop over channels (cn0).
 703             memset(rowbuf0, 0, rowbufsz*sizeof(rowbuf0[0]) );
 704
 705             for( int stripe = r.start; stripe < r.end; stripe++ )
 706             {
 707                 int subsampleIdx = stripe/stripesPerSample;
 708                 if( subsampleIdx >= batchSize )
 709                     break;
 710                 int stripeStart = (int)((stripe - subsampleIdx*stripesPerSample)*stripeSize);
 711                 int stripeEnd = (int)std::min(stripeStart + stripeSize, outPlaneSize);
 712                 const float* data_inp0 = data_inp0_ + subsampleIdx*inpPlaneSize*inpCn;
 713                 float* data_out0 = data_out0_ + subsampleIdx*outPlaneSize*outCn;
 714                 int startOutCn = (subsampleIdx % ngroups)*outCn;
 715                 const float* wptr_orig = wptr_orig_ + wstep*startOutCn;
 716                 const float* biasptr = biasptr_ + startOutCn;
 717
 718                 for( int cn0 = 0; cn0 < inpCn; cn0 += BLK_SIZE_CN )
 719                 {
 720                     int cn1 = std::min(cn0 + BLK_SIZE_CN, inpCn);
 721                     int ncn = cn1 - cn0, vsz = karea*ncn;
 722                     int vsz_a = (int)alignSize(vsz, valign);
 723                     const float* wptr = wptr_orig + cn0*karea;
 724                     // we apply [Channels][P]ReLU (if any) during the final pass only.
 725                     const float* relu = cn1 == inpCn && reluptr_ ? reluptr_ + startOutCn : 0;
 726
 727                     for( int ofs0 = stripeStart; ofs0 < stripeEnd; ofs0 += BLK_SIZE )
 728                     {
 729                         int ofs, ofs1 = std::min(ofs0 + BLK_SIZE, stripeEnd);
 730                         int out_i = ofs0 / outW;
 731                         int out_j = ofs0 - out_i * outW;
 732
 733                         // do im2row for a part of input tensor
 734                         float* rowbuf = rowbuf0;
 735                         for( ofs = ofs0; ofs < ofs1; out_j = 0, ++out_i )
 736                         {
 737                             int delta = std::min(ofs1 - ofs, outW - out_j);
 738                             int out_j1 = out_j + delta;
 739                             int in_i = out_i * stride_h - pad_h;
 740                             int in_j = out_j * stride_w - pad_w;
 741                             const float* imgptr = data_inp0 + (cn0*height + in_i)*width + in_j;
 742                             ofs += delta;
 743
 744                             // do im2row for a part of input tensor
 745                             if( is1x1 )
 746                             {
 747                                 for( ; out_j < out_j1; out_j++, rowbuf += vsz_a, imgptr += stride_w )
 748                                 {
 749                                     for( k = 0; k < vsz; k++ )
 750                                         rowbuf[k] = imgptr[k*inpPlaneSize];
 751                                 }
 752                             }
 753                             else
 754                             {
 755                                 bool ok_i = 0 <= in_i && in_i < height - (kernel_h-1)*dilation_h;
 756                                 int i0 = std::max(0, (-in_i + dilation_h-1)/dilation_h);
 757                                 int i1 = std::min(kernel_h, (height - in_i + dilation_h-1)/dilation_h);
 758
 759                                 for( ; out_j < out_j1; out_j++, rowbuf += vsz_a, imgptr += stride_w, in_j += stride_w )
 760                                 {
 761                                     // this condition should be true for most of the tensor elements, i.e.
 762                                     // most of the time the kernel aperture is inside the tensor X-Y plane.
 763                                     if( ok_i && out_j + 2 <= out_j1 && 0 <= in_j && in_j + stride_w*2 <= width - (kernel_w-1)*dilation_w )
 764                                     {
 765                                         for( k = 0; k < vsz; k++ )
 766                                         {
 767                                             int k1 = ofstab[k];
 768                                             float v0 = imgptr[k1];
 769                                             float v1 = imgptr[k1 + stride_w];
 770                                             rowbuf[k] = v0;
 771                                             rowbuf[k+vsz_a] = v1;
 772                                         }
 773                                         out_j++;
 774                                         rowbuf += vsz_a;
 775                                         imgptr += stride_w;
 776                                         in_j += stride_w;
 777                                     }
 778                                     else
 779                                     {
 780                                         int j0 = std::max(0, (-in_j + dilation_w-1)/dilation_w);
 781                                         int j1 = std::min(kernel_w, (width - in_j + dilation_w-1)/dilation_w);
 782
 783                                         // here some non-continuous sub-row of the row will not be
 784                                         // filled from the tensor; we need to make sure that the uncovered
 785                                         // elements are explicitly set to 0's. the easiest way is to
 786                                         // set all the elements to 0's before the loop.
 787                                         memset(rowbuf, 0, vsz*sizeof(rowbuf[0]));
 788                                         for( k = 0; k < ncn; k++ )
 789                                         {
 790                                             for( i = i0; i < i1; i++ )
 791                                             {
 792                                                 for( j = j0; j < j1; j++ )
 793                                                 {
 794                                                     int imgofs = k*(width*height) + i*(dilation_h*width) + j*dilation_w;
 795                                                     rowbuf[(k*kernel_h + i)*kernel_w + j] = imgptr[imgofs];
 796                                                 }
 797                                             }
 798                                         }
 799                                     }
 800                                 }
 801                             }
 802                         }
 803
 804                         // now compute dot product of the weights
 805                         // and im2row-transformed part of the tensor
 806                         int bsz = ofs1 - ofs0;
 807                     #if CV_TRY_AVX512_SKX
 808                         /* AVX512 convolution requires an alignment of 16, and ROI is only there for larger vector sizes */
 809                         if(useAVX512)
 810                             opt_AVX512_SKX::fastConv(wptr, wstep, biasptr, rowbuf0, data_out0 + ofs0,
 811                                           outShape, bsz, vsz, vsz_a, relu, cn0 == 0);
 812                         else
 813                     #endif
 814                     #if CV_TRY_AVX2
 815                         if(useAVX2)
 816                             opt_AVX2::fastConv(wptr, wstep, biasptr, rowbuf0, data_out0 + ofs0,
 817                                           outShape, bsz, vsz, vsz_a, relu, cn0 == 0);
 818                         else
 819                     #endif
 820                     #if CV_TRY_AVX
 821                         if(useAVX)
 822                             opt_AVX::fastConv(wptr, wstep, biasptr, rowbuf0, data_out0 + ofs0,
 823                                          outShape, bsz, vsz, vsz_a, relu, cn0 == 0);
 824                         else
 825                     #endif
 826                         for( int i = 0; i < outCn; i += 2 )
 827                         {
 828                             const float* wptr0 = wptr + i*wstep;
 829                             const float* wptr1 = wptr0 + wstep;
 830                             float* outptr0 = data_out0 + ofs0 + i*outPlaneSize;
 831                             float* outptr1 = outptr0 + outPlaneSize;
 832                             float bias0 = biasptr[i], bias1 = biasptr[i+1];
 833                             float r0 = 1.f, r1 = 1.f;
 834
 835                             if( i+1 >= outCn )
 836                             {
 837                                 wptr1 = wptr0;
 838                                 outptr1 = outptr0;
 839                                 bias1 = bias0;
 840                             }
 841
 842                             if( relu )
 843                             {
 844                                 r0 = relu[i]; r1 = relu[i+1];
 845                                 if( i+1 >= outCn )
 846                                     r1 = r0;
 847                             }
 848
 849                             int j = 0;
 850                         #if CV_SIMD128
 851                             v_float32x4 vr0 = v_setall_f32(r0), vr1 = v_setall_f32(r1), z = v_setzero_f32();
 852
 853                             for( ; j <= bsz - 4; j += 4 )
 854                             {
 855                                 const float* rptr = rowbuf0 + j*vsz_a;
 856                                 v_float32x4 s0, s1;
 857
 858                                 if( cn0 == 0 )
 859                                 {
 860                                     s0 = v_setall_f32(bias0);
 861                                     s1 = v_setall_f32(bias1);
 862                                 }
 863                                 else
 864                                 {
 865                                     s0 = v_load(outptr0 + j);
 866                                     s1 = v_load(outptr1 + j);
 867                                 }
 868
 869                                 v_float32x4 vs00 = v_setzero_f32(), vs01 = v_setzero_f32(),
 870                                             vs02 = v_setzero_f32(), vs03 = v_setzero_f32(),
 871                                             vs10 = v_setzero_f32(), vs11 = v_setzero_f32(),
 872                                             vs12 = v_setzero_f32(), vs13 = v_setzero_f32();
 873                                 for( k = 0; k < vsz; k += 4, rptr += 4 )
 874                                 {
 875                                     v_float32x4 w0 = v_load_aligned(wptr0 + k), w1 = v_load_aligned(wptr1 + k);
 876                                     v_float32x4 r0 = v_load_aligned(rptr), r1 = v_load_aligned(rptr + vsz_a),
 877                                                 r2 = v_load_aligned(rptr + vsz_a*2), r3 = v_load_aligned(rptr + vsz_a*3);
 878
 879                                     vs00 += w0*r0;
 880                                     vs01 += w0*r1;
 881                                     vs02 += w0*r2;
 882                                     vs03 += w0*r3;
 883
 884                                     vs10 += w1*r0;
 885                                     vs11 += w1*r1;
 886                                     vs12 += w1*r2;
 887                                     vs13 += w1*r3;
 888                                 }
 889                                 s0 += v_reduce_sum4(vs00, vs01, vs02, vs03);
 890                                 s1 += v_reduce_sum4(vs10, vs11, vs12, vs13);
 891                                 if( relu )
 892                                 {
 893                                     s0 = v_select(s0 > z, s0, s0*vr0);
 894                                     s1 = v_select(s1 > z, s1, s1*vr1);
 895                                 }
 896
 897                                 v_store(outptr0 + j, s0);
 898                                 v_store(outptr1 + j, s1);
 899                             }
 900                         #endif
 901                             for( ; j < bsz; j++ )
 902                             {
 903                                 const float* rptr = rowbuf0 + j*vsz_a;
 904                                 float s00, s10;
 905
 906                                 if( cn0 == 0 )
 907                                 {
 908                                     s00 = bias0;
 909                                     s10 = bias1;
 910                                 }
 911                                 else
 912                                 {
 913                                     s00 = outptr0[j];
 914                                     s10 = outptr1[j];
 915                                 }
 916
 917                                 for( k = 0; k < vsz; k++ )
 918                                 {
 919                                     float r0 = rptr[k];
 920                                     s00 += wptr0[k]*r0;
 921                                     s10 += wptr1[k]*r0;
 922                                 }
 923                                 if( relu )
 924                                 {
 925                                     s00 = s00 > 0.f ? s00 : s00*r0;
 926                                     s10 = s10 > 0.f ? s10 : s10*r1;
 927                                 }
 928
 929                                 outptr0[j] = s00;
 930                                 outptr1[j] = s10;
 931                             }
 932                         }
 933                     }
 934                 }
 935
 936                 if( activ_ )
 937                     activ_->forwardSlice(data_out0 + stripeStart, data_out0 + stripeStart,
 938                                          (int)(stripeEnd - stripeStart),
 939                                          outPlaneSize, startOutCn, startOutCn + outCn);
 940             }
 941         }
 942     };
 943
 944 #ifdef HAVE_OPENCL
 945     bool forward_ocl(InputArrayOfArrays inps, OutputArrayOfArrays outs, OutputArrayOfArrays internals)
 946     {
 947         std::vector<UMat> inputs;
 948         std::vector<UMat> outputs;
 949
 950         bool use_half = (inps.depth() == CV_16S);
 951         inps.getUMatVector(inputs);
 952         outs.getUMatVector(outputs);
 953
 954         CV_Assert(outputs.size() == 1);
 955         for (int i = 0; i < inputs.size(); ++i)
 956             CV_Assert(inputs[i].u != outputs[0].u);
 957
 958         if (umat_blobs.empty())
 959         {
 960             size_t n = blobs.size();
 961             umat_blobs.resize(n);
 962             for (size_t i = 0; i < n; i++)
 963             {
 964                 blobs[i].copyTo(umat_blobs[i]);
 965             }
 966         }
 967
 968         if (convolutionOp.empty())
 969         {
 970             OCL4DNNConvConfig config;
 971             config.in_shape = shape(inputs[0]);
 972             config.out_shape = shape(outputs[0]);
 973             config.kernel = kernel;
 974             config.pad = pad;
 975             config.stride = stride;
 976             config.dilation = dilation;
 977             config.group = inputs[0].size[1] / umat_blobs[0].size[1];
 978             config.bias_term = (hasBias()) ? true : false;
 979             config.use_half = use_half;
 980
 981             convolutionOp = Ptr<OCL4DNNConvSpatial<float> >(new OCL4DNNConvSpatial<float>(config));
 982         }
 983
 984         int outCn = umat_blobs[0].size[0];
 985
 986         reluslope.clear();
 987         if( activ )
 988         {
 989             Ptr<ReLULayer> activ_relu = activ.dynamicCast<ReLULayer>();
 990             if( !activ_relu.empty() )
 991             {
 992                 reluslope.assign(outCn+2, activ_relu->negativeSlope);
 993                 activType = OCL4DNN_CONV_FUSED_ACTIV_RELU;
 994             }
 995
 996             Ptr<ReLU6Layer> activ_relu6 = activ.dynamicCast<ReLU6Layer>();
 997             if( !activ_relu6.empty() )
 998             {
 999                 reluslope.resize(2);
1000                 reluslope[0] = activ_relu6->minValue;
1001                 reluslope[1] = activ_relu6->maxValue;
1002                 activType = OCL4DNN_CONV_FUSED_ACTIV_RELU6;
1003             }
1004
1005             Ptr<ChannelsPReLULayer> activ_chprelu = activ.dynamicCast<ChannelsPReLULayer>();
1006             if( !activ_chprelu.empty() )
1007             {
1008                 const Mat& m = activ_chprelu->blobs[0];
1009                 CV_Assert(m.isContinuous() && m.type() == CV_32F && (int)m.total() == outCn);
1010                 const float* mdata = m.ptr<float>();
1011                 reluslope.resize(outCn+2);
1012                 std::copy(mdata, mdata + outCn, reluslope.begin());
1013                 reluslope[outCn] = reluslope[outCn+1] = reluslope[outCn-1];
1014                 activType = OCL4DNN_CONV_FUSED_ACTIV_PRELU;
1015             }
1016         }
1017
1018         if ( newWeightAndBias )
1019         {
1020             weightsMat.copyTo(umat_blobs[0]);
1021             if ( fusedBias )
1022             {
1023                 if ( umat_blobs.size() < 2 )
1024                     umat_blobs.resize(2);
1025                 umat_blobs[1] = UMat(biasvec, true);
1026             }
1027             convolutionOp->setBias(fusedBias || hasBias());
1028             newWeightAndBias = false;
1029         }
1030
1031         if ( newActiv )
1032         {
1033             if ( activType == OCL4DNN_CONV_FUSED_ACTIV_RELU )
1034             {
1035                 CV_Assert(!reluslope.empty());
1036                 convolutionOp->setActivReLU(true, reluslope[0]);
1037             }
1038             else if ( activType == OCL4DNN_CONV_FUSED_ACTIV_PRELU)
1039             {
1040                 CV_Assert(!reluslope.empty());
1041                 convolutionOp->setActivPReLU(true, reluslope);
1042             }
1043             else if ( activType == OCL4DNN_CONV_FUSED_ACTIV_POWER)
1044             {
1045                 convolutionOp->setActivPower(true, power);
1046             }
1047             else if ( activType == OCL4DNN_CONV_FUSED_ACTIV_TANH)
1048             {
1049                 convolutionOp->setActivTanh(true);
1050             }
1051             else if ( activType == OCL4DNN_CONV_FUSED_ACTIV_RELU6)
1052             {
1053                 convolutionOp->setActivReLU6(true, reluslope[0], reluslope[1]);
1054             }
1055             else
1056             {
1057                 convolutionOp->setActivReLU(false, 0);
1058                 convolutionOp->setActivPReLU(false, reluslope);
1059                 convolutionOp->setActivPower(false, 1.f);
1060                 convolutionOp->setActivTanh(false);
1061                 convolutionOp->setActivReLU6(false, 0, 0);
1062             }
1063             newActiv = false;
1064         }
1065
1066         UMat& inpMat = inputs[0];
1067         UMat& outMat = outputs[0];
1068         int batch_size = inpMat.size[0];
1069
1070         return convolutionOp->Forward(inpMat,
1071                                       inputs.size() == 2 ? inputs[1] : UMat(),
1072                                       umat_blobs[0],
1073                                       (hasBias() || fusedBias) ? umat_blobs[1] : UMat(),
1074                                       outMat,
1075                                       batch_size);
1076     }
1077 #endif
1078
1079     void forward(InputArrayOfArrays inputs_arr, OutputArrayOfArrays outputs_arr, OutputArrayOfArrays internals_arr) CV_OVERRIDE
1080     {
1081         CV_TRACE_FUNCTION();
1082         CV_TRACE_ARG_VALUE(name, "name", name.c_str());
1083
1084         CV_OCL_RUN(IS_DNN_OPENCL_TARGET(preferableTarget),
1085                    forward_ocl(inputs_arr, outputs_arr, internals_arr))
1086
1087         if (inputs_arr.depth() == CV_16S)
1088         {
1089             forward_fallback(inputs_arr, outputs_arr, internals_arr);
1090             return;
1091         }
1092
1093         std::vector<Mat> inputs, outputs;
1094         inputs_arr.getMatVector(inputs);
1095         outputs_arr.getMatVector(outputs);
1096
1097         /*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",
1098                name.c_str(), inputs[0].size[0], inputs[0].size[1], inputs[0].size[2], inputs[0].size[3],
1099                kernel.width, kernel.height, pad.width, pad.height,
1100                stride.width, stride.height, dilation.width, dilation.height);*/
1101         CV_Assert_N(inputs.size() == (size_t)1, inputs[0].size[1] % blobs[0].size[1] == 0,
1102                     outputs.size() == 1, inputs[0].data != outputs[0].data);
1103
1104         if (inputs[0].dims == 5) {
1105             CV_Error(Error::StsNotImplemented, "Convolution3D layer is not supported on OCV backend");
1106         }
1107
1108         int ngroups = inputs[0].size[1]/blobs[0].size[1];
1109         CV_Assert(outputs[0].size[1] % ngroups == 0);
1110         int outCn = blobs[0].size[0];
1111
1112         reluslope.clear();
1113         if( activ )
1114         {
1115             Ptr<ReLULayer> activ_relu = activ.dynamicCast<ReLULayer>();
1116             if( !activ_relu.empty() )
1117             {
1118                 reluslope.assign(outCn+2, activ_relu->negativeSlope);
1119             }
1120
1121             Ptr<ChannelsPReLULayer> activ_chprelu = activ.dynamicCast<ChannelsPReLULayer>();
1122             if( !activ_chprelu.empty() )
1123             {
1124                 const Mat& m = activ_chprelu->blobs[0];
1125                 CV_Assert(m.isContinuous() && m.type() == CV_32F && (int)m.total() == outCn);
1126                 const float* mdata = m.ptr<float>();
1127                 reluslope.resize(outCn+2);
1128                 std::copy(mdata, mdata + outCn, reluslope.begin());
1129                 reluslope[outCn] = reluslope[outCn+1] = reluslope[outCn-1];
1130             }
1131         }
1132
1133         int nstripes = std::max(getNumThreads(), 1);
1134
1135         ParallelConv::run(inputs[0], outputs[0], weightsMat, biasvec, reluslope,
1136                           kernel, pad, stride, dilation, activ.get(), ngroups, nstripes);
1137     }
1138
1139     virtual int64 getFLOPS(const std::vector<MatShape> &inputs,
1140                            const std::vector<MatShape> &outputs) const CV_OVERRIDE
1141     {
1142         CV_Assert(inputs.size() == outputs.size());
1143
1144         int64 flops = 0;
1145         for (int i = 0; i < inputs.size(); i++)
1146         {
1147             flops += total(outputs[i])*(CV_BIG_INT(2)*kernel.area()*inputs[i][1] + 1);
1148         }
1149
1150         return flops;
1151     }
1152 };
1153
1154 class DeConvolutionLayerImpl CV_FINAL : public BaseConvolutionLayerImpl
1155 {
1156 public:
1157     Mat weightsMat, biasesMat;
1158     UMat umat_weights;
1159     UMat umat_biases;
1160
1161     DeConvolutionLayerImpl(const LayerParams& params) : BaseConvolutionLayerImpl(params) {}
1162
1163     MatShape computeColRowShape(const MatShape &inpShape, const MatShape &outShape) const CV_OVERRIDE
1164     {
1165         int inpCn = inpShape[1];
1166         int inpH = inpShape[2];
1167         int inpW = inpShape[3];
1168         int outCn = outShape[1];
1169         int ngroups = inpCn / blobs[0].size[0];
1170         int outGroupCn = outCn / ngroups;
1171         int ksize = outGroupCn * kernel.height * kernel.width;
1172         return shape(ksize, inpH * inpW);
1173     }
1174
1175     virtual bool supportBackend(int backendId) CV_OVERRIDE
1176     {
1177 #ifdef HAVE_INF_ENGINE
1178         if (backendId == DNN_BACKEND_INFERENCE_ENGINE)
1179         {
1180             if (kernel_size.size() == 3)
1181                 CV_Error(Error::StsNotImplemented, "Unsupported deconvolution3D layer");
1182
1183             if (INF_ENGINE_RELEASE >= 2018050000 && (adjustPad.height || adjustPad.width))
1184                 return false;
1185
1186             const int outGroupCn = blobs[0].size[1];  // Weights are in IOHW layout
1187             const int group = numOutput / outGroupCn;
1188             if (group != 1)
1189             {
1190                 return preferableTarget == DNN_TARGET_CPU;
1191             }
1192             if (preferableTarget == DNN_TARGET_OPENCL || preferableTarget == DNN_TARGET_OPENCL_FP16)
1193                 return dilation.width == 1 && dilation.height == 1;
1194             return true;
1195         }
1196         else
1197 #endif  // HAVE_INF_ENGINE
1198             return kernel_size.size() == 2 && (backendId == DNN_BACKEND_OPENCV || backendId == DNN_BACKEND_HALIDE);
1199     }
1200
1201     bool getMemoryShapes(const std::vector<MatShape> &inputs,
1202                          const int requiredOutputs,
1203                          std::vector<MatShape> &outputs,
1204                          std::vector<MatShape> &internals) const CV_OVERRIDE
1205     {
1206         CV_Assert(!hasBias() || blobs[1].total() == (size_t)numOutput);
1207         CV_Assert(inputs.size() != 0);
1208
1209         int outCn = numOutput;
1210         std::vector<int> outShape;
1211         outShape.push_back(inputs[0][0]);  // batch
1212         outShape.push_back(outCn);
1213         if (padMode.empty())
1214         {
1215             for (int i = 0; i < kernel_size.size(); i++)
1216                 outShape.push_back(strides[i] * (inputs[0][2 + i] - 1) + kernel_size[i] - pads_begin[i] - pads_end[i] + adjust_pads[i]);
1217         }
1218         else if (padMode == "VALID")
1219         {
1220             for (int i = 0; i < kernel_size.size(); i++)
1221                 outShape.push_back(strides[i] * (inputs[0][2 + i] - 1) + kernel_size[i] + adjust_pads[i]);
1222         }
1223         else if (padMode == "SAME")
1224         {
1225             for (int i = 0; i < kernel_size.size(); i++)
1226                 outShape.push_back(strides[i] * (inputs[0][2 + i] - 1) + 1 + adjust_pads[i]);
1227         }
1228         else
1229             CV_Error(Error::StsError, "Unsupported padding mode " + padMode);
1230
1231         CV_Assert(outCn % blobs[0].size[1] == 0);
1232         int ngroups = outCn / blobs[0].size[1];
1233
1234         int inpCn = inputs[0][1];
1235         CV_Assert(inpCn % ngroups == 0 && outCn % ngroups == 0);
1236         CV_Assert(blobs[0].size[0] == inpCn);
1237
1238         outputs.resize(1, outShape);
1239
1240         if (!is1x1())
1241             internals.push_back(computeColRowShape(inputs[0], outputs[0]));
1242
1243         return false;
1244     }
1245
1246     void finalize(InputArrayOfArrays inputs_arr, OutputArrayOfArrays outputs_arr) CV_OVERRIDE
1247     {
1248         BaseConvolutionLayerImpl::finalize(inputs_arr, outputs_arr);
1249
1250         std::vector<Mat> inputs, outputs;
1251         inputs_arr.getMatVector(inputs);
1252         outputs_arr.getMatVector(outputs);
1253
1254         std::vector<int> inpShape;
1255         std::vector<int> outShape;
1256         for (int i = 2; i < inputs[0].dims; i++) {
1257             inpShape.push_back(inputs[0].size[i]);
1258             outShape.push_back(outputs[0].size[i]);
1259         }
1260         getConvPoolPaddings(outShape, inpShape, kernel_size, strides, padMode, dilations, pads_begin, pads_end);
1261         if (pads_begin.size() == 2) {
1262             for (int i = 0; i < pads_begin.size(); i++) {
1263                 if (pads_begin[i] != pads_end[i])
1264                     CV_Error(Error::StsNotImplemented, "Unsupported asymmetric padding in deconvolution layer");
1265             }
1266             pad = Size(pads_begin[1], pads_begin[0]);
1267         }
1268
1269         weightsMultipliers.assign(numOutput, 1.0);
1270         if (weightsMat.empty())
1271         {
1272             transpose(blobs[0].reshape(1, blobs[0].size[0]), weightsMat);
1273             biasesMat = hasBias() ? blobs[1].reshape(1, numOutput)
1274                                   : Mat::zeros(numOutput, 1, CV_32F);
1275         }
1276     }
1277
1278     void fuseWeights(const Mat& w_, const Mat& b_) CV_OVERRIDE
1279     {
1280         Mat w = w_.total() == 1 ? Mat(1, numOutput, CV_32F, Scalar(w_.at<float>(0))) : w_;
1281         Mat b = b_.total() == 1 ? Mat(1, numOutput, CV_32F, Scalar(b_.at<float>(0))) : b_;
1282
1283         CV_Assert_N(!weightsMat.empty(),
1284                      w.empty() || numOutput == w.total(),
1285                      b.empty() || numOutput == b.total());
1286
1287         if (!w.empty())
1288         {
1289             transpose(blobs[0].reshape(1, blobs[0].size[0]), weightsMat);
1290             weightsMat = weightsMat.reshape(1, numOutput);
1291             for (int i = 0; i < numOutput; ++i)
1292             {
1293                 double wi = w.at<float>(i);
1294                 weightsMultipliers[i] *= wi;
1295                 cv::multiply(weightsMat.row(i), weightsMultipliers[i], weightsMat.row(i));
1296                 biasesMat.at<float>(i) *= wi;
1297             }
1298             weightsMat = weightsMat.reshape(1, weightsMat.total() / blobs[0].size[0]);
1299         }
1300
1301         if (!b.empty())
1302         {
1303             cv::add(biasesMat, b.reshape(1, numOutput), biasesMat);
1304         }
1305
1306         newWeightAndBias = !w.empty() || !b.empty();
1307     }
1308
1309     class MatMulInvoker : public ParallelLoopBody
1310     {
1311     public:
1312         MatMulInvoker(const Mat& a, const Mat& b, Mat& c, int nstripes)
1313         {
1314             a_ = &a;
1315             b_ = &b;
1316             c_ = &c;
1317             nstripes_ = nstripes;
1318             useAVX = checkHardwareSupport(CPU_AVX);
1319             useAVX2 = checkHardwareSupport(CPU_AVX2);
1320             useAVX512 = CV_CPU_HAS_SUPPORT_AVX512_SKX;
1321         }
1322
1323         void operator()(const Range& range_) const CV_OVERRIDE
1324         {
1325             int stripeSize = (int)alignSize((b_->cols + nstripes_ - 1)/nstripes_, 16);
1326             Range range(range_.start*stripeSize, std::min(range_.end*stripeSize, b_->cols));
1327             int mmax = a_->rows;
1328             int nmax = range.end - range.start;
1329             int kmax = a_->cols;
1330             int m, n, k;
1331             const float* aptr = a_->ptr<float>();
1332             const float* bptr = b_->ptr<float>() + range.start;
1333             float* cptr = c_->ptr<float>() + range.start;
1334             size_t astep = a_->step1();
1335             size_t bstep = b_->step1();
1336             size_t cstep = c_->step1();
1337
1338         #if CV_TRY_AVX512_SKX
1339             if( useAVX512 )
1340                 opt_AVX512_SKX::fastGEMM( aptr, astep, bptr, bstep, cptr, cstep, mmax, kmax, nmax );
1341             else
1342         #endif
1343         #if CV_TRY_AVX2
1344             if( useAVX2 )
1345                 opt_AVX2::fastGEMM( aptr, astep, bptr, bstep, cptr, cstep, mmax, kmax, nmax );
1346             else
1347         #endif
1348         #if CV_TRY_AVX
1349             if( useAVX )
1350                 opt_AVX::fastGEMM( aptr, astep, bptr, bstep, cptr, cstep, mmax, kmax, nmax );
1351             else
1352         #endif
1353             for( m = 0; m < mmax; m += 2 )
1354             {
1355                 float* dst0 = cptr + cstep*m;
1356                 float* dst1 = cptr + cstep*std::min(m+1, mmax-1);
1357                 const float* aptr0 = aptr + astep*m;
1358                 const float* aptr1 = aptr + astep*std::min(m+1, mmax-1);
1359
1360                 for( n = 0; n < nmax; n++ )
1361                 {
1362                     dst0[n] = 0.f;
1363                     dst1[n] = 0.f;
1364                 }
1365
1366                 for( k = 0; k < kmax; k += 4 )
1367                 {
1368                     float alpha00 = aptr0[k];
1369                     float alpha01 = aptr1[k];
1370                     float alpha10 = 0.f, alpha11 = 0.f;
1371                     float alpha20 = 0.f, alpha21 = 0.f;
1372                     float alpha30 = 0.f, alpha31 = 0.f;
1373                     const float* bptr0 = bptr + k*bstep;
1374                     const float* bptr1 = bptr0;
1375                     const float* bptr2 = bptr0;
1376                     const float* bptr3 = bptr0;
1377
1378                     if( k+1 < kmax )
1379                     {
1380                         alpha10 = aptr0[k+1];
1381                         alpha11 = aptr1[k+1];
1382                         bptr1 = bptr0 + bstep;
1383                         if( k+2 < kmax )
1384                         {
1385                             alpha20 = aptr0[k+2];
1386                             alpha21 = aptr1[k+2];
1387                             bptr2 = bptr1 + bstep;
1388                             if( k+3 < kmax )
1389                             {
1390                                 alpha30 = aptr0[k+3];
1391                                 alpha31 = aptr1[k+3];
1392                                 bptr3 = bptr2 + bstep;
1393                             }
1394                         }
1395                     }
1396                     n = 0;
1397
1398                 #if CV_SIMD128
1399                     v_float32x4 a00 = v_setall_f32(alpha00);
1400                     v_float32x4 a01 = v_setall_f32(alpha01);
1401                     v_float32x4 a10 = v_setall_f32(alpha10);
1402                     v_float32x4 a11 = v_setall_f32(alpha11);
1403                     v_float32x4 a20 = v_setall_f32(alpha20);
1404                     v_float32x4 a21 = v_setall_f32(alpha21);
1405                     v_float32x4 a30 = v_setall_f32(alpha30);
1406                     v_float32x4 a31 = v_setall_f32(alpha31);
1407
1408                     for( ; n <= nmax - 4; n += 4 )
1409                     {
1410                         v_float32x4 b0 = v_load(bptr0 + n);
1411                         v_float32x4 b1 = v_load(bptr1 + n);
1412                         v_float32x4 b2 = v_load(bptr2 + n);
1413                         v_float32x4 b3 = v_load(bptr3 + n);
1414                         v_float32x4 d0 = v_load(dst0 + n);
1415                         v_float32x4 d1 = v_load(dst1 + n);
1416                         d0 += b0*a00;
1417                         d1 += b0*a01;
1418                         d0 += b1*a10;
1419                         d1 += b1*a11;
1420                         d0 += b2*a20;
1421                         d1 += b2*a21;
1422                         d0 += b3*a30;
1423                         d1 += b3*a31;
1424                         v_store(dst0 + n, d0);
1425                         v_store(dst1 + n, d1);
1426                     }
1427                 #endif
1428
1429                     for( ; n < nmax; n++ )
1430                     {
1431                         float b0 = bptr0[n], b1 = bptr1[n];
1432                         float b2 = bptr2[n], b3 = bptr3[n];
1433                         float d0 = dst0[n] + alpha00*b0 + alpha10*b1 + alpha20*b2 + alpha30*b3;
1434                         float d1 = dst1[n] + alpha01*b0 + alpha11*b1 + alpha21*b2 + alpha31*b3;
1435                         dst0[n] = d0;
1436                         dst1[n] = d1;
1437                     }
1438                 }
1439             }
1440         }
1441
1442         const Mat *a_, *b_;
1443         Mat* c_;
1444         int nstripes_;
1445         bool useAVX;
1446         bool useAVX2;
1447         bool useAVX512;
1448     };
1449
1450     class Col2ImInvoker : public cv::ParallelLoopBody
1451     {
1452     public:
1453         const float* data_col;
1454         const float* biasvec;
1455         int channels, height, width;
1456         int kernel_h, kernel_w;
1457         int pad_h, pad_w;
1458         int stride_h, stride_w;
1459         float* data_im;
1460         int height_col, width_col;
1461         int nstripes;
1462         bool is1x1;
1463
1464         Col2ImInvoker()
1465             : data_col(0), biasvec(0), channels(0), height(0), width(0),
1466               kernel_h(0), kernel_w(0), pad_h(0), pad_w(0), stride_h(0), stride_w(0), data_im(0),
1467               height_col(0), width_col(0), nstripes(0), is1x1(0)
1468         {}
1469
1470         static void run(const float* data_col,
1471                         int channels, int height, int width,
1472                         int kernel_h, int kernel_w,
1473                         int pad_h, int pad_w,
1474                         int stride_h, int stride_w,
1475                         int height_col, int width_col,
1476                         float* data_im,
1477                         const float* biasvec,
1478                         bool is1x1)
1479         {
1480             const int nstripes = getNumThreads();
1481
1482             Col2ImInvoker t;
1483             t.data_col = data_col;
1484             t.data_im = data_im;
1485             t.channels = channels; t.height = height; t.width = width;
1486             t.kernel_h = kernel_h; t.kernel_w = kernel_w;
1487             t.pad_h = pad_h; t.pad_w = pad_w;
1488             t.stride_h = stride_h; t.stride_w = stride_w;
1489             t.height_col = height_col;
1490             t.width_col = width_col;
1491             t.nstripes = nstripes;
1492             t.is1x1 = is1x1;
1493             t.biasvec = biasvec;
1494
1495             parallel_for_(Range(0, nstripes), t, nstripes);
1496         }
1497
1498         virtual void operator ()(const Range &r) const CV_OVERRIDE
1499         {
1500             const float* data_col_ = data_col;
1501             float* data_im_ = data_im;
1502             int coeff_h = (1 - stride_h * kernel_w * height_col) * width_col;
1503             int coeff_w = (1 - stride_w * height_col * width_col);
1504             size_t total = (size_t)channels * height * width;
1505             size_t stripeSize = (total + nstripes - 1)/nstripes;
1506             size_t startIndex = r.start*stripeSize;
1507             size_t endIndex = std::min(r.end*stripeSize, total);
1508             int w = (int)(startIndex % width + pad_w);
1509             int h = (int)((startIndex / width) % height + pad_h);
1510             int c = (int)(startIndex / (width * height));
1511             int h_col_start = (h < kernel_h) ? 0 : (h - kernel_h) / stride_h + 1;
1512             int h_col_end = std::min(h / stride_h + 1, height_col);
1513             int plane_size_col = height_col * width_col;
1514             int offset = (c * kernel_h * kernel_w + h * kernel_w + w) * plane_size_col;
1515             bool is1x1_ = is1x1;
1516             const float* biasvec_ = biasvec;
1517
1518             for (size_t index = startIndex; index < endIndex; index++)
1519             {
1520                 // compute the start and end of the output
1521                 int w_col_start = (w < kernel_w) ? 0 : (w - kernel_w) / stride_w + 1;
1522                 int w_col_end = std::min(w / stride_w + 1, width_col);
1523                 float val;
1524
1525                 if( is1x1_ )
1526                     val = data_im_[index];
1527                 else
1528                 {
1529                     val = 0.f;
1530                     for (int h_col = h_col_start; h_col < h_col_end; ++h_col) {
1531                         for (int w_col = w_col_start; w_col < w_col_end; ++w_col) {
1532                             val += data_col_[offset + h_col * coeff_h + w_col * coeff_w];
1533                         }
1534                     }
1535                 }
1536                 data_im_[index] = val + biasvec_[c];
1537
1538                 offset += plane_size_col;
1539                 if( ++w >= width + pad_w )
1540                 {
1541                     w = (int)((index + 1)% width + pad_w);
1542                     h = (int)(((index + 1) / width) % height + pad_h);
1543                     c = (int)((index + 1) / (width * height));
1544                     h_col_start = (h < kernel_h) ? 0 : (h - kernel_h) / stride_h + 1;
1545                     h_col_end = std::min(h / stride_h + 1, height_col);
1546                     offset = (c * kernel_h * kernel_w + h * kernel_w + w) * plane_size_col;
1547                 }
1548             }
1549         }
1550     };
1551
1552 #ifdef HAVE_OPENCL
1553     bool forward_ocl(InputArrayOfArrays inputs_, OutputArrayOfArrays outputs_, OutputArrayOfArrays internals_)
1554     {
1555         std::vector<UMat> inputs;
1556         std::vector<UMat> outputs;
1557         std::vector<UMat> internals;
1558
1559         if (inputs_.depth() == CV_16S)
1560             return false;
1561
1562         inputs_.getUMatVector(inputs);
1563         outputs_.getUMatVector(outputs);
1564         internals_.getUMatVector(internals);
1565
1566         int outCn = numOutput;
1567         int inpCn = inputs[0].size[1];
1568
1569         if (is1x1())
1570             return false;
1571
1572         if (umat_weights.empty())
1573         {
1574             if (newWeightAndBias)
1575             {
1576                 weightsMat.copyTo(umat_weights);
1577                 biasesMat.copyTo(umat_biases);
1578             }
1579             else
1580             {
1581                 transpose(blobs[0].reshape(1, inpCn), umat_weights);
1582                 if (hasBias())
1583                     blobs[1].reshape(1, outCn).copyTo(umat_biases);
1584                 else
1585                     umat_biases = UMat::zeros(outCn, 1, CV_32F);
1586             }
1587         }
1588
1589         String buildopt = format("-DT=%s ", ocl::typeToStr(inputs[0].type()));
1590         buildopt += format("-DPAD_H=%d -DPAD_W=%d -DKERNEL_H=%d -DKERNEL_W=%d -DSTRIDE_H=%d -DSTRIDE_W=%d ",
1591                            pad.height, pad.width, kernel.height, kernel.width, stride.height, stride.width);
1592
1593         for (size_t ii = 0; ii < outputs.size(); ii++)
1594         {
1595             int ngroups = outCn / blobs[0].size[1];
1596             int inpGroupCn = inpCn / ngroups;
1597             int outGroupCn = blobs[0].size[1];
1598             const UMat& inp = inputs[ii];
1599             UMat& out = outputs[ii];
1600             int numImg = inp.size[0];
1601             int inpH = inp.size[2], inpW = inp.size[3];
1602             int outH = out.size[2], outW = out.size[3];
1603
1604             MatShape inpshape = shape(numImg*inpCn, inpH*inpW);
1605             MatShape outshape = shape(numImg*outCn, outH*outW);
1606             UMat convBlob = inputs[ii].reshape(1, inpshape.size(), &inpshape[0]);
1607             UMat decnBlob = out.reshape(1, outshape.size(), &outshape[0]);
1608             int rows = internals[0].rows / ngroups;
1609
1610             for (int n = 0; n < numImg; n++)
1611             {
1612                 for (int g = 0; g < ngroups; g++)
1613                 {
1614                     UMat colMat = internals[0].rowRange(_Range(g * rows, rows));
1615                     UMat convMat = convBlob.rowRange(_Range((g + n * ngroups) * inpGroupCn, inpGroupCn));
1616                     UMat wghtMat = umat_weights.colRange(_Range(g * inpGroupCn, inpGroupCn));
1617                     gemm(wghtMat, convMat, 1, noArray(), 0, colMat, 0);
1618                 }
1619
1620                 for (int g = 0; g < ngroups; g++)
1621                 {
1622                     int total = outGroupCn * decnBlob.cols;
1623                     int index = 0;
1624                     int height_col = inpH;
1625                     int width_col = inpW;
1626                     int coeff_h = (1 - stride.height * kernel.width * height_col) * width_col;
1627                     int coeff_w = (1 - stride.width * height_col * width_col);
1628
1629                     ocl::Kernel k("col2im", ocl::dnn::col2im_oclsrc, buildopt);
1630                     k.set(index++, total);
1631                     k.set(index++, ocl::KernelArg::PtrReadOnly(internals[0]));
1632                     k.set(index++, (int)(g * rows * internals[0].cols));
1633                     k.set(index++, outGroupCn);
1634                     k.set(index++, outH);
1635                     k.set(index++, outW);
1636                     k.set(index++, height_col);
1637                     k.set(index++, width_col);
1638                     k.set(index++, coeff_h);
1639                     k.set(index++, coeff_w);
1640                     k.set(index++, ocl::KernelArg::PtrReadOnly(umat_biases));
1641                     k.set(index++, (int)(g * outGroupCn * umat_biases.cols));
1642                     k.set(index++, ocl::KernelArg::PtrWriteOnly(decnBlob));
1643                     k.set(index++, (int)((g + n * ngroups) * outGroupCn * decnBlob.cols));
1644
1645                     size_t global[] = { (size_t)total };
1646                     bool ret = k.run(1, global, NULL, false);
1647                     if (!ret)
1648                         return false;
1649                 }
1650             }
1651         }
1652
1653         return true;
1654     }
1655 #endif
1656
1657     void forward(InputArrayOfArrays inputs_arr, OutputArrayOfArrays outputs_arr, OutputArrayOfArrays internals_arr) CV_OVERRIDE
1658     {
1659         CV_TRACE_FUNCTION();
1660         CV_TRACE_ARG_VALUE(name, "name", name.c_str());
1661
1662         CV_OCL_RUN(IS_DNN_OPENCL_TARGET(preferableTarget),
1663                    forward_ocl(inputs_arr, outputs_arr, internals_arr));
1664
1665         if (inputs_arr.depth() == CV_16S)
1666         {
1667             forward_fallback(inputs_arr, outputs_arr, internals_arr);
1668             return;
1669         }
1670
1671         std::vector<Mat> inputs, outputs, internals;
1672         inputs_arr.getMatVector(inputs);
1673         outputs_arr.getMatVector(outputs);
1674         internals_arr.getMatVector(internals);
1675
1676         int outCn = numOutput;
1677         int inpCn = inputs[0].size[1];
1678         bool is1x1flag = is1x1();
1679         int nstripes = getNumThreads();
1680
1681         if( weightsMat.empty() )
1682         {
1683             transpose(blobs[0].reshape(1, inpCn), weightsMat);
1684             biasesMat = hasBias() ? blobs[1].reshape(1, outCn) : Mat::zeros(outCn, 1, CV_32F);
1685         }
1686
1687         for (size_t ii = 0; ii < outputs.size(); ii++)
1688         {
1689             int ngroups = outCn / blobs[0].size[1];
1690             int inpGroupCn = inpCn / ngroups;
1691             int outGroupCn = blobs[0].size[1];
1692             const Mat& inp = inputs[ii];
1693             Mat& out = outputs[ii];
1694             int numImg = inp.size[0];
1695             int inpH = inp.size[2], inpW = inp.size[3];
1696             int outH = out.size[2], outW = out.size[3];
1697
1698             Mat convBlob = inputs[ii].reshape(1, numImg*inpCn);
1699             Mat decnBlob = out.reshape(1, numImg*outCn);
1700
1701             for (int n = 0; n < numImg; n++)
1702             {
1703                 for (int g = 0; g < ngroups; g++)
1704                 {
1705                     Mat dstMat = decnBlob.rowRange(_Range((g + n * ngroups) * outGroupCn, outGroupCn));
1706                     Mat &colMat = is1x1flag ? dstMat : internals[0];
1707
1708                     Mat convMat = convBlob.rowRange(_Range((g + n * ngroups) * inpGroupCn, inpGroupCn));
1709                     Mat wghtMat = weightsMat.colRange(_Range(g * inpGroupCn, inpGroupCn));
1710                     Mat curBiasMat = biasesMat.rowRange(_Range(g * outGroupCn, outGroupCn));
1711
1712                     //gemm(wghtMat, convMat, 1, colMat, 0, colMat, 0);
1713                     MatMulInvoker mminvoker(wghtMat, convMat, colMat, nstripes);
1714                     parallel_for_(Range(0, nstripes), mminvoker, nstripes);
1715
1716                     Col2ImInvoker::run(colMat.ptr<float>(), outGroupCn, outH, outW,
1717                                        kernel.height, kernel.width, pad.height, pad.width,
1718                                        stride.height, stride.width, inpH, inpW, dstMat.ptr<float>(),
1719                                        curBiasMat.ptr<float>(), is1x1flag);
1720                 }
1721             }
1722         }
1723     }
1724
1725     virtual Ptr<BackendNode> initHalide(const std::vector<Ptr<BackendWrapper> > &inputs) CV_OVERRIDE
1726     {
1727 #ifdef HAVE_HALIDE
1728         Halide::Buffer<float> inputBuffer = halideBuffer(inputs[0]);
1729
1730         int inW, inH, inC, inN;
1731         getCanonicalSize(inputBuffer, &inW, &inH, &inC, &inN);
1732         const int outGroupCn = blobs[0].size[1];
1733         const int group = numOutput / outGroupCn;
1734         const int inpGroupCn = blobs[0].size[0] / group;
1735
1736         Halide::Var x("x"), y("y"), c("c"), n("n");
1737         Halide::Func top = (name.empty() ? Halide::Func() : Halide::Func(name));
1738         Halide::Func padded_input(name + "_constant_exterior");
1739         auto weights = wrapToHalideBuffer(blobs[0]);
1740
1741         Halide::Func dilated_input("dilated_input");
1742         dilated_input(x, y, c, n) = 0.0f;
1743         Halide::RDom r1(0, inW, 0, inH);
1744         dilated_input(r1.x * stride.width, r1.y * stride.height, c, n) =
1745               inputBuffer(r1.x, r1.y, c, n);
1746         dilated_input.compute_root();
1747
1748         Halide::Func bounded =
1749             Halide::BoundaryConditions::constant_exterior(dilated_input, 0,
1750                                                           0, (inW - 1) * stride.width + 1,
1751                                                           0, (inH - 1) * stride.height + 1,
1752                                                           0, inC, 0, inN);
1753         padded_input(x, y, c, n) = bounded(x, y, c, n);
1754
1755         Halide::RDom r(0, kernel.width, 0, kernel.height, 0, inpGroupCn);
1756         Halide::Expr kx = x + pad.width - r.x;
1757         Halide::Expr ky = y + pad.height - r.y;
1758         Halide::Expr kInC = r.z;
1759         Halide::Expr kOutC = c;
1760         for (int i = 1; i < group; ++i)
1761         {
1762             kInC = select(c < outGroupCn * i, kInC, inpGroupCn * i + r.z);
1763             kOutC = select(c < outGroupCn * i, kOutC, c - outGroupCn * i);
1764         }
1765         Halide::Expr topExpr = sum(padded_input(kx, ky, kInC, n) *
1766                                    weights(r.x, r.y, kOutC, kInC));
1767         if (hasBias())
1768         {
1769             auto bias = wrapToHalideBuffer(blobs[1], {numOutput});
1770             topExpr += bias(c);
1771         }
1772         top(x, y, c, n) = topExpr;
1773         return Ptr<BackendNode>(new HalideBackendNode({ padded_input, top }));
1774 #endif  // HAVE_HALIDE
1775         return Ptr<BackendNode>();
1776     }
1777
1778     virtual Ptr<BackendNode> initInfEngine(const std::vector<Ptr<BackendWrapper> > &) CV_OVERRIDE
1779     {
1780 #ifdef HAVE_INF_ENGINE
1781 #if INF_ENGINE_VER_MAJOR_GE(INF_ENGINE_RELEASE_2018R5)
1782         const int outGroupCn = blobs[0].size[1];  // Weights are in IOHW layout
1783         const int group = numOutput / outGroupCn;
1784
1785         InferenceEngine::Builder::DeconvolutionLayer ieLayer(name);
1786
1787         ieLayer.setKernel(kernel_size);
1788         ieLayer.setStrides(strides);
1789         ieLayer.setDilation(dilations);
1790         ieLayer.setPaddingsBegin(pads_begin);
1791         ieLayer.setPaddingsEnd(pads_end);
1792         ieLayer.setGroup((size_t)group);
1793         ieLayer.setOutDepth((size_t)numOutput);
1794
1795         InferenceEngine::Builder::Layer l = ieLayer;
1796         addConstantData("weights", wrapToInfEngineBlob(blobs[0], InferenceEngine::Layout::OIHW), l);
1797         if (hasBias())
1798             addConstantData("biases", wrapToInfEngineBlob(blobs[1], {(size_t)numOutput}, InferenceEngine::Layout::C), l);
1799         return Ptr<BackendNode>(new InfEngineBackendNode(l));
1800 #else
1801         const int outGroupCn = blobs[0].size[1];  // Weights are in IOHW layout
1802         const int group = numOutput / outGroupCn;
1803
1804         InferenceEngine::LayerParams lp;
1805         lp.name = name;
1806         lp.type = "Deconvolution";
1807         lp.precision = InferenceEngine::Precision::FP32;
1808         std::shared_ptr<InferenceEngine::DeconvolutionLayer> ieLayer(new InferenceEngine::DeconvolutionLayer(lp));
1809
1810 #if INF_ENGINE_VER_MAJOR_GT(INF_ENGINE_RELEASE_2018R3)
1811         ieLayer->_kernel.insert(InferenceEngine::X_AXIS, kernel.width);
1812         ieLayer->_kernel.insert(InferenceEngine::Y_AXIS, kernel.height);
1813         ieLayer->_stride.insert(InferenceEngine::X_AXIS, stride.width);
1814         ieLayer->_stride.insert(InferenceEngine::Y_AXIS, stride.height);
1815         ieLayer->_padding.insert(InferenceEngine::X_AXIS, pad.width);
1816         ieLayer->_padding.insert(InferenceEngine::Y_AXIS, pad.height);
1817         ieLayer->_pads_end.insert(InferenceEngine::X_AXIS, pad.width);
1818         ieLayer->_pads_end.insert(InferenceEngine::Y_AXIS, pad.height);
1819         ieLayer->_dilation.insert(InferenceEngine::X_AXIS, dilation.width);
1820         ieLayer->_dilation.insert(InferenceEngine::Y_AXIS, dilation.height);
1821 #else
1822         ieLayer->_kernel_x = kernel.width;
1823         ieLayer->_kernel_y = kernel.height;
1824         ieLayer->_stride_x = stride.width;
1825         ieLayer->_stride_y = stride.height;
1826         ieLayer->_padding_x = pad.width;
1827         ieLayer->_padding_y = pad.height;
1828         ieLayer->_dilation_x = dilation.width;
1829         ieLayer->_dilation_y = dilation.height;
1830 #endif
1831         ieLayer->_out_depth = numOutput;
1832         ieLayer->_group = group;
1833
1834         ieLayer->_weights = wrapToInfEngineBlob(blobs[0], InferenceEngine::Layout::OIHW);
1835         if (hasBias())
1836         {
1837             ieLayer->_biases = wrapToInfEngineBlob(blobs[1], {(size_t)numOutput}, InferenceEngine::Layout::C);
1838         }
1839         return Ptr<BackendNode>(new InfEngineBackendNode(ieLayer));
1840 #endif
1841 #endif  // HAVE_INF_ENGINE
1842         return Ptr<BackendNode>();
1843     }
1844
1845     virtual int64 getFLOPS(const std::vector<MatShape> &inputs,
1846                            const std::vector<MatShape> &outputs) const CV_OVERRIDE
1847     {
1848         CV_Assert(inputs.size() == outputs.size());
1849
1850         float flops = 0;
1851         int outChannels = blobs[0].size[0];
1852
1853         for (int i = 0; i < inputs.size(); i++)
1854         {
1855             flops += CV_BIG_INT(2)*outChannels*kernel.area()*total(inputs[i]);
1856         }
1857
1858         return flops;
1859     }
1860 };
1861
1862 Ptr<BaseConvolutionLayer> ConvolutionLayer::create(const LayerParams &params)
1863 {
1864     Ptr<ConvolutionLayerImpl> l(new ConvolutionLayerImpl(params));
1865     return l;
1866 }
1867
1868 Ptr<BaseConvolutionLayer> DeconvolutionLayer::create(const LayerParams &params)
1869 {
1870     return Ptr<BaseConvolutionLayer>(new DeConvolutionLayerImpl(params));
1871 }
1872
1873 }
1874 }