modules/dnn/include/opencv2/dnn/all_layers.hpp

   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 // Third party copyrights are property of their respective owners.
  15 //
  16 // Redistribution and use in source and binary forms, with or without modification,
  17 // are permitted provided that the following conditions are met:
  18 //
  19 //   * Redistribution's of source code must retain the above copyright notice,
  20 //     this list of conditions and the following disclaimer.
  21 //
  22 //   * Redistribution's in binary form must reproduce the above copyright notice,
  23 //     this list of conditions and the following disclaimer in the documentation
  24 //     and/or other materials provided with the distribution.
  25 //
  26 //   * The name of the copyright holders may not be used to endorse or promote products
  27 //     derived from this software without specific prior written permission.
  28 //
  29 // This software is provided by the copyright holders and contributors "as is" and
  30 // any express or implied warranties, including, but not limited to, the implied
  31 // warranties of merchantability and fitness for a particular purpose are disclaimed.
  32 // In no event shall the Intel Corporation or contributors be liable for any direct,
  33 // indirect, incidental, special, exemplary, or consequential damages
  34 // (including, but not limited to, procurement of substitute goods or services;
  35 // loss of use, data, or profits; or business interruption) however caused
  36 // and on any theory of liability, whether in contract, strict liability,
  37 // or tort (including negligence or otherwise) arising in any way out of
  38 // the use of this software, even if advised of the possibility of such damage.
  39 //
  40 //M*/
  41
  42 #ifndef OPENCV_DNN_DNN_ALL_LAYERS_HPP
  43 #define OPENCV_DNN_DNN_ALL_LAYERS_HPP
  44 #include <opencv2/dnn.hpp>
  45
  46 namespace cv {
  47 namespace dnn {
  48 CV__DNN_INLINE_NS_BEGIN
  49 //! @addtogroup dnn
  50 //! @{
  51
  52 /** @defgroup dnnLayerList Partial List of Implemented Layers
  53   @{
  54   This subsection of dnn module contains information about built-in layers and their descriptions.
  55
  56   Classes listed here, in fact, provides C++ API for creating instances of built-in layers.
  57   In addition to this way of layers instantiation, there is a more common factory API (see @ref dnnLayerFactory), it allows to create layers dynamically (by name) and register new ones.
  58   You can use both API, but factory API is less convenient for native C++ programming and basically designed for use inside importers (see @ref readNetFromCaffe(), @ref readNetFromTorch(), @ref readNetFromTensorflow()).
  59
  60   Built-in layers partially reproduce functionality of corresponding Caffe and Torch7 layers.
  61   In particular, the following layers and Caffe importer were tested to reproduce <a href="http://caffe.berkeleyvision.org/tutorial/layers.html">Caffe</a> functionality:
  62   - Convolution
  63   - Deconvolution
  64   - Pooling
  65   - InnerProduct
  66   - TanH, ReLU, Sigmoid, BNLL, Power, AbsVal
  67   - Softmax
  68   - Reshape, Flatten, Slice, Split
  69   - LRN
  70   - MVN
  71   - Dropout (since it does nothing on forward pass -))
  72 */
  73
  74     class CV_EXPORTS BlankLayer : public Layer
  75     {
  76     public:
  77         static Ptr<Layer> create(const LayerParams &params);
  78     };
  79
  80     /**
  81      * Constant layer produces the same data blob at an every forward pass.
  82      */
  83     class CV_EXPORTS ConstLayer : public Layer
  84     {
  85     public:
  86         static Ptr<Layer> create(const LayerParams &params);
  87     };
  88
  89     //! LSTM recurrent layer
  90     class CV_EXPORTS LSTMLayer : public Layer
  91     {
  92     public:
  93         /** Creates instance of LSTM layer */
  94         static Ptr<LSTMLayer> create(const LayerParams& params);
  95
  96         /** @deprecated Use LayerParams::blobs instead.
  97         @brief Set trained weights for LSTM layer.
  98
  99         LSTM behavior on each step is defined by current input, previous output, previous cell state and learned weights.
 100
 101         Let @f$x_t@f$ be current input, @f$h_t@f$ be current output, @f$c_t@f$ be current state.
 102         Than current output and current cell state is computed as follows:
 103         @f{eqnarray*}{
 104         h_t &= o_t \odot tanh(c_t),               \\
 105         c_t &= f_t \odot c_{t-1} + i_t \odot g_t, \\
 106         @f}
 107         where @f$\odot@f$ is per-element multiply operation and @f$i_t, f_t, o_t, g_t@f$ is internal gates that are computed using learned weights.
 108
 109         Gates are computed as follows:
 110         @f{eqnarray*}{
 111         i_t &= sigmoid&(W_{xi} x_t + W_{hi} h_{t-1} + b_i), \\
 112         f_t &= sigmoid&(W_{xf} x_t + W_{hf} h_{t-1} + b_f), \\
 113         o_t &= sigmoid&(W_{xo} x_t + W_{ho} h_{t-1} + b_o), \\
 114         g_t &= tanh   &(W_{xg} x_t + W_{hg} h_{t-1} + b_g), \\
 115         @f}
 116         where @f$W_{x?}@f$, @f$W_{h?}@f$ and @f$b_{?}@f$ are learned weights represented as matrices:
 117         @f$W_{x?} \in R^{N_h \times N_x}@f$, @f$W_{h?} \in R^{N_h \times N_h}@f$, @f$b_? \in R^{N_h}@f$.
 118
 119         For simplicity and performance purposes we use @f$ W_x = [W_{xi}; W_{xf}; W_{xo}, W_{xg}] @f$
 120         (i.e. @f$W_x@f$ is vertical concatenation of @f$ W_{x?} @f$), @f$ W_x \in R^{4N_h \times N_x} @f$.
 121         The same for @f$ W_h = [W_{hi}; W_{hf}; W_{ho}, W_{hg}], W_h \in R^{4N_h \times N_h} @f$
 122         and for @f$ b = [b_i; b_f, b_o, b_g]@f$, @f$b \in R^{4N_h} @f$.
 123
 124         @param Wh is matrix defining how previous output is transformed to internal gates (i.e. according to above mentioned notation is @f$ W_h @f$)
 125         @param Wx is matrix defining how current input is transformed to internal gates (i.e. according to above mentioned notation is @f$ W_x @f$)
 126         @param b  is bias vector (i.e. according to above mentioned notation is @f$ b @f$)
 127         */
 128         CV_DEPRECATED virtual void setWeights(const Mat &Wh, const Mat &Wx, const Mat &b) = 0;
 129
 130         /** @brief Specifies shape of output blob which will be [[`T`], `N`] + @p outTailShape.
 131           * @details If this parameter is empty or unset then @p outTailShape = [`Wh`.size(0)] will be used,
 132           * where `Wh` is parameter from setWeights().
 133           */
 134         virtual void setOutShape(const MatShape &outTailShape = MatShape()) = 0;
 135
 136         /** @deprecated Use flag `produce_cell_output` in LayerParams.
 137           * @brief Specifies either interpret first dimension of input blob as timestamp dimension either as sample.
 138           *
 139           * If flag is set to true then shape of input blob will be interpreted as [`T`, `N`, `[data dims]`] where `T` specifies number of timestamps, `N` is number of independent streams.
 140           * In this case each forward() call will iterate through `T` timestamps and update layer's state `T` times.
 141           *
 142           * If flag is set to false then shape of input blob will be interpreted as [`N`, `[data dims]`].
 143           * In this case each forward() call will make one iteration and produce one timestamp with shape [`N`, `[out dims]`].
 144           */
 145         CV_DEPRECATED virtual void setUseTimstampsDim(bool use = true) = 0;
 146
 147         /** @deprecated Use flag `use_timestamp_dim` in LayerParams.
 148          * @brief If this flag is set to true then layer will produce @f$ c_t @f$ as second output.
 149          * @details Shape of the second output is the same as first output.
 150          */
 151         CV_DEPRECATED virtual void setProduceCellOutput(bool produce = false) = 0;
 152
 153         /* In common case it use single input with @f$x_t@f$ values to compute output(s) @f$h_t@f$ (and @f$c_t@f$).
 154          * @param input should contain packed values @f$x_t@f$
 155          * @param output contains computed outputs: @f$h_t@f$ (and @f$c_t@f$ if setProduceCellOutput() flag was set to true).
 156          *
 157          * If setUseTimstampsDim() is set to true then @p input[0] should has at least two dimensions with the following shape: [`T`, `N`, `[data dims]`],
 158          * where `T` specifies number of timestamps, `N` is number of independent streams (i.e. @f$ x_{t_0 + t}^{stream} @f$ is stored inside @p input[0][t, stream, ...]).
 159          *
 160          * If setUseTimstampsDim() is set to false then @p input[0] should contain single timestamp, its shape should has form [`N`, `[data dims]`] with at least one dimension.
 161          * (i.e. @f$ x_{t}^{stream} @f$ is stored inside @p input[0][stream, ...]).
 162         */
 163
 164         int inputNameToIndex(String inputName) CV_OVERRIDE;
 165         int outputNameToIndex(const String& outputName) CV_OVERRIDE;
 166     };
 167
 168     /** @brief GRU recurrent one-layer
 169      *
 170      * Accepts input sequence and computes the final hidden state for each element in the batch.
 171      *
 172      * - input[0] containing the features of the input sequence.
 173      * input[0] should have shape [`T`, `N`, `data_dims`] where `T` is sequence length, `N` is batch size, `data_dims` is input size
 174      * - output would have shape [`T`, `N`, `D` * `hidden_size`] where `D = 2` if layer is bidirectional otherwise `D = 1`
 175      *
 176      * Depends on the following attributes:
 177      * - hidden_size - Number of neurons in the hidden layer
 178      * - direction - RNN could be bidirectional or forward
 179      *
 180      * The final hidden state @f$ h_t @f$ computes by the following formulas:
 181      *
 182      @f{eqnarray*}{
 183      r_t = \sigma(W_{ir} x_t + b_{ir} + W_{hr} h_{(t-1)} + b_{hr}) \\
 184      z_t = \sigma(W_{iz} x_t + b_{iz} + W_{hz} h_{(t-1)} + b_{hz}) \\
 185      n_t = \tanh(W_{in} x_t + b_{in} + r_t \odot (W_{hn} h_{(t-1)}+ b_{hn})) \\
 186      h_t = (1 - z_t) \odot n_t + z_t \odot h_{(t-1)} \\
 187      @f}
 188      * Where @f$x_t@f$ is current input, @f$h_{(t-1)}@f$ is previous or initial hidden state.
 189      *
 190      * @f$W_{x?}@f$, @f$W_{h?}@f$ and @f$b_{?}@f$ are learned weights represented as matrices:
 191      * @f$W_{x?} \in R^{N_h \times N_x}@f$, @f$W_{h?} \in R^{N_h \times N_h}@f$, @f$b_? \in R^{N_h}@f$.
 192      *
 193      * @f$\odot@f$ is per-element multiply operation.
 194     */
 195     class CV_EXPORTS GRULayer : public Layer
 196     {
 197     public:
 198         /** Creates instance of GRU layer */
 199         static Ptr<GRULayer> create(const LayerParams& params);
 200     };
 201
 202     /** @brief Classical recurrent layer
 203
 204     Accepts two inputs @f$x_t@f$ and @f$h_{t-1}@f$ and compute two outputs @f$o_t@f$ and @f$h_t@f$.
 205
 206     - input: should contain packed input @f$x_t@f$.
 207     - output: should contain output @f$o_t@f$ (and @f$h_t@f$ if setProduceHiddenOutput() is set to true).
 208
 209     input[0] should have shape [`T`, `N`, `data_dims`] where `T` and `N` is number of timestamps and number of independent samples of @f$x_t@f$ respectively.
 210
 211     output[0] will have shape [`T`, `N`, @f$N_o@f$], where @f$N_o@f$ is number of rows in @f$ W_{xo} @f$ matrix.
 212
 213     If setProduceHiddenOutput() is set to true then @p output[1] will contain a Mat with shape [`T`, `N`, @f$N_h@f$], where @f$N_h@f$ is number of rows in @f$ W_{hh} @f$ matrix.
 214     */
 215     class CV_EXPORTS RNNLayer : public Layer
 216     {
 217     public:
 218         /** Creates instance of RNNLayer */
 219         static Ptr<RNNLayer> create(const LayerParams& params);
 220
 221         /** Setups learned weights.
 222
 223         Recurrent-layer behavior on each step is defined by current input @f$ x_t @f$, previous state @f$ h_t @f$ and learned weights as follows:
 224         @f{eqnarray*}{
 225         h_t &= tanh&(W_{hh} h_{t-1} + W_{xh} x_t + b_h),  \\
 226         o_t &= tanh&(W_{ho} h_t + b_o),
 227         @f}
 228
 229         @param Wxh is @f$ W_{xh} @f$ matrix
 230         @param bh  is @f$ b_{h}  @f$ vector
 231         @param Whh is @f$ W_{hh} @f$ matrix
 232         @param Who is @f$ W_{xo} @f$ matrix
 233         @param bo  is @f$ b_{o}  @f$ vector
 234         */
 235         virtual void setWeights(const Mat &Wxh, const Mat &bh, const Mat &Whh, const Mat &Who, const Mat &bo) = 0;
 236
 237         /** @brief If this flag is set to true then layer will produce @f$ h_t @f$ as second output.
 238          * @details Shape of the second output is the same as first output.
 239          */
 240         virtual void setProduceHiddenOutput(bool produce = false) = 0;
 241
 242     };
 243
 244     class CV_EXPORTS BaseConvolutionLayer : public Layer
 245     {
 246     public:
 247         CV_DEPRECATED_EXTERNAL Size kernel, stride, pad, dilation, adjustPad;
 248         std::vector<size_t> adjust_pads;
 249         std::vector<size_t> kernel_size, strides, dilations;
 250         std::vector<size_t> pads_begin, pads_end;
 251         String padMode;
 252         int numOutput;
 253     };
 254
 255     class CV_EXPORTS ConvolutionLayer : public BaseConvolutionLayer
 256     {
 257     public:
 258         static Ptr<BaseConvolutionLayer> create(const LayerParams& params);
 259         bool fusedActivation = false;
 260         bool fusedAdd = false;
 261         bool isConv2D = false; // Should be deleted after fastconv branch support Conv1D and Conv3D.
 262         bool useWinograd = false; // Flag whether to use Winograd to speed up 3x3 convolution.
 263     };
 264
 265     class CV_EXPORTS ConvolutionLayerInt8 : public BaseConvolutionLayer
 266     {
 267     public:
 268         int input_zp, output_zp;
 269         float input_sc, output_sc;
 270
 271         // quantization type flag. The perChannel default is true, that means it contains the parameters
 272         // of per-Channel quantization. Otherwise, that means this layer contains per-Tensor quantized parameters.
 273         bool per_channel;
 274         bool useWinograd = true; // Flag whether to use Winograd to speed up 3x3 convolution.
 275         static Ptr<BaseConvolutionLayer> create(const LayerParams& params);
 276     };
 277
 278     class CV_EXPORTS DeconvolutionLayer : public BaseConvolutionLayer
 279     {
 280     public:
 281         static Ptr<BaseConvolutionLayer> create(const LayerParams& params);
 282     };
 283
 284     class CV_EXPORTS LRNLayer : public Layer
 285     {
 286     public:
 287         int type;
 288
 289         int size;
 290         float alpha, beta, bias;
 291         bool normBySize;
 292
 293         static Ptr<LRNLayer> create(const LayerParams& params);
 294     };
 295
 296
 297     /** @brief ArgMax/ArgMin layer
 298      * @note returns indices as floats, which means the supported range is [-2^24; 2^24]
 299      */
 300     class CV_EXPORTS ArgLayer : public Layer
 301     {
 302     public:
 303         static Ptr<ArgLayer> create(const LayerParams& params);
 304     };
 305
 306     /** @brief Gather layer
 307      */
 308     class CV_EXPORTS GatherLayer : public Layer
 309     {
 310     public:
 311         static Ptr<GatherLayer> create(const LayerParams& params);
 312     };
 313
 314     class CV_EXPORTS PoolingLayer : public Layer
 315     {
 316     public:
 317         int type;
 318         std::vector<size_t> kernel_size, strides;
 319         std::vector<size_t> pads_begin, pads_end;
 320         bool globalPooling; //!< Flag is true if at least one of the axes is global pooled.
 321         std::vector<bool> isGlobalPooling;
 322         bool computeMaxIdx;
 323         String padMode;
 324         bool ceilMode;
 325         // If true for average pooling with padding, divide an every output region
 326         // by a whole kernel area. Otherwise exclude zero padded values and divide
 327         // by number of real values.
 328         bool avePoolPaddedArea;
 329         // ROIPooling parameters.
 330         Size pooledSize;
 331         float spatialScale;
 332         // PSROIPooling parameters.
 333         int psRoiOutChannels;
 334
 335         static Ptr<PoolingLayer> create(const LayerParams& params);
 336     };
 337
 338     class CV_EXPORTS PoolingLayerInt8 : public PoolingLayer
 339     {
 340     public:
 341         int input_zp, output_zp;
 342         float input_sc, output_sc;
 343         static Ptr<PoolingLayerInt8> create(const LayerParams& params);
 344     };
 345
 346     class CV_EXPORTS ReduceLayer : public Layer
 347     {
 348     public:
 349         int reduceType;
 350         // reduceDims contains the dimensions that need to be reduced, targetDims is the target output dimension.
 351         std::vector<size_t> reduceDims, targetDims;
 352         static Ptr<ReduceLayer> create(const LayerParams& params);
 353     };
 354
 355     class CV_EXPORTS ReduceLayerInt8 : public ReduceLayer
 356     {
 357     public:
 358         static Ptr<ReduceLayerInt8> create(const LayerParams& params);
 359     };
 360
 361     class CV_EXPORTS SoftmaxLayer : public Layer
 362     {
 363     public:
 364         bool logSoftMax;
 365
 366         static Ptr<SoftmaxLayer> create(const LayerParams& params);
 367     };
 368
 369     class CV_EXPORTS SoftmaxLayerInt8 : public SoftmaxLayer
 370     {
 371     public:
 372         float output_sc;
 373         int output_zp;
 374         static Ptr<SoftmaxLayerInt8> create(const LayerParams& params);
 375     };
 376
 377     class CV_EXPORTS InnerProductLayer : public Layer
 378     {
 379     public:
 380         int axis;
 381         static Ptr<InnerProductLayer> create(const LayerParams& params);
 382     };
 383
 384     class CV_EXPORTS InnerProductLayerInt8 : public InnerProductLayer
 385     {
 386     public:
 387         int input_zp, output_zp;
 388         float input_sc, output_sc;
 389
 390         // quantization type flag. The perChannel default is true, that means it contains the parameters
 391         // of per-Channel quantization. Otherwise, that means this layer contains per-Tensor quantized parameters.
 392         bool per_channel;
 393         static Ptr<InnerProductLayerInt8> create(const LayerParams& params);
 394     };
 395
 396     class CV_EXPORTS MVNLayer : public Layer
 397     {
 398     public:
 399         float eps;
 400         bool normVariance, acrossChannels;
 401
 402         static Ptr<MVNLayer> create(const LayerParams& params);
 403     };
 404
 405     /* Reshaping */
 406
 407     class CV_EXPORTS ReshapeLayer : public Layer
 408     {
 409     public:
 410         MatShape newShapeDesc;
 411         Range newShapeRange;
 412
 413         static Ptr<ReshapeLayer> create(const LayerParams& params);
 414     };
 415
 416     class CV_EXPORTS FlattenLayer : public Layer
 417     {
 418     public:
 419         static Ptr<FlattenLayer> create(const LayerParams &params);
 420     };
 421
 422     class CV_EXPORTS QuantizeLayer : public Layer
 423     {
 424     public:
 425         std::vector<float> scales;
 426         std::vector<int> zeropoints;
 427         static Ptr<QuantizeLayer> create(const LayerParams &params);
 428     };
 429
 430     class CV_EXPORTS DequantizeLayer : public Layer
 431     {
 432     public:
 433         std::vector<float> scales;
 434         std::vector<int> zeropoints;
 435         static Ptr<DequantizeLayer> create(const LayerParams &params);
 436     };
 437
 438     class CV_EXPORTS RequantizeLayer : public Layer
 439     {
 440     public:
 441         float scale, shift;
 442         static Ptr<RequantizeLayer> create(const LayerParams &params);
 443     };
 444
 445     class CV_EXPORTS ConcatLayer : public Layer
 446     {
 447     public:
 448         int axis;
 449         /**
 450          * @brief Add zero padding in case of concatenation of blobs with different
 451          * spatial sizes.
 452          *
 453          * Details: https://github.com/torch/nn/blob/master/doc/containers.md#depthconcat
 454          */
 455         bool padding;
 456         int paddingValue;
 457
 458         static Ptr<ConcatLayer> create(const LayerParams &params);
 459     };
 460
 461     class CV_EXPORTS SplitLayer : public Layer
 462     {
 463     public:
 464         int outputsCount; //!< Number of copies that will be produced (is ignored when negative).
 465
 466         static Ptr<SplitLayer> create(const LayerParams &params);
 467     };
 468
 469     /**
 470      * Slice layer has several modes:
 471      * 1. Caffe mode
 472      * @param[in] axis Axis of split operation
 473      * @param[in] slice_point Array of split points
 474      *
 475      * Number of output blobs equals to number of split points plus one. The
 476      * first blob is a slice on input from 0 to @p slice_point[0] - 1 by @p axis,
 477      * the second output blob is a slice of input from @p slice_point[0] to
 478      * @p slice_point[1] - 1 by @p axis and the last output blob is a slice of
 479      * input from @p slice_point[-1] up to the end of @p axis size.
 480      *
 481      * 2. TensorFlow mode
 482      * @param begin Vector of start indices
 483      * @param size Vector of sizes
 484      *
 485      * More convenient numpy-like slice. One and only output blob
 486      * is a slice `input[begin[0]:begin[0]+size[0], begin[1]:begin[1]+size[1], ...]`
 487      *
 488      * 3. Torch mode
 489      * @param axis Axis of split operation
 490      *
 491      * Split input blob on the equal parts by @p axis.
 492      */
 493     class CV_EXPORTS SliceLayer : public Layer
 494     {
 495     public:
 496         /**
 497          * @brief Vector of slice ranges.
 498          *
 499          * The first dimension equals number of output blobs.
 500          * Inner vector has slice ranges for the first number of input dimensions.
 501          */
 502         std::vector<std::vector<Range> > sliceRanges;
 503         std::vector<std::vector<int> > sliceSteps;
 504         int axis;
 505         int num_split;
 506
 507         static Ptr<SliceLayer> create(const LayerParams &params);
 508     };
 509
 510     class CV_EXPORTS PermuteLayer : public Layer
 511     {
 512     public:
 513         static Ptr<PermuteLayer> create(const LayerParams& params);
 514     };
 515
 516     /**
 517      * Permute channels of 4-dimensional input blob.
 518      * @param group Number of groups to split input channels and pick in turns
 519      *              into output blob.
 520      *
 521      * \f[ groupSize = \frac{number\ of\ channels}{group} \f]
 522      * \f[ output(n, c, h, w) = input(n, groupSize \times (c \% group) + \lfloor \frac{c}{group} \rfloor, h, w) \f]
 523      * Read more at https://arxiv.org/pdf/1707.01083.pdf
 524      */
 525     class CV_EXPORTS ShuffleChannelLayer : public Layer
 526     {
 527     public:
 528         static Ptr<Layer> create(const LayerParams& params);
 529
 530         int group;
 531     };
 532
 533     /**
 534      * @brief Adds extra values for specific axes.
 535      * @param paddings Vector of paddings in format
 536      *                 @code
 537      *                 [ pad_before, pad_after,  // [0]th dimension
 538      *                   pad_before, pad_after,  // [1]st dimension
 539      *                   ...
 540      *                   pad_before, pad_after ] // [n]th dimension
 541      *                 @endcode
 542      *                 that represents number of padded values at every dimension
 543      *                 starting from the first one. The rest of dimensions won't
 544      *                 be padded.
 545      * @param value Value to be padded. Defaults to zero.
 546      * @param type Padding type: 'constant', 'reflect'
 547      * @param input_dims Torch's parameter. If @p input_dims is not equal to the
 548      *                   actual input dimensionality then the `[0]th` dimension
 549      *                   is considered as a batch dimension and @p paddings are shifted
 550      *                   to a one dimension. Defaults to `-1` that means padding
 551      *                   corresponding to @p paddings.
 552      */
 553     class CV_EXPORTS PaddingLayer : public Layer
 554     {
 555     public:
 556         static Ptr<PaddingLayer> create(const LayerParams& params);
 557     };
 558
 559     /* Activations */
 560     class CV_EXPORTS ActivationLayer : public Layer
 561     {
 562     public:
 563         virtual void forwardSlice(const float* src, float* dst, int len,
 564                                   size_t outPlaneSize, int cn0, int cn1) const {};
 565         virtual void forwardSlice(const int* src, const int* lut, int* dst, int len,
 566                                   size_t outPlaneSize, int cn0, int cn1) const {};
 567         virtual void forwardSlice(const int8_t* src, const int8_t* lut, int8_t* dst, int len,
 568                                   size_t outPlaneSize, int cn0, int cn1) const {};
 569     };
 570
 571     class CV_EXPORTS ReLULayer : public ActivationLayer
 572     {
 573     public:
 574         float negativeSlope;
 575
 576         static Ptr<ReLULayer> create(const LayerParams &params);
 577     };
 578
 579     class CV_EXPORTS ReLU6Layer : public ActivationLayer
 580     {
 581     public:
 582         float minValue, maxValue;
 583
 584         static Ptr<ReLU6Layer> create(const LayerParams &params);
 585     };
 586
 587     class CV_EXPORTS ChannelsPReLULayer : public ActivationLayer
 588     {
 589     public:
 590         static Ptr<Layer> create(const LayerParams& params);
 591     };
 592
 593     class CV_EXPORTS ELULayer : public ActivationLayer
 594     {
 595     public:
 596         float alpha;
 597
 598         static Ptr<ELULayer> create(const LayerParams &params);
 599     };
 600
 601     class CV_EXPORTS TanHLayer : public ActivationLayer
 602     {
 603     public:
 604         static Ptr<TanHLayer> create(const LayerParams &params);
 605     };
 606
 607     class CV_EXPORTS SwishLayer : public ActivationLayer
 608     {
 609     public:
 610         static Ptr<SwishLayer> create(const LayerParams &params);
 611     };
 612
 613     class CV_EXPORTS MishLayer : public ActivationLayer
 614     {
 615     public:
 616         static Ptr<MishLayer> create(const LayerParams &params);
 617     };
 618
 619     class CV_EXPORTS SigmoidLayer : public ActivationLayer
 620     {
 621     public:
 622         static Ptr<SigmoidLayer> create(const LayerParams &params);
 623     };
 624
 625     class CV_EXPORTS BNLLLayer : public ActivationLayer
 626     {
 627     public:
 628         static Ptr<BNLLLayer> create(const LayerParams &params);
 629     };
 630
 631     class CV_EXPORTS AbsLayer : public ActivationLayer
 632     {
 633     public:
 634         static Ptr<AbsLayer> create(const LayerParams &params);
 635     };
 636
 637     class CV_EXPORTS PowerLayer : public ActivationLayer
 638     {
 639     public:
 640         float power, scale, shift;
 641
 642         static Ptr<PowerLayer> create(const LayerParams &params);
 643     };
 644
 645     class CV_EXPORTS ExpLayer : public ActivationLayer
 646     {
 647     public:
 648         float base, scale, shift;
 649
 650         static Ptr<ExpLayer> create(const LayerParams &params);
 651     };
 652
 653     class CV_EXPORTS CeilLayer : public ActivationLayer
 654     {
 655     public:
 656         static Ptr<CeilLayer> create(const LayerParams &params);
 657     };
 658
 659     class CV_EXPORTS FloorLayer : public ActivationLayer
 660     {
 661     public:
 662         static Ptr<FloorLayer> create(const LayerParams &params);
 663     };
 664
 665     class CV_EXPORTS LogLayer : public ActivationLayer
 666     {
 667     public:
 668         static Ptr<LogLayer> create(const LayerParams &params);
 669     };
 670
 671     class CV_EXPORTS RoundLayer : public ActivationLayer
 672     {
 673     public:
 674         static Ptr<RoundLayer> create(const LayerParams &params);
 675     };
 676
 677     class CV_EXPORTS SqrtLayer : public ActivationLayer
 678     {
 679     public:
 680         static Ptr<SqrtLayer> create(const LayerParams &params);
 681     };
 682
 683     class CV_EXPORTS NotLayer : public ActivationLayer
 684     {
 685     public:
 686         static Ptr<NotLayer> create(const LayerParams &params);
 687     };
 688
 689     class CV_EXPORTS AcosLayer : public ActivationLayer
 690     {
 691     public:
 692         static Ptr<AcosLayer> create(const LayerParams &params);
 693     };
 694
 695     class CV_EXPORTS AcoshLayer : public ActivationLayer
 696     {
 697     public:
 698         static Ptr<AcoshLayer> create(const LayerParams &params);
 699     };
 700
 701     class CV_EXPORTS AsinLayer : public ActivationLayer
 702     {
 703     public:
 704         static Ptr<AsinLayer> create(const LayerParams &params);
 705     };
 706
 707     class CV_EXPORTS AsinhLayer : public ActivationLayer
 708     {
 709     public:
 710         static Ptr<AsinhLayer> create(const LayerParams &params);
 711     };
 712
 713     class CV_EXPORTS AtanLayer : public ActivationLayer
 714     {
 715     public:
 716         static Ptr<AtanLayer> create(const LayerParams &params);
 717     };
 718
 719     class CV_EXPORTS AtanhLayer : public ActivationLayer
 720     {
 721     public:
 722         static Ptr<AtanhLayer> create(const LayerParams &params);
 723     };
 724
 725     class CV_EXPORTS CosLayer : public ActivationLayer
 726     {
 727     public:
 728         static Ptr<CosLayer> create(const LayerParams &params);
 729     };
 730
 731     class CV_EXPORTS CoshLayer : public ActivationLayer
 732     {
 733     public:
 734         static Ptr<CoshLayer> create(const LayerParams &params);
 735     };
 736
 737     class CV_EXPORTS ErfLayer : public ActivationLayer
 738     {
 739     public:
 740         static Ptr<ErfLayer> create(const LayerParams &params);
 741     };
 742
 743     class CV_EXPORTS HardSwishLayer : public ActivationLayer
 744     {
 745     public:
 746         static Ptr<HardSwishLayer> create(const LayerParams &params);
 747     };
 748
 749     class CV_EXPORTS SinLayer : public ActivationLayer
 750     {
 751     public:
 752         static Ptr<SinLayer> create(const LayerParams &params);
 753     };
 754
 755     class CV_EXPORTS SinhLayer : public ActivationLayer
 756     {
 757     public:
 758         static Ptr<SinhLayer> create(const LayerParams &params);
 759     };
 760
 761     class CV_EXPORTS SoftplusLayer : public ActivationLayer
 762     {
 763     public:
 764         static Ptr<SoftplusLayer> create(const LayerParams &params);
 765     };
 766
 767     class CV_EXPORTS SoftsignLayer : public ActivationLayer
 768     {
 769     public:
 770         static Ptr<SoftsignLayer> create(const LayerParams &params);
 771     };
 772
 773     class CV_EXPORTS TanLayer : public ActivationLayer
 774     {
 775     public:
 776         static Ptr<TanLayer> create(const LayerParams &params);
 777     };
 778
 779     class CV_EXPORTS CeluLayer : public ActivationLayer
 780     {
 781     public:
 782         float alpha;
 783
 784         static Ptr<CeluLayer> create(const LayerParams &params);
 785     };
 786
 787     class CV_EXPORTS HardSigmoidLayer : public ActivationLayer
 788     {
 789     public:
 790         float alpha;
 791         float beta;
 792
 793         static Ptr<HardSigmoidLayer> create(const LayerParams &params);
 794     };
 795
 796     class CV_EXPORTS SeluLayer : public ActivationLayer
 797     {
 798     public:
 799         float alpha;
 800         float gamma;
 801
 802         static Ptr<SeluLayer> create(const LayerParams &params);
 803     };
 804
 805     class CV_EXPORTS ThresholdedReluLayer : public ActivationLayer
 806     {
 807     public:
 808         float alpha;
 809
 810         static Ptr<ThresholdedReluLayer> create(const LayerParams &params);
 811     };
 812
 813     class CV_EXPORTS ActivationLayerInt8 : public ActivationLayer
 814     {
 815     public:
 816         static Ptr<ActivationLayerInt8> create(const LayerParams &params);
 817     };
 818
 819     class CV_EXPORTS SignLayer : public ActivationLayer
 820     {
 821     public:
 822         static Ptr<SignLayer> create(const LayerParams &params);
 823     };
 824
 825     class CV_EXPORTS ShrinkLayer : public ActivationLayer
 826     {
 827     public:
 828         float bias;
 829         float lambd;
 830         static Ptr<ShrinkLayer> create(const LayerParams &params);
 831     };
 832
 833     class CV_EXPORTS ReciprocalLayer : public ActivationLayer
 834     {
 835     public:
 836         static Ptr<ReciprocalLayer> create(const LayerParams &params);
 837     };
 838
 839     /* Layers used in semantic segmentation */
 840
 841     class CV_EXPORTS CropLayer : public Layer
 842     {
 843     public:
 844         static Ptr<Layer> create(const LayerParams &params);
 845     };
 846
 847     /** @brief Element wise operation on inputs
 848
 849     Extra optional parameters:
 850     - "operation" as string. Values are "sum" (default), "prod", "max", "div", "min"
 851     - "coeff" as float array. Specify weights of inputs for SUM operation
 852     - "output_channels_mode" as string. Values are "same" (default, all input must have the same layout), "input_0", "input_0_truncate", "max_input_channels"
 853     */
 854     class CV_EXPORTS EltwiseLayer : public Layer
 855     {
 856     public:
 857         static Ptr<EltwiseLayer> create(const LayerParams &params);
 858     };
 859
 860     class CV_EXPORTS EltwiseLayerInt8 : public Layer
 861     {
 862     public:
 863         static Ptr<EltwiseLayerInt8> create(const LayerParams &params);
 864     };
 865
 866     class CV_EXPORTS NaryEltwiseLayer : public Layer
 867     {
 868     public:
 869         static Ptr<NaryEltwiseLayer> create(const LayerParams &params);
 870     };
 871
 872     class CV_EXPORTS BatchNormLayer : public ActivationLayer
 873     {
 874     public:
 875         bool hasWeights, hasBias;
 876         float epsilon;
 877
 878         static Ptr<BatchNormLayer> create(const LayerParams &params);
 879     };
 880
 881     class CV_EXPORTS BatchNormLayerInt8 : public BatchNormLayer
 882     {
 883     public:
 884         float input_sc, output_sc;
 885         int input_zp, output_zp;
 886         static Ptr<BatchNormLayerInt8> create(const LayerParams &params);
 887     };
 888
 889     class CV_EXPORTS MaxUnpoolLayer : public Layer
 890     {
 891     public:
 892         Size poolKernel;
 893         Size poolPad;
 894         Size poolStride;
 895
 896         static Ptr<MaxUnpoolLayer> create(const LayerParams &params);
 897     };
 898
 899     class CV_EXPORTS ScaleLayer : public Layer
 900     {
 901     public:
 902         bool hasBias;
 903         int axis;
 904         String mode;
 905
 906         static Ptr<ScaleLayer> create(const LayerParams& params);
 907     };
 908
 909     class CV_EXPORTS ScaleLayerInt8 : public ScaleLayer
 910     {
 911     public:
 912         float output_sc;
 913         int output_zp;
 914         static Ptr<ScaleLayerInt8> create(const LayerParams &params);
 915     };
 916
 917     class CV_EXPORTS ShiftLayer : public Layer
 918     {
 919     public:
 920         static Ptr<Layer> create(const LayerParams& params);
 921     };
 922
 923     class CV_EXPORTS ShiftLayerInt8 : public Layer
 924     {
 925     public:
 926         static Ptr<Layer> create(const LayerParams& params);
 927     };
 928
 929     class CV_EXPORTS CompareLayer : public Layer
 930     {
 931     public:
 932         static Ptr<Layer> create(const LayerParams& params);
 933     };
 934
 935     class CV_EXPORTS DataAugmentationLayer : public Layer
 936     {
 937     public:
 938         static Ptr<DataAugmentationLayer> create(const LayerParams& params);
 939     };
 940
 941     class CV_EXPORTS CorrelationLayer : public Layer
 942     {
 943     public:
 944         static Ptr<CorrelationLayer> create(const LayerParams& params);
 945     };
 946
 947     class CV_EXPORTS AccumLayer : public Layer
 948     {
 949     public:
 950         static Ptr<AccumLayer> create(const LayerParams& params);
 951     };
 952
 953     class CV_EXPORTS FlowWarpLayer : public Layer
 954     {
 955     public:
 956         static Ptr<FlowWarpLayer> create(const LayerParams& params);
 957     };
 958
 959     class CV_EXPORTS PriorBoxLayer : public Layer
 960     {
 961     public:
 962         static Ptr<PriorBoxLayer> create(const LayerParams& params);
 963     };
 964
 965     class CV_EXPORTS ReorgLayer : public Layer
 966     {
 967     public:
 968         static Ptr<ReorgLayer> create(const LayerParams& params);
 969     };
 970
 971     class CV_EXPORTS RegionLayer : public Layer
 972     {
 973     public:
 974         float nmsThreshold;
 975
 976         static Ptr<RegionLayer> create(const LayerParams& params);
 977     };
 978
 979     /**
 980      * @brief Detection output layer.
 981      *
 982      * The layer size is: @f$ (1 \times 1 \times N \times 7) @f$
 983      *    where N is [keep_top_k] parameter multiplied by batch size. Each row is:
 984      *    [image_id, label, confidence, xmin, ymin, xmax, ymax]
 985      *    where image_id is the index of image input in the batch.
 986      */
 987     class CV_EXPORTS DetectionOutputLayer : public Layer
 988     {
 989     public:
 990         static Ptr<DetectionOutputLayer> create(const LayerParams& params);
 991     };
 992
 993     /**
 994      * @brief \f$ L_p \f$ - normalization layer.
 995      * @param p Normalization factor. The most common `p = 1` for \f$ L_1 \f$ -
 996      *          normalization or `p = 2` for \f$ L_2 \f$ - normalization or a custom one.
 997      * @param eps Parameter \f$ \epsilon \f$ to prevent a division by zero.
 998      * @param across_spatial If true, normalize an input across all non-batch dimensions.
 999      *                       Otherwise normalize an every channel separately.
1000      *
1001      * Across spatial:
1002      * @f[
1003      * norm = \sqrt[p]{\epsilon + \sum_{x, y, c} |src(x, y, c)|^p } \\
1004      * dst(x, y, c) = \frac{ src(x, y, c) }{norm}
1005      * @f]
1006      *
1007      * Channel wise normalization:
1008      * @f[
1009      * norm(c) = \sqrt[p]{\epsilon + \sum_{x, y} |src(x, y, c)|^p } \\
1010      * dst(x, y, c) = \frac{ src(x, y, c) }{norm(c)}
1011      * @f]
1012      *
1013      * Where `x, y` - spatial coordinates, `c` - channel.
1014      *
1015      * An every sample in the batch is normalized separately. Optionally,
1016      * output is scaled by the trained parameters.
1017      */
1018     class CV_EXPORTS NormalizeBBoxLayer : public Layer
1019     {
1020     public:
1021         float pnorm, epsilon;
1022         CV_DEPRECATED_EXTERNAL bool acrossSpatial;
1023
1024         static Ptr<NormalizeBBoxLayer> create(const LayerParams& params);
1025     };
1026
1027     /**
1028      * @brief Resize input 4-dimensional blob by nearest neighbor or bilinear strategy.
1029      *
1030      * Layer is used to support TensorFlow's resize_nearest_neighbor and resize_bilinear ops.
1031      */
1032     class CV_EXPORTS ResizeLayer : public Layer
1033     {
1034     public:
1035         static Ptr<ResizeLayer> create(const LayerParams& params);
1036     };
1037
1038     /**
1039      * @brief Bilinear resize layer from https://github.com/cdmh/deeplab-public-ver2
1040      *
1041      * It differs from @ref ResizeLayer in output shape and resize scales computations.
1042      */
1043     class CV_EXPORTS InterpLayer : public Layer
1044     {
1045     public:
1046         static Ptr<Layer> create(const LayerParams& params);
1047     };
1048
1049     class CV_EXPORTS ProposalLayer : public Layer
1050     {
1051     public:
1052         static Ptr<ProposalLayer> create(const LayerParams& params);
1053     };
1054
1055     class CV_EXPORTS CropAndResizeLayer : public Layer
1056     {
1057     public:
1058         static Ptr<Layer> create(const LayerParams& params);
1059     };
1060
1061     class CV_EXPORTS CumSumLayer : public Layer
1062     {
1063     public:
1064         int exclusive;
1065         int reverse;
1066
1067         static Ptr<CumSumLayer> create(const LayerParams& params);
1068     };
1069
1070     class CV_EXPORTS ScatterLayer : public Layer
1071     {
1072     public:
1073         static Ptr<ScatterLayer> create(const LayerParams& params);
1074     };
1075
1076     class CV_EXPORTS ScatterNDLayer : public Layer
1077     {
1078     public:
1079         static Ptr<ScatterNDLayer> create(const LayerParams& params);
1080     };
1081
1082     class CV_EXPORTS TileLayer : public Layer
1083     {
1084     public:
1085         static Ptr<TileLayer> create(const LayerParams& params);
1086     };
1087
1088 //! @}
1089 //! @}
1090 CV__DNN_INLINE_NS_END
1091 }
1092 }
1093 #endif