Huawei_Technology
/
mindspore
Not watched
1
0
Fork 0
Code
Releases 13 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: 13c4106031
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '13c4106031'
${ noResults }
mindspore/mindspore/nn/layer/conv.py

916 lines
47 kB
Raw Blame History 

  1. # Copyright 2020 Huawei Technologies Co., Ltd

  2. #

  3. # Licensed under the Apache License, Version 2.0 (the "License");

  4. # you may not use this file except in compliance with the License.

  5. # You may obtain a copy of the License at

  6. #

  7. # http://www.apache.org/licenses/LICENSE-2.0

  8. #

  9. # Unless required by applicable law or agreed to in writing, software

  10. # distributed under the License is distributed on an "AS IS" BASIS,

  11. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

  12. # See the License for the specific language governing permissions and

  13. # limitations under the License.

  14. # ============================================================================

  15. """conv"""

  16. from mindspore import log as logger

  17. from mindspore.ops import operations as P

  18. from mindspore.common.parameter import Parameter

  19. from mindspore.common.initializer import initializer

  20. from mindspore._checkparam import ParamValidator as validator, Rel

  21. from mindspore._checkparam import Validator

  22. from mindspore._checkparam import check_bool, twice, check_int_positive

  23. from mindspore._extends import cell_attr_register

  24. from ..cell import Cell

  25. 

  26. __all__ = ['Conv2d', 'Conv2dTranspose', 'DepthwiseConv2d', 'Conv1d', 'Conv1dTranspose']

  27. 

  28. class _Conv(Cell):

  29.     """

  30.     Applies a N-D convolution over an input signal composed of several input planes.

  31.     """

  32.     def __init__(self,

  33.                  in_channels,

  34.                  out_channels,

  35.                  kernel_size,

  36.                  stride,

  37.                  pad_mode,

  38.                  padding,

  39.                  dilation,

  40.                  group,

  41.                  has_bias,

  42.                  weight_init,

  43.                  bias_init,

  44.                  transposed=False):

  45.         super(_Conv, self).__init__()

  46.         self.in_channels = check_int_positive(in_channels)

  47.         self.out_channels = check_int_positive(out_channels)

  48.         self.kernel_size = kernel_size

  49.         self.stride = stride

  50.         self.pad_mode = pad_mode

  51.         if isinstance(padding, int):

  52.             Validator.check_integer('padding', padding, 0, Rel.GE, self.cls_name)

  53.             self.padding = padding

  54.         elif isinstance(padding, tuple):

  55.             for pad in padding:

  56.                 Validator.check_integer('padding item', pad, 0, Rel.GE, self.cls_name)

  57.             self.padding = padding

  58.         else:

  59.             raise TypeError("padding type must be int/tuple(int) cannot be {}!".format(type(padding)))

  60. 

  61.         self.dilation = dilation

  62.         self.group = check_int_positive(group)

  63.         self.has_bias = has_bias

  64.         if (not isinstance(kernel_size[0], int)) or (not isinstance(kernel_size[1], int)) or \

  65.             kernel_size[0] < 1 or kernel_size[1] < 1:

  66.             raise ValueError("Attr 'kernel_size' of 'Conv2D' Op passed "

  67.                              + str(self.kernel_size) + ", should be a int or tuple and equal to or greater than 1.")

  68.         if (not isinstance(stride[0], int)) or (not isinstance(stride[1], int)) or stride[0] < 1 or stride[1] < 1:

  69.             raise ValueError("Attr 'stride' of 'Conv2D' Op passed "

  70.                              + str(self.stride) + ", should be a int or tuple and equal to or greater than 1.")

  71.         if (not isinstance(dilation[0], int)) or (not isinstance(dilation[1], int)) or \

  72.             dilation[0] < 1 or dilation[1] < 1:

  73.             raise ValueError("Attr 'dilation' of 'Conv2D' Op passed "

  74.                              + str(self.dilation) + ", should equal to or greater than 1.")

  75.         if in_channels % group != 0:

  76.             raise ValueError("Attr 'in_channels' of 'Conv2D' Op must be divisible by "

  77.                              "attr 'group' of 'Conv2D' Op.")

  78.         if out_channels % group != 0:

  79.             raise ValueError("Attr 'out_channels' of 'Conv2D' Op must be divisible by "

  80.                              "attr 'group' of 'Conv2D' Op.")

  81.         if transposed:

  82.             shape = [in_channels, out_channels // group, *kernel_size]

  83.         else:

  84.             shape = [out_channels, in_channels // group, *kernel_size]

  85.         self.weight = Parameter(initializer(weight_init, shape), name='weight')

  86. 

  87.         if check_bool(has_bias):

  88.             self.bias = Parameter(initializer(bias_init, [out_channels]), name='bias')

  89.         else:

  90.             if bias_init != 'zeros':

  91.                 logger.warning("Value of 'has_bias' is False, value of 'bias_init' will be ignored.")

  92.             self.bias = None

  93. 

  94.     def construct(self, *inputs):

  95.         """Must be overridden by all subclasses."""

  96.         raise NotImplementedError

  97. 

  98. 

  99. class Conv2d(_Conv):

  100.     r"""

  101.     2D convolution layer.

  102. 

  103.     Applies a 2D convolution over an input tensor which is typically of shape :math:`(N, C_{in}, H_{in}, W_{in})`,

  104.     where :math:`N` is batch size and :math:`C_{in}` is channel number. For each batch of shape

  105.     :math:`(C_{in}, H_{in}, W_{in})`, the formula is defined as:

  106. 

  107.     .. math::

  108. 

  109.         out_j = \sum_{i=0}^{C_{in} - 1} ccor(W_{ij}, X_i) + b_j,

  110. 

  111.     where :math:`ccor` is cross correlation operator, :math:`C_{in}` is the input channel number, :math:`j` ranges

  112.     from :math:`0` to :math:`C_{out} - 1`, :math:`W_{ij}` corresponds to :math:`i`-th channel of the :math:`j`-th

  113.     filter and :math:`out_{j}` corresponds to the :math:`j`-th channel of the output. :math:`W_{ij}` is a slice

  114.     of kernel and it has shape :math:`(\text{ks_h}, \text{ks_w})`, where :math:`\text{ks_h}` and

  115.     :math:`\text{ks_w}` are height and width of the convolution kernel. The full kernel has shape

  116.     :math:`(C_{out}, C_{in} // \text{group}, \text{ks_h}, \text{ks_w})`, where group is the group number

  117.     to split the input in the channel dimension.

  118. 

  119.     If the 'pad_mode' is set to be "valid", the output height and width will be

  120.     :math:`\left \lfloor{1 + \frac{H_{in} + 2 \times \text{padding} - \text{ks_h} -

  121.     (\text{ks_h} - 1) \times (\text{dilation} - 1) }{\text{stride}}} \right \rfloor` and

  122.     :math:`\left \lfloor{1 + \frac{W_{in} + 2 \times \text{padding} - \text{ks_w} -

  123.     (\text{ks_w} - 1) \times (\text{dilation} - 1) }{\text{stride}}} \right \rfloor` respectively.

  124. 

  125.     The first introduction can be found in paper `Gradient Based Learning Applied to Document Recognition

  126.     <http://vision.stanford.edu/cs598_spring07/papers/Lecun98.pdf>`_.

  127. 

  128.     Args:

  129.         in_channels (int): The number of input channel :math:`C_{in}`.

  130.         out_channels (int): The number of output channel :math:`C_{out}`.

  131.         kernel_size (Union[int, tuple[int]]): The data type is int or tuple with 2 integers. Specifies the height

  132.             and width of the 2D convolution window. Single int means the value if for both height and width of

  133.             the kernel. A tuple of 2 ints means the first value is for the height and the other is for the

  134.             width of the kernel.

  135.         stride (Union[int, tuple[int]]): The distance of kernel moving, an int number that represents

  136.             the height and width of movement are both strides, or a tuple of two int numbers that

  137.             represent height and width of movement respectively. Default: 1.

  138.         pad_mode (str): Specifies padding mode. The optional values are

  139.             "same", "valid", "pad". Default: "same".

  140. 

  141.             - same: Adopts the way of completion. Output height and width will be the same as the input.

  142.               Total number of padding will be calculated for horizontal and vertical

  143.               direction and evenly distributed to top and bottom, left and right if possible. Otherwise, the

  144.               last extra padding will be done from the bottom and the right side. If this mode is set, `padding`

  145.               must be 0.

  146. 

  147.             - valid: Adopts the way of discarding. The possibly largest height and width of output will be return

  148.               without padding. Extra pixels will be discarded. If this mode is set, `padding`

  149.               must be 0.

  150. 

  151.             - pad: Implicit paddings on both sides of the input. The number of `padding` will be padded to the input

  152.               Tensor borders. `padding` should be greater than or equal to 0.

  153. 

  154.         padding (Union[int, tuple[int]]): Implicit paddings on both sides of the input. If `padding` is one integer,

  155.                     the padding of top, bottom, left and right is same, equal to padding. If `padding` is tuple with

  156.                     four integer, the padding of top, bottom, left and right equal to padding[0], padding[1],

  157.                     padding[2], padding[3] with corresponding. Default: 0.

  158.         dilation (Union[int, tuple[int]]): The data type is int or tuple with 2 integers. Specifies the dilation rate

  159.                                       to use for dilated convolution. If set to be :math:`k > 1`, there will

  160.                                       be :math:`k - 1` pixels skipped for each sampling location. Its value should

  161.                                       be greater or equal to 1 and bounded by the height and width of the

  162.                                       input. Default: 1.

  163.         group (int): Split filter into groups, `in_ channels` and `out_channels` should be

  164.             divisible by the number of groups. Default: 1.

  165.         has_bias (bool): Specifies whether the layer uses a bias vector. Default: False.

  166.         weight_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the convolution kernel.

  167.             It can be a Tensor, a string, an Initializer or a numbers.Number. When a string is specified,

  168.             values from 'TruncatedNormal', 'Normal', 'Uniform', 'HeUniform' and 'XavierUniform' distributions as well

  169.             as constant 'One' and 'Zero' distributions are possible. Alias 'xavier_uniform', 'he_uniform', 'ones'

  170.             and 'zeros' are acceptable. Uppercase and lowercase are both acceptable. Refer to the values of

  171.             Initializer for more details. Default: 'normal'.

  172.         bias_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the bias vector. Possible

  173.             Initializer and string are the same as 'weight_init'. Refer to the values of

  174.             Initializer for more details. Default: 'zeros'.

  175. 

  176.     Inputs:

  177.         - **input** (Tensor) - Tensor of shape :math:`(N, C_{in}, H_{in}, W_{in})`.

  178. 

  179.     Outputs:

  180.         Tensor of shape :math:`(N, C_{out}, H_{out}, W_{out})`.

  181. 

  182.     Examples:

  183.         >>> net = nn.Conv2d(120, 240, 4, has_bias=False, weight_init='normal')

  184.         >>> input = Tensor(np.ones([1, 120, 1024, 640]), mindspore.float32)

  185.         >>> net(input).shape

  186.         (1, 240, 1024, 640)

  187.     """

  188.     @cell_attr_register

  189.     def __init__(self,

  190.                  in_channels,

  191.                  out_channels,

  192.                  kernel_size,

  193.                  stride=1,

  194.                  pad_mode='same',

  195.                  padding=0,

  196.                  dilation=1,

  197.                  group=1,

  198.                  has_bias=False,

  199.                  weight_init='normal',

  200.                  bias_init='zeros'):

  201.         kernel_size = twice(kernel_size)

  202.         stride = twice(stride)

  203.         dilation = twice(dilation)

  204.         super(Conv2d, self).__init__(

  205.             in_channels,

  206.             out_channels,

  207.             kernel_size,

  208.             stride,

  209.             pad_mode,

  210.             padding,

  211.             dilation,

  212.             group,

  213.             has_bias,

  214.             weight_init,

  215.             bias_init)

  216.         self.conv2d = P.Conv2D(out_channel=self.out_channels,

  217.                                kernel_size=self.kernel_size,

  218.                                mode=1,

  219.                                pad_mode=self.pad_mode,

  220.                                pad=self.padding,

  221.                                stride=self.stride,

  222.                                dilation=self.dilation,

  223.                                group=self.group)

  224.         self.bias_add = P.BiasAdd()

  225.         if pad_mode not in ('valid', 'same', 'pad'):

  226.             raise ValueError('Attr \'pad_mode\' of \'Conv2d\' Op passed '

  227.                              + str(pad_mode) + ', should be one of values in \'valid\', \'same\', \'pad\'.')

  228. 

  229.     def construct(self, x):

  230.         output = self.conv2d(x, self.weight)

  231.         if self.has_bias:

  232.             output = self.bias_add(output, self.bias)

  233.         return output

  234. 

  235.     def extend_repr(self):

  236.         s = 'input_channels={}, output_channels={}, kernel_size={},' \

  237.             'stride={},  pad_mode={}, padding={}, dilation={}, ' \

  238.             'group={}, has_bias={},' \

  239.             'weight_init={}, bias_init={}'.format(

  240.                 self.in_channels,

  241.                 self.out_channels,

  242.                 self.kernel_size,

  243.                 self.stride,

  244.                 self.pad_mode,

  245.                 self.padding,

  246.                 self.dilation,

  247.                 self.group,

  248.                 self.has_bias,

  249.                 self.weight,

  250.                 self.bias)

  251. 

  252.         if self.has_bias:

  253.             s += ', bias={}'.format(self.bias)

  254.         return s

  255. 

  256. 

  257. class Conv1d(_Conv):

  258.     r"""

  259.     1D convolution layer.

  260. 

  261.     Applies a 1D convolution over an input tensor which is typically of shape :math:`(N, C_{in}, W_{in})`,

  262.     where :math:`N` is batch size and :math:`C_{in}` is channel number. For each batch of shape

  263.     :math:`(C_{in}, W_{in})`, the formula is defined as:

  264. 

  265.     .. math::

  266. 

  267.         out_j = \sum_{i=0}^{C_{in} - 1} ccor(W_{ij}, X_i) + b_j,

  268. 

  269.     where :math:`ccor` is cross correlation operator, :math:`C_{in}` is the input channel number, :math:`j` ranges

  270.     from :math:`0` to :math:`C_{out} - 1`, :math:`W_{ij}` corresponds to :math:`i`-th channel of the :math:`j`-th

  271.     filter and :math:`out_{j}` corresponds to the :math:`j`-th channel of the output. :math:`W_{ij}` is a slice

  272.     of kernel and it has shape :math:`(\text{ks_w})`, where :math:`\text{ks_w}` are width of the convolution kernel.

  273.     The full kernel has shape :math:`(C_{out}, C_{in} // \text{group}, \text{ks_w})`, where group is the group number

  274.     to split the input in the channel dimension.

  275. 

  276.     If the 'pad_mode' is set to be "valid", the output width will be

  277.     :math:`\left \lfloor{1 + \frac{W_{in} + 2 \times \text{padding} - \text{ks_w} -

  278.     (\text{ks_w} - 1) \times (\text{dilation} - 1) }{\text{stride}}} \right \rfloor` respectively.

  279. 

  280.     The first introduction can be found in paper `Gradient Based Learning Applied to Document Recognition

  281.     <http://vision.stanford.edu/cs598_spring07/papers/Lecun98.pdf>`_.

  282. 

  283.     Args:

  284.         in_channels (int): The number of input channel :math:`C_{in}`.

  285.         out_channels (int): The number of output channel :math:`C_{out}`.

  286.         kernel_size (int): The data type is int. Specifies the

  287.             width of the 1D convolution window.

  288.         stride (int): The distance of kernel moving, an int number that represents

  289.             the width of movement. Default: 1.

  290.         pad_mode (str): Specifies padding mode. The optional values are

  291.             "same", "valid", "pad". Default: "same".

  292. 

  293.             - same: Adopts the way of completion. Output width will be the same as the input.

  294.               Total number of padding will be calculated for horizontal

  295.               direction and evenly distributed to left and right if possible. Otherwise, the

  296.               last extra padding will be done from the bottom and the right side. If this mode is set, `padding`

  297.               must be 0.

  298. 

  299.             - valid: Adopts the way of discarding. The possibly largest width of output will be return

  300.               without padding. Extra pixels will be discarded. If this mode is set, `padding`

  301.               must be 0.

  302. 

  303.             - pad: Implicit paddings on both sides of the input. The number of `padding` will be padded to the input

  304.               Tensor borders. `padding` should be greater than or equal to 0.

  305. 

  306.         padding (int): Implicit paddings on both sides of the input. Default: 0.

  307.         dilation (int): The data type is int. Specifies the dilation rate

  308.                                       to use for dilated convolution. If set to be :math:`k > 1`, there will

  309.                                       be :math:`k - 1` pixels skipped for each sampling location. Its value should

  310.                                       be greater or equal to 1 and bounded by the height and width of the

  311.                                       input. Default: 1.

  312.         group (int): Split filter into groups, `in_ channels` and `out_channels` should be

  313.             divisible by the number of groups. Default: 1.

  314.         has_bias (bool): Specifies whether the layer uses a bias vector. Default: False.

  315.         weight_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the convolution kernel.

  316.             It can be a Tensor, a string, an Initializer or a numbers.Number. When a string is specified,

  317.             values from 'TruncatedNormal', 'Normal', 'Uniform', 'HeUniform' and 'XavierUniform' distributions as well

  318.             as constant 'One' and 'Zero' distributions are possible. Alias 'xavier_uniform', 'he_uniform', 'ones'

  319.             and 'zeros' are acceptable. Uppercase and lowercase are both acceptable. Refer to the values of

  320.             Initializer for more details. Default: 'normal'.

  321.         bias_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the bias vector. Possible

  322.             Initializer and string are the same as 'weight_init'. Refer to the values of

  323.             Initializer for more details. Default: 'zeros'.

  324. 

  325.     Inputs:

  326.         - **input** (Tensor) - Tensor of shape :math:`(N, C_{in}, W_{in})`.

  327. 

  328.     Outputs:

  329.         Tensor of shape :math:`(N, C_{out}, W_{out})`.

  330. 

  331.     Examples:

  332.         >>> net = nn.Conv1d(120, 240, 4, has_bias=False, weight_init='normal')

  333.         >>> input = Tensor(np.ones([1, 120, 640]), mindspore.float32)

  334.         >>> net(input).shape

  335.         (1, 240, 640)

  336.     """

  337.     @cell_attr_register

  338.     def __init__(self,

  339.                  in_channels,

  340.                  out_channels,

  341.                  kernel_size,

  342.                  stride=1,

  343.                  pad_mode='same',

  344.                  padding=0,

  345.                  dilation=1,

  346.                  group=1,

  347.                  has_bias=False,

  348.                  weight_init='normal',

  349.                  bias_init='zeros'):

  350. 

  351.         Validator.check_value_type("kernel_size", kernel_size, [int], self.cls_name)

  352.         Validator.check_value_type("stride", stride, [int], self.cls_name)

  353.         Validator.check_value_type("padding", padding, [int], self.cls_name)

  354.         Validator.check_value_type("dilation", dilation, [int], self.cls_name)

  355.         Validator.check_integer('kernel_size', kernel_size, 1, Rel.GE, self.cls_name)

  356.         Validator.check_integer('stride', stride, 1, Rel.GE, self.cls_name)

  357.         Validator.check_integer('padding', padding, 0, Rel.GE, self.cls_name)

  358.         Validator.check_integer('dilation', dilation, 1, Rel.GE, self.cls_name)

  359.         kernel_size = (1, kernel_size)

  360.         stride = (1, stride)

  361.         dilation = (1, dilation)

  362. 

  363.         super(Conv1d, self).__init__(

  364.             in_channels,

  365.             out_channels,

  366.             kernel_size,

  367.             stride,

  368.             pad_mode,

  369.             padding,

  370.             dilation,

  371.             group,

  372.             has_bias,

  373.             weight_init,

  374.             bias_init)

  375.         self.padding = (0, 0, padding, padding)

  376.         self.conv2d = P.Conv2D(out_channel=self.out_channels,

  377.                                kernel_size=self.kernel_size,

  378.                                mode=1,

  379.                                pad_mode=self.pad_mode,

  380.                                pad=self.padding,

  381.                                stride=self.stride,

  382.                                dilation=self.dilation,

  383.                                group=self.group)

  384.         self.bias_add = P.BiasAdd()

  385.         if pad_mode not in ('valid', 'same', 'pad'):

  386.             raise ValueError('Attr \'pad_mode\' of \'Conv1d\' Op passed '

  387.                              + str(pad_mode) + ', should be one of values in \'valid\', \'same\', \'pad\'.')

  388.         self.expand_dims = P.ExpandDims()

  389.         self.squeeze = P.Squeeze(2)

  390.         self.shape = P.Shape()

  391. 

  392.     def construct(self, x):

  393.         x_shape = self.shape(x)

  394.         if len(x_shape) == 3:

  395.             x = self.expand_dims(x, 2)

  396.         output = self.conv2d(x, self.weight)

  397.         if self.has_bias:

  398.             output = self.bias_add(output, self.bias)

  399.         if len(x_shape) == 3:

  400.             output = self.squeeze(output)

  401.         return output

  402. 

  403.     def extend_repr(self):

  404.         s = 'input_channels={}, output_channels={}, kernel_size={},' \

  405.             'stride={},  pad_mode={}, padding={}, dilation={}, ' \

  406.             'group={}, has_bias={},' \

  407.             'weight_init={}, bias_init={}'.format(

  408.                 self.in_channels,

  409.                 self.out_channels,

  410.                 self.kernel_size,

  411.                 self.stride,

  412.                 self.pad_mode,

  413.                 self.padding,

  414.                 self.dilation,

  415.                 self.group,

  416.                 self.has_bias,

  417.                 self.weight,

  418.                 self.bias)

  419. 

  420.         if self.has_bias:

  421.             s += ', bias={}'.format(self.bias)

  422.         return s

  423. 

  424. 

  425. class Conv2dTranspose(_Conv):

  426.     r"""

  427.     2D transposed convolution layer.

  428. 

  429.     Compute a 2D transposed convolution, which is also know as a deconvolution

  430.     (although it is not actual deconvolution).

  431. 

  432.     Input is typically of shape :math:`(N, C, H, W)`, where :math:`N` is batch size and :math:`C` is channel number.

  433. 

  434.     Args:

  435.         in_channels (int): The number of channels in the input space.

  436.         out_channels (int): The number of channels in the output space.

  437.         kernel_size (Union[int, tuple]): int or tuple with 2 integers, which specifies the  height

  438.             and width of the 2D convolution window. Single int means the value is for both height and width of

  439.             the kernel. A tuple of 2 ints means the first value is for the height and the other is for the

  440.             width of the kernel.

  441.         stride (Union[int, tuple[int]]): The distance of kernel moving, an int number that represents

  442.             the height and width of movement are both strides, or a tuple of two int numbers that

  443.             represent height and width of movement respectively. Default: 1.

  444.         pad_mode (str): Select the mode of the pad. The optional values are

  445.             "pad", "same", "valid". Default: "same".

  446. 

  447.             - pad: Implicit paddings on both sides of the input.

  448. 

  449.             - same: Adopted the way of completion.

  450. 

  451.             - valid: Adopted the way of discarding.

  452.         padding (Union[int, tuple[int]]): Implicit paddings on both sides of the input. If `padding` is one integer,

  453.                     the padding of top, bottom, left and right is same, equal to padding. If `padding` is tuple with

  454.                     four integer, the padding of top, bottom, left and right equal to padding[0], padding[1],

  455.                     padding[2], padding[3] with corresponding. Default: 0.

  456.         dilation (Union[int, tuple[int]]): The data type is int or tuple with 2 integers. Specifies the dilation rate

  457.                                       to use for dilated convolution. If set to be :math:`k > 1`, there will

  458.                                       be :math:`k - 1` pixels skipped for each sampling location. Its value should

  459.                                       be greater or equal to 1 and bounded by the height and width of the

  460.                                       input. Default: 1.

  461.         group (int): Split filter into groups, `in_channels` and `out_channels` should be

  462.             divisible by the number of groups. This is not support for Davinci devices when group > 1. Default: 1.

  463.         has_bias (bool): Specifies whether the layer uses a bias vector. Default: False.

  464.         weight_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the convolution kernel.

  465.             It can be a Tensor, a string, an Initializer or a numbers.Number. When a string is specified,

  466.             values from 'TruncatedNormal', 'Normal', 'Uniform', 'HeUniform' and 'XavierUniform' distributions as well

  467.             as constant 'One' and 'Zero' distributions are possible. Alias 'xavier_uniform', 'he_uniform', 'ones'

  468.             and 'zeros' are acceptable. Uppercase and lowercase are both acceptable. Refer to the values of

  469.             Initializer for more details. Default: 'normal'.

  470.         bias_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the bias vector. Possible

  471.             Initializer and string are the same as 'weight_init'. Refer to the values of

  472.             Initializer for more details. Default: 'zeros'.

  473. 

  474.     Inputs:

  475.         - **input** (Tensor) - Tensor of shape :math:`(N, C_{in}, H_{in}, W_{in})`.

  476. 

  477.     Outputs:

  478.         Tensor of shape :math:`(N, C_{out}, H_{out}, W_{out})`.

  479. 

  480.     Examples:

  481.         >>> net = nn.Conv2dTranspose(3, 64, 4, has_bias=False, weight_init='normal')

  482.         >>> input = Tensor(np.ones([1, 3, 16, 50]), mindspore.float32)

  483.         >>> net(input)

  484.         """

  485.     def __init__(self,

  486.                  in_channels,

  487.                  out_channels,

  488.                  kernel_size,

  489.                  stride=1,

  490.                  pad_mode='same',

  491.                  padding=0,

  492.                  dilation=1,

  493.                  group=1,

  494.                  has_bias=False,

  495.                  weight_init='normal',

  496.                  bias_init='zeros'):

  497.         kernel_size = twice(kernel_size)

  498.         stride = twice(stride)

  499.         dilation = twice(dilation)

  500.         Validator.check_value_type('padding', padding, (int, tuple), self.cls_name)

  501.         if isinstance(padding, tuple):

  502.             Validator.check_integer('padding size', len(padding), 4, Rel.EQ, self.cls_name)

  503.         # out_channels and in_channels swap.

  504.         # cause Conv2DBackpropInput's out_channel refers to Conv2D's out_channel,

  505.         # then Conv2dTranspose's out_channel refers to Conv2DBackpropInput's in_channel.

  506.         super(Conv2dTranspose, self).__init__(

  507.             in_channels,

  508.             out_channels,

  509.             kernel_size,

  510.             stride,

  511.             pad_mode,

  512.             padding,

  513.             dilation,

  514.             group,

  515.             has_bias,

  516.             weight_init,

  517.             bias_init,

  518.             transposed=True)

  519. 

  520.         self.in_channels = in_channels

  521.         self.out_channels = out_channels

  522.         self.shape = P.Shape()

  523.         if pad_mode not in ('valid', 'same', 'pad'):

  524.             raise ValueError('Attr \'pad_mode\' of \'Conv2dTranspose\' Op passed '

  525.                              + str(pad_mode) + ', should be one of values in \'valid\', \'same\', \'pad\'.')

  526.         self.is_valid = self.pad_mode == 'valid'

  527.         self.is_same = self.pad_mode == 'same'

  528.         self.is_pad = self.pad_mode == 'pad'

  529.         if check_bool(has_bias):

  530.             self.bias = Parameter(initializer(bias_init, [out_channels]), name='bias')

  531. 

  532.         # cause Conv2DBackpropInput's out_channel refers to Conv2D's out_channel.

  533.         self.conv2d_transpose = P.Conv2DBackpropInput(out_channel=in_channels,

  534.                                                       kernel_size=kernel_size,

  535.                                                       mode=1,

  536.                                                       pad_mode=pad_mode,

  537.                                                       pad=padding,

  538.                                                       stride=stride,

  539.                                                       dilation=dilation,

  540.                                                       group=group)

  541.         self.bias_add = P.BiasAdd()

  542.         if isinstance(self.padding, int):

  543.             self.padding_top, self.padding_bottom, self.padding_left, self.padding_right = (self.padding,) * 4

  544.         else:

  545.             self.padding_top, self.padding_bottom, self.padding_left, self.padding_right = self.padding

  546. 

  547.     def set_strategy(self, strategy):

  548.         self.conv2d_transpose.set_strategy(strategy)

  549.         return self

  550. 

  551.     def _deconv_output_length(self, input_length, filter_size, stride_size, dilation_size, padding):

  552.         """Calculate the width and height of output."""

  553.         length = 0

  554.         filter_size = filter_size + (filter_size - 1) * (dilation_size - 1)

  555.         if self.is_valid:

  556.             if filter_size - stride_size > 0:

  557.                 length = input_length * stride_size + filter_size - stride_size

  558.             else:

  559.                 length = input_length * stride_size

  560.         elif self.is_same:

  561.             length = input_length * stride_size

  562.         elif self.is_pad:

  563.             length = input_length * stride_size - padding + filter_size - stride_size

  564. 

  565.         return length

  566. 

  567.     def construct(self, x):

  568.         n, _, h, w = self.shape(x)

  569.         h_out = self._deconv_output_length(h, self.kernel_size[0], self.stride[0], self.dilation[0],

  570.                                            self.padding_top + self.padding_bottom)

  571.         w_out = self._deconv_output_length(w, self.kernel_size[1], self.stride[1], self.dilation[1],

  572.                                            self.padding_left + self.padding_right)

  573.         if self.has_bias:

  574.             return self.bias_add(self.conv2d_transpose(x, self.weight, (n, self.out_channels, h_out, w_out)),

  575.                                  self.bias)

  576.         return self.conv2d_transpose(x, self.weight, (n, self.out_channels, h_out, w_out))

  577. 

  578.     def extend_repr(self):

  579.         s = 'input_channels={}, output_channels={}, kernel_size={},' \

  580.             'stride={},  pad_mode={}, padding={}, dilation={}, ' \

  581.             'group={}, has_bias={},' \

  582.             'weight_init={}, bias_init={}'.format(self.in_channels,

  583.                                                   self.out_channels,

  584.                                                   self.kernel_size,

  585.                                                   self.stride,

  586.                                                   self.pad_mode,

  587.                                                   self.padding,

  588.                                                   self.dilation,

  589.                                                   self.group,

  590.                                                   self.has_bias,

  591.                                                   self.weight,

  592.                                                   self.bias)

  593.         return s

  594. 

  595. 

  596. class Conv1dTranspose(_Conv):

  597.     r"""

  598.     1D transposed convolution layer.

  599. 

  600.     Compute a 1D transposed convolution, which is also know as a deconvolution

  601.     (although it is not actual deconvolution).

  602. 

  603.     Input is typically of shape :math:`(N, C, W)`, where :math:`N` is batch size and :math:`C` is channel number.

  604. 

  605.     Args:

  606.         in_channels (int): The number of channels in the input space.

  607.         out_channels (int): The number of channels in the output space.

  608.         kernel_size (int): int, which specifies the width of the 1D convolution window.

  609.         stride (int): The distance of kernel moving, an int number that represents

  610.             the width of movement. Default: 1.

  611.         pad_mode (str): Select the mode of the pad. The optional values are

  612.             "pad", "same", "valid". Default: "same".

  613. 

  614.             - pad: Implicit paddings on both sides of the input.

  615. 

  616.             - same: Adopted the way of completion.

  617. 

  618.             - valid: Adopted the way of discarding.

  619.         padding (int): Implicit paddings on both sides of the input. Default: 0.

  620.         dilation (int): The data type is int. Specifies the dilation rate

  621.                                       to use for dilated convolution. If set to be :math:`k > 1`, there will

  622.                                       be :math:`k - 1` pixels skipped for each sampling location. Its value should

  623.                                       be greater or equal to 1 and bounded by the width of the

  624.                                       input. Default: 1.

  625.         group (int): Split filter into groups, `in_channels` and `out_channels` should be

  626.             divisible by the number of groups. This is not support for Davinci devices when group > 1. Default: 1.

  627.         has_bias (bool): Specifies whether the layer uses a bias vector. Default: False.

  628.         weight_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the convolution kernel.

  629.             It can be a Tensor, a string, an Initializer or a numbers.Number. When a string is specified,

  630.             values from 'TruncatedNormal', 'Normal', 'Uniform', 'HeUniform' and 'XavierUniform' distributions as well

  631.             as constant 'One' and 'Zero' distributions are possible. Alias 'xavier_uniform', 'he_uniform', 'ones'

  632.             and 'zeros' are acceptable. Uppercase and lowercase are both acceptable. Refer to the values of

  633.             Initializer for more details. Default: 'normal'.

  634.         bias_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the bias vector. Possible

  635.             Initializer and string are the same as 'weight_init'. Refer to the values of

  636.             Initializer for more details. Default: 'zeros'.

  637. 

  638.     Inputs:

  639.         - **input** (Tensor) - Tensor of shape :math:`(N, C_{in}, W_{in})`.

  640. 

  641.     Outputs:

  642.         Tensor of shape :math:`(N, C_{out}, W_{out})`.

  643. 

  644.     Examples:

  645.         >>> net = nn.Conv1dTranspose(3, 64, 4, has_bias=False, weight_init='normal')

  646.         >>> input = Tensor(np.ones([1, 3, 50]), mindspore.float32)

  647.         >>> net(input)

  648.     """

  649.     def __init__(self,

  650.                  in_channels,

  651.                  out_channels,

  652.                  kernel_size,

  653.                  stride=1,

  654.                  pad_mode='same',

  655.                  padding=0,

  656.                  dilation=1,

  657.                  group=1,

  658.                  has_bias=False,

  659.                  weight_init='normal',

  660.                  bias_init='zeros'):

  661.         Validator.check_value_type("kernel_size", kernel_size, [int], self.cls_name)

  662.         Validator.check_value_type("stride", stride, [int], self.cls_name)

  663.         Validator.check_value_type("padding", padding, [int], self.cls_name)

  664.         Validator.check_value_type("dilation", dilation, [int], self.cls_name)

  665.         Validator.check_integer('kernel_size', kernel_size, 1, Rel.GE, self.cls_name)

  666.         Validator.check_integer('stride', stride, 1, Rel.GE, self.cls_name)

  667.         Validator.check_integer('padding', padding, 0, Rel.GE, self.cls_name)

  668.         Validator.check_integer('dilation', dilation, 1, Rel.GE, self.cls_name)

  669.         kernel_size = (1, kernel_size)

  670.         stride = (1, stride)

  671.         dilation = (1, dilation)

  672.         # out_channels and in_channels swap.

  673.         # cause Conv2DBackpropInput's out_channel refers to Conv2D's out_channel,

  674.         # then Conv1dTranspose's out_channel refers to Conv2DBackpropInput's in_channel.

  675.         super(Conv1dTranspose, self).__init__(

  676.             in_channels,

  677.             out_channels,

  678.             kernel_size,

  679.             stride,

  680.             pad_mode,

  681.             padding,

  682.             dilation,

  683.             group,

  684.             has_bias,

  685.             weight_init,

  686.             bias_init,

  687.             transposed=True)

  688.         self.padding = (0, 0, padding, padding)

  689.         self.in_channels = in_channels

  690.         self.out_channels = out_channels

  691.         self.shape = P.Shape()

  692.         if pad_mode not in ('valid', 'same', 'pad'):

  693.             raise ValueError('Attr \'pad_mode\' of \'Conv1dTranspose\' Op passed '

  694.                              + str(pad_mode) + ', should be one of values in \'valid\', \'same\', \'pad\'.')

  695.         self.is_valid = self.pad_mode == 'valid'

  696.         self.is_same = self.pad_mode == 'same'

  697.         self.is_pad = self.pad_mode == 'pad'

  698.         if check_bool(has_bias):

  699.             self.bias = Parameter(initializer(bias_init, [out_channels]), name='bias')

  700. 

  701.         # cause Conv2DBackpropInput's out_channel refers to Conv2D's out_channel.

  702.         self.conv2d_transpose = P.Conv2DBackpropInput(out_channel=in_channels,

  703.                                                       kernel_size=kernel_size,

  704.                                                       mode=1,

  705.                                                       pad_mode=pad_mode,

  706.                                                       pad=self.padding,

  707.                                                       stride=stride,

  708.                                                       dilation=dilation,

  709.                                                       group=group)

  710.         self.bias_add = P.BiasAdd()

  711.         self.expand_dims = P.ExpandDims()

  712.         self.squeeze = P.Squeeze(2)

  713. 

  714.     def set_strategy(self, strategy):

  715.         self.conv2d_transpose.set_strategy(strategy)

  716.         return self

  717. 

  718.     def _deconv_output_length(self, input_length, filter_size, stride_size, dilation_size, padding):

  719.         """Calculate the width and height of output."""

  720.         length = 0

  721.         filter_size = filter_size + (filter_size - 1) * (dilation_size - 1)

  722.         if self.is_valid:

  723.             if filter_size - stride_size > 0:

  724.                 length = input_length * stride_size + filter_size - stride_size

  725.             else:

  726.                 length = input_length * stride_size

  727.         elif self.is_same:

  728.             length = input_length * stride_size

  729.         elif self.is_pad:

  730.             length = input_length * stride_size - padding + filter_size - stride_size

  731. 

  732.         return length

  733. 

  734.     def construct(self, x):

  735.         x_shape = self.shape(x)

  736.         if len(x_shape) == 3:

  737.             x = self.expand_dims(x, 2)

  738. 

  739.         n, _, h, w = self.shape(x)

  740. 

  741.         h_out = self._deconv_output_length(h, self.kernel_size[0], self.stride[0], self.dilation[0],

  742.                                            self.padding[0] + self.padding[1])

  743.         w_out = self._deconv_output_length(w, self.kernel_size[1], self.stride[1], self.dilation[1],

  744.                                            self.padding[2] + self.padding[3])

  745.         output = self.conv2d_transpose(x, self.weight, (n, self.out_channels, h_out, w_out))

  746.         if self.has_bias:

  747.             output = self.bias_add(output, self.bias)

  748. 

  749.         if len(x_shape) == 3:

  750.             output = self.squeeze(output)

  751.         return output

  752. 

  753.     def extend_repr(self):

  754.         s = 'input_channels={}, output_channels={}, kernel_size={},' \

  755.             'stride={},  pad_mode={}, padding={}, dilation={}, ' \

  756.             'group={}, has_bias={},' \

  757.             'weight_init={}, bias_init={}'.format(self.in_channels,

  758.                                                   self.out_channels,

  759.                                                   self.kernel_size,

  760.                                                   self.stride,

  761.                                                   self.pad_mode,

  762.                                                   self.padding,

  763.                                                   self.dilation,

  764.                                                   self.group,

  765.                                                   self.has_bias,

  766.                                                   self.weight,

  767.                                                   self.bias)

  768.         return s

  769. 

  770. 

  771. class DepthwiseConv2d(Cell):

  772.     r"""

  773.     2D depthwise convolution layer.

  774. 

  775.     Applies a 2D depthwise convolution over an input tensor which is typically of shape:

  776.     math:`(N, C_{in}, H_{in}, W_{in})`, where :math:`N` is batch size and :math:`C_{in}` is channel number.

  777.     For each batch of shape:math:`(C_{in}, H_{in}, W_{in})`, the formula is defined as:

  778. 

  779.     .. math::

  780. 

  781.         out_j = \sum_{i=0}^{C_{in} - 1} ccor(W_{ij}, X_i) + b_j,

  782. 

  783.     where :math:`ccor` is cross correlation operator, :math:`C_{in}` is the input channel number, :math:`j` ranges

  784.     from :math:`0` to :math:`C_{out} - 1`, :math:`W_{ij}` corresponds to :math:`i`-th channel of the :math:`j`-th

  785.     filter and :math:`out_{j}` corresponds to the :math:`j`-th channel of the output. :math:`W_{ij}` is a slice

  786.     of kernel and it has shape :math:`(\text{ks_h}, \text{ks_w})`, where :math:`\text{ks_h}` and

  787.     :math:`\text{ks_w}` are height and width of the convolution kernel. The full kernel has shape

  788.     :math:`(C_{out}, C_{in} // \text{group}, \text{ks_h}, \text{ks_w})`, where group is the group number

  789.     to split the input in the channel dimension.

  790. 

  791.     If the 'pad_mode' is set to be "valid", the output height and width will be

  792.     :math:`\left \lfloor{1 + \frac{H_{in} + 2 \times \text{padding} - \text{ks_h} -

  793.     (\text{ks_h} - 1) \times (\text{dilation} - 1) }{\text{stride}}} \right \rfloor` and

  794.     :math:`\left \lfloor{1 + \frac{W_{in} + 2 \times \text{padding} - \text{ks_w} -

  795.     (\text{ks_w} - 1) \times (\text{dilation} - 1) }{\text{stride}}} \right \rfloor` respectively.

  796. 

  797.     The first introduction can be found in paper `Gradient Based Learning Applied to Document Recognition

  798.     <http://vision.stanford.edu/cs598_spring07/papers/Lecun98.pdf>`_.

  799. 

  800.     Args:

  801.         in_channels (int): The number of input channel :math:`C_{in}`.

  802.         out_channels (int): The number of output channel :math:`C_{out}`.

  803.         kernel_size (Union[int, tuple[int]]): The data type is int or tuple with 2 integers. Specifies the height

  804.             and width of the 2D convolution window. Single int means the value if for both height and width of

  805.             the kernel. A tuple of 2 ints means the first value is for the height and the other is for the

  806.             width of the kernel.

  807.         stride (Union[int, tuple[int]]): The distance of kernel moving, an int number that represents

  808.             the height and width of movement are both strides, or a tuple of two int numbers that

  809.             represent height and width of movement respectively. Default: 1.

  810.         pad_mode (str): Specifies padding mode. The optional values are

  811.             "same", "valid", "pad". Default: "same".

  812. 

  813.             - same: Adopts the way of completion. Output height and width will be the same as the input.

  814.               Total number of padding will be calculated for horizontal and vertical

  815.               direction and evenly distributed to top and bottom, left and right if possible. Otherwise, the

  816.               last extra padding will be done from the bottom and the right side. If this mode is set, `padding`

  817.               must be 0.

  818. 

  819.             - valid: Adopts the way of discarding. The possibly largest height and width of output will be return

  820.               without padding. Extra pixels will be discarded. If this mode is set, `padding`

  821.               must be 0.

  822. 

  823.             - pad: Implicit paddings on both sides of the input. The number of `padding` will be padded to the input

  824.               Tensor borders. `padding` should be greater than or equal to 0.

  825. 

  826.         padding (int): Implicit paddings on both sides of the input. Default: 0.

  827.         dilation (Union[int, tuple[int]]): The data type is int or tuple with 2 integers. Specifies the dilation rate

  828.                                       to use for dilated convolution. If set to be :math:`k > 1`, there will

  829.                                       be :math:`k - 1` pixels skipped for each sampling location. Its value should

  830.                                       be greater or equal to 1 and bounded by the height and width of the

  831.                                       input. Default: 1.

  832.         group (int): Split filter into groups, `in_ channels` and `out_channels` should be

  833.             divisible by the number of groups. Default: 1.

  834.         has_bias (bool): Specifies whether the layer uses a bias vector. Default: False.

  835.         weight_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the convolution kernel.

  836.             It can be a Tensor, a string, an Initializer or a numbers.Number. When a string is specified,

  837.             values from 'TruncatedNormal', 'Normal', 'Uniform', 'HeUniform' and 'XavierUniform' distributions as well

  838.             as constant 'One' and 'Zero' distributions are possible. Alias 'xavier_uniform', 'he_uniform', 'ones'

  839.             and 'zeros' are acceptable. Uppercase and lowercase are both acceptable. Refer to the values of

  840.             Initializer for more details. Default: 'normal'.

  841.         bias_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the bias vector. Possible

  842.             Initializer and string are the same as 'weight_init'. Refer to the values of

  843.             Initializer for more details. Default: 'zeros'.

  844. 

  845.     Inputs:

  846.         - **input** (Tensor) - Tensor of shape :math:`(N, C_{in}, H_{in}, W_{in})`.

  847. 

  848.     Outputs:

  849.         Tensor of shape :math:`(N, C_{out}, H_{out}, W_{out})`.

  850. 

  851.     Examples:

  852.         >>> net = nn.DepthwiseConv2d(120, 240, 4, has_bias=False, weight_init='normal')

  853.         >>> input = Tensor(np.ones([1, 120, 1024, 640]), mindspore.float32)

  854.         >>> net(input).shape

  855.         (1, 240, 1024, 640)

  856.     """

  857.     def __init__(self,

  858.                  in_channels,

  859.                  out_channels,

  860.                  kernel_size,

  861.                  stride=1,

  862.                  pad_mode='same',

  863.                  padding=0,

  864.                  dilation=1,

  865.                  group=1,

  866.                  has_bias=False,

  867.                  weight_init='normal',

  868.                  bias_init='zeros'):

  869.         super(DepthwiseConv2d, self).__init__()

  870.         self.kernel_size = twice(kernel_size)

  871.         self.stride = twice(stride)

  872.         self.dilation = twice(dilation)

  873.         self.in_channels = check_int_positive(in_channels)

  874.         self.out_channels = check_int_positive(out_channels)

  875.         validator.check_integer('group', group, in_channels, Rel.EQ)

  876.         validator.check_integer('group', group, out_channels, Rel.EQ)

  877.         validator.check_integer('group', group, 1, Rel.GE)

  878.         self.pad_mode = pad_mode

  879.         self.padding = padding

  880.         self.dilation = dilation

  881.         self.group = group

  882.         self.has_bias = has_bias

  883.         self.conv = P.DepthwiseConv2dNative(channel_multiplier=1,

  884.                                             kernel_size=self.kernel_size,

  885.                                             pad_mode=self.pad_mode,

  886.                                             pad=self.padding,

  887.                                             stride=self.stride,

  888.                                             dilation=self.dilation)

  889.         self.bias_add = P.BiasAdd()

  890.         weight_shape = [1, in_channels, *self.kernel_size]

  891.         self.weight = Parameter(initializer(weight_init, weight_shape), name='weight')

  892.         if check_bool(has_bias):

  893.             self.bias = Parameter(initializer(bias_init, [out_channels]), name='bias')

  894.         else:

  895.             if bias_init != 'zeros':

  896.                 logger.warning("value of `has_bias` is False, value of `bias_init` will be ignore.")

  897.             self.bias = None

  898. 

  899.     def construct(self, x):

  900.         out = self.conv(x, self.weight)

  901.         if self.has_bias:

  902.             out = self.bias_add(out, self.bias)

  903.         return out

  904. 

  905.     def extend_repr(self):

  906.         s = 'input_channels={}, output_channels={}, kernel_size={}, stride={}, ' \

  907.             'pad_mode={}, padding={}, dilation={}, group={},' \

  908.             'has_bias={}, weight_init={}, bias_init={}'.format(

  909.                 self.in_channels, self.out_channels, self.kernel_size, self.stride,

  910.                 self.pad_mode, self.padding, self.dilation, self.group,

  911.                 self.has_bias, self.weight_init, self.bias_init)

  912. 

  913.         if self.has_bias:

  914.             s += ', bias={}'.format(self.bias)

  915.         return s