1
/*M///////////////////////////////////////////////////////////////////////////////////////
3
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
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.
11
// For Open Source Computer Vision Library
13
// Copyright (C) 2013, OpenCV Foundation, all rights reserved.
14
// Third party copyrights are property of their respective owners.
16
// Redistribution and use in source and binary forms, with or without modification,
17
// are permitted provided that the following conditions are met:
19
// * Redistribution's of source code must retain the above copyright notice,
20
// this list of conditions and the following disclaimer.
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.
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.
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.
42
#ifndef OPENCV_DNN_DNN_ALL_LAYERS_HPP
43
#define OPENCV_DNN_DNN_ALL_LAYERS_HPP
44
#include <opencv2/dnn.hpp>
48
CV__DNN_INLINE_NS_BEGIN
52
/** @defgroup dnnLayerList Partial List of Implemented Layers
54
This subsection of dnn module contains information about built-in layers and their descriptions.
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()).
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:
66
- TanH, ReLU, Sigmoid, BNLL, Power, AbsVal
68
- Reshape, Flatten, Slice, Split
71
- Dropout (since it does nothing on forward pass -))
74
class CV_EXPORTS BlankLayer : public Layer
77
static Ptr<Layer> create(const LayerParams ¶ms);
81
* Constant layer produces the same data blob at an every forward pass.
83
class CV_EXPORTS ConstLayer : public Layer
86
static Ptr<Layer> create(const LayerParams ¶ms);
89
//! LSTM recurrent layer
90
class CV_EXPORTS LSTMLayer : public Layer
93
/** Creates instance of LSTM layer */
94
static Ptr<LSTMLayer> create(const LayerParams& params);
96
/** @deprecated Use LayerParams::blobs instead.
97
@brief Set trained weights for LSTM layer.
99
LSTM behavior on each step is defined by current input, previous output, previous cell state and learned weights.
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:
104
h_t &= o_t \odot tanh(c_t), \\
105
c_t &= f_t \odot c_{t-1} + i_t \odot g_t, \\
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 wights.
109
Gates are computed as follows:
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), \\
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$.
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$.
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$)
128
CV_DEPRECATED virtual void setWeights(const Mat &Wh, const Mat &Wx, const Mat &b) = 0;
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().
134
virtual void setOutShape(const MatShape &outTailShape = MatShape()) = 0;
136
/** @deprecated Use flag `produce_cell_output` in LayerParams.
137
* @brief Specifies either interpret first dimension of input blob as timestamp dimenion either as sample.
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.
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]`].
145
CV_DEPRECATED virtual void setUseTimstampsDim(bool use = true) = 0;
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.
151
CV_DEPRECATED virtual void setProduceCellOutput(bool produce = false) = 0;
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).
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, ...]).
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, ...]).
164
int inputNameToIndex(String inputName) CV_OVERRIDE;
165
int outputNameToIndex(const String& outputName) CV_OVERRIDE;
168
/** @brief Classical recurrent layer
170
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$.
172
- input: should contain packed input @f$x_t@f$.
173
- output: should contain output @f$o_t@f$ (and @f$h_t@f$ if setProduceHiddenOutput() is set to true).
175
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.
177
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.
179
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.
181
class CV_EXPORTS RNNLayer : public Layer
184
/** Creates instance of RNNLayer */
185
static Ptr<RNNLayer> create(const LayerParams& params);
187
/** Setups learned weights.
189
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:
191
h_t &= tanh&(W_{hh} h_{t-1} + W_{xh} x_t + b_h), \\
192
o_t &= tanh&(W_{ho} h_t + b_o),
195
@param Wxh is @f$ W_{xh} @f$ matrix
196
@param bh is @f$ b_{h} @f$ vector
197
@param Whh is @f$ W_{hh} @f$ matrix
198
@param Who is @f$ W_{xo} @f$ matrix
199
@param bo is @f$ b_{o} @f$ vector
201
virtual void setWeights(const Mat &Wxh, const Mat &bh, const Mat &Whh, const Mat &Who, const Mat &bo) = 0;
203
/** @brief If this flag is set to true then layer will produce @f$ h_t @f$ as second output.
204
* @details Shape of the second output is the same as first output.
206
virtual void setProduceHiddenOutput(bool produce = false) = 0;
210
class CV_EXPORTS BaseConvolutionLayer : public Layer
213
CV_DEPRECATED_EXTERNAL Size kernel, stride, pad, dilation, adjustPad;
214
std::vector<size_t> adjust_pads;
215
std::vector<size_t> kernel_size, strides, dilations;
216
std::vector<size_t> pads_begin, pads_end;
221
class CV_EXPORTS ConvolutionLayer : public BaseConvolutionLayer
224
static Ptr<BaseConvolutionLayer> create(const LayerParams& params);
227
class CV_EXPORTS DeconvolutionLayer : public BaseConvolutionLayer
230
static Ptr<BaseConvolutionLayer> create(const LayerParams& params);
233
class CV_EXPORTS LRNLayer : public Layer
239
float alpha, beta, bias;
242
static Ptr<LRNLayer> create(const LayerParams& params);
245
class CV_EXPORTS PoolingLayer : public Layer
249
std::vector<size_t> kernel_size, strides;
250
std::vector<size_t> pads_begin, pads_end;
251
CV_DEPRECATED_EXTERNAL Size kernel, stride, pad;
252
CV_DEPRECATED_EXTERNAL int pad_l, pad_t, pad_r, pad_b;
257
// If true for average pooling with padding, divide an every output region
258
// by a whole kernel area. Otherwise exclude zero padded values and divide
259
// by number of real values.
260
bool avePoolPaddedArea;
261
// ROIPooling parameters.
264
// PSROIPooling parameters.
265
int psRoiOutChannels;
267
static Ptr<PoolingLayer> create(const LayerParams& params);
270
class CV_EXPORTS SoftmaxLayer : public Layer
275
static Ptr<SoftmaxLayer> create(const LayerParams& params);
278
class CV_EXPORTS InnerProductLayer : public Layer
282
static Ptr<InnerProductLayer> create(const LayerParams& params);
285
class CV_EXPORTS MVNLayer : public Layer
289
bool normVariance, acrossChannels;
291
static Ptr<MVNLayer> create(const LayerParams& params);
296
class CV_EXPORTS ReshapeLayer : public Layer
299
MatShape newShapeDesc;
302
static Ptr<ReshapeLayer> create(const LayerParams& params);
305
class CV_EXPORTS FlattenLayer : public Layer
308
static Ptr<FlattenLayer> create(const LayerParams ¶ms);
311
class CV_EXPORTS ConcatLayer : public Layer
316
* @brief Add zero padding in case of concatenation of blobs with different
319
* Details: https://github.com/torch/nn/blob/master/doc/containers.md#depthconcat
323
static Ptr<ConcatLayer> create(const LayerParams ¶ms);
326
class CV_EXPORTS SplitLayer : public Layer
329
int outputsCount; //!< Number of copies that will be produced (is ignored when negative).
331
static Ptr<SplitLayer> create(const LayerParams ¶ms);
335
* Slice layer has several modes:
337
* @param[in] axis Axis of split operation
338
* @param[in] slice_point Array of split points
340
* Number of output blobs equals to number of split points plus one. The
341
* first blob is a slice on input from 0 to @p slice_point[0] - 1 by @p axis,
342
* the second output blob is a slice of input from @p slice_point[0] to
343
* @p slice_point[1] - 1 by @p axis and the last output blob is a slice of
344
* input from @p slice_point[-1] up to the end of @p axis size.
347
* @param begin Vector of start indices
348
* @param size Vector of sizes
350
* More convenient numpy-like slice. One and only output blob
351
* is a slice `input[begin[0]:begin[0]+size[0], begin[1]:begin[1]+size[1], ...]`
354
* @param axis Axis of split operation
356
* Split input blob on the equal parts by @p axis.
358
class CV_EXPORTS SliceLayer : public Layer
362
* @brief Vector of slice ranges.
364
* The first dimension equals number of output blobs.
365
* Inner vector has slice ranges for the first number of input dimensions.
367
std::vector<std::vector<Range> > sliceRanges;
370
static Ptr<SliceLayer> create(const LayerParams ¶ms);
373
class CV_EXPORTS PermuteLayer : public Layer
376
static Ptr<PermuteLayer> create(const LayerParams& params);
380
* Permute channels of 4-dimensional input blob.
381
* @param group Number of groups to split input channels and pick in turns
384
* \f[ groupSize = \frac{number\ of\ channels}{group} \f]
385
* \f[ output(n, c, h, w) = input(n, groupSize \times (c \% group) + \lfloor \frac{c}{group} \rfloor, h, w) \f]
386
* Read more at https://arxiv.org/pdf/1707.01083.pdf
388
class CV_EXPORTS ShuffleChannelLayer : public Layer
391
static Ptr<Layer> create(const LayerParams& params);
397
* @brief Adds extra values for specific axes.
398
* @param paddings Vector of paddings in format
400
* [ pad_before, pad_after, // [0]th dimension
401
* pad_before, pad_after, // [1]st dimension
403
* pad_before, pad_after ] // [n]th dimension
405
* that represents number of padded values at every dimension
406
* starting from the first one. The rest of dimensions won't
408
* @param value Value to be padded. Defaults to zero.
409
* @param type Padding type: 'constant', 'reflect'
410
* @param input_dims Torch's parameter. If @p input_dims is not equal to the
411
* actual input dimensionality then the `[0]th` dimension
412
* is considered as a batch dimension and @p paddings are shifted
413
* to a one dimension. Defaults to `-1` that means padding
414
* corresponding to @p paddings.
416
class CV_EXPORTS PaddingLayer : public Layer
419
static Ptr<PaddingLayer> create(const LayerParams& params);
423
class CV_EXPORTS ActivationLayer : public Layer
426
virtual void forwardSlice(const float* src, float* dst, int len,
427
size_t outPlaneSize, int cn0, int cn1) const = 0;
430
class CV_EXPORTS ReLULayer : public ActivationLayer
435
static Ptr<ReLULayer> create(const LayerParams ¶ms);
438
class CV_EXPORTS ReLU6Layer : public ActivationLayer
441
float minValue, maxValue;
443
static Ptr<ReLU6Layer> create(const LayerParams ¶ms);
446
class CV_EXPORTS ChannelsPReLULayer : public ActivationLayer
449
static Ptr<Layer> create(const LayerParams& params);
452
class CV_EXPORTS ELULayer : public ActivationLayer
455
static Ptr<ELULayer> create(const LayerParams ¶ms);
458
class CV_EXPORTS TanHLayer : public ActivationLayer
461
static Ptr<TanHLayer> create(const LayerParams ¶ms);
464
class CV_EXPORTS SigmoidLayer : public ActivationLayer
467
static Ptr<SigmoidLayer> create(const LayerParams ¶ms);
470
class CV_EXPORTS BNLLLayer : public ActivationLayer
473
static Ptr<BNLLLayer> create(const LayerParams ¶ms);
476
class CV_EXPORTS AbsLayer : public ActivationLayer
479
static Ptr<AbsLayer> create(const LayerParams ¶ms);
482
class CV_EXPORTS PowerLayer : public ActivationLayer
485
float power, scale, shift;
487
static Ptr<PowerLayer> create(const LayerParams ¶ms);
490
/* Layers used in semantic segmentation */
492
class CV_EXPORTS CropLayer : public Layer
495
static Ptr<Layer> create(const LayerParams ¶ms);
498
class CV_EXPORTS EltwiseLayer : public Layer
501
static Ptr<EltwiseLayer> create(const LayerParams ¶ms);
504
class CV_EXPORTS BatchNormLayer : public ActivationLayer
507
bool hasWeights, hasBias;
510
static Ptr<BatchNormLayer> create(const LayerParams ¶ms);
513
class CV_EXPORTS MaxUnpoolLayer : public Layer
520
static Ptr<MaxUnpoolLayer> create(const LayerParams ¶ms);
523
class CV_EXPORTS ScaleLayer : public Layer
529
static Ptr<ScaleLayer> create(const LayerParams& params);
532
class CV_EXPORTS ShiftLayer : public Layer
535
static Ptr<Layer> create(const LayerParams& params);
538
class CV_EXPORTS PriorBoxLayer : public Layer
541
static Ptr<PriorBoxLayer> create(const LayerParams& params);
544
class CV_EXPORTS ReorgLayer : public Layer
547
static Ptr<ReorgLayer> create(const LayerParams& params);
550
class CV_EXPORTS RegionLayer : public Layer
553
static Ptr<RegionLayer> create(const LayerParams& params);
556
class CV_EXPORTS DetectionOutputLayer : public Layer
559
static Ptr<DetectionOutputLayer> create(const LayerParams& params);
563
* @brief \f$ L_p \f$ - normalization layer.
564
* @param p Normalization factor. The most common `p = 1` for \f$ L_1 \f$ -
565
* normalization or `p = 2` for \f$ L_2 \f$ - normalization or a custom one.
566
* @param eps Parameter \f$ \epsilon \f$ to prevent a division by zero.
567
* @param across_spatial If true, normalize an input across all non-batch dimensions.
568
* Otherwise normalize an every channel separately.
572
* norm = \sqrt[p]{\epsilon + \sum_{x, y, c} |src(x, y, c)|^p } \\
573
* dst(x, y, c) = \frac{ src(x, y, c) }{norm}
576
* Channel wise normalization:
578
* norm(c) = \sqrt[p]{\epsilon + \sum_{x, y} |src(x, y, c)|^p } \\
579
* dst(x, y, c) = \frac{ src(x, y, c) }{norm(c)}
582
* Where `x, y` - spatial coordinates, `c` - channel.
584
* An every sample in the batch is normalized separately. Optionally,
585
* output is scaled by the trained parameters.
587
class CV_EXPORTS NormalizeBBoxLayer : public Layer
590
float pnorm, epsilon;
591
CV_DEPRECATED_EXTERNAL bool acrossSpatial;
593
static Ptr<NormalizeBBoxLayer> create(const LayerParams& params);
597
* @brief Resize input 4-dimensional blob by nearest neighbor or bilinear strategy.
599
* Layer is used to support TensorFlow's resize_nearest_neighbor and resize_bilinear ops.
601
class CV_EXPORTS ResizeLayer : public Layer
604
static Ptr<ResizeLayer> create(const LayerParams& params);
608
* @brief Bilinear resize layer from https://github.com/cdmh/deeplab-public-ver2
610
* It differs from @ref ResizeLayer in output shape and resize scales computations.
612
class CV_EXPORTS InterpLayer : public Layer
615
static Ptr<Layer> create(const LayerParams& params);
618
class CV_EXPORTS ProposalLayer : public Layer
621
static Ptr<ProposalLayer> create(const LayerParams& params);
624
class CV_EXPORTS CropAndResizeLayer : public Layer
627
static Ptr<Layer> create(const LayerParams& params);
632
CV__DNN_INLINE_NS_END
added
removed
usr/include/opencv2/dnn/all_layers.hpp
