mindspore 1.10.0__cp37-cp37m-win_amd64.whl → 2.0.0rc1__cp37-cp37m-win_amd64.whl

mindspore/nn/layer/channel_shuffle.py

@@ -0,0 +1,103 @@
+# Copyright 2022 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""channel shuffle"""
+from mindspore.ops import operations as P
+from mindspore.nn.cell import Cell
+from mindspore.ops.primitive import _primexpr
+
+__all__ = ['ChannelShuffle']
+
+
+class ChannelShuffle(Cell):
+    r"""
+    Divide the channels of Tensor whose shape is :math:`(*, C, H, W)` into :math:`g` groups to obtain a Tensor with
+    shape :math:`(*, C \frac g, g, H, W)`, and transpose along the corresponding axis of :math:`C`,
+    :math:`\frac{g}{}` and :math:`g` to restore Tensor to the original shape.
+
+    Args:
+        groups (int): Number of groups to divide channels in, must be greater than 0. Refer to :math:`g`.
+
+    Inputs:
+        - **x** (Tensor) - Tensor of shape :math:`(*, C_{in}, H_{in}, W_{in})`.
+
+    Outputs:
+        Tensor, with the same type and shape as the `x`.
+
+    Raises:
+        TypeError: If `groups` is not an int.
+        ValueError: If `groups` is less than 1.
+        ValueError: If dims of `x` is less than 3.
+        ValueError: If number of channels can not be divisible by groups.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> channel_shuffle = nn.ChannelShuffle(2)
+        >>> x = Tensor(np.arange(16).astype(np.int32).reshape(1, 4, 2, 2))
+        >>> print(x)
+        [[[[0 1],
+           [2 3]],
+          [[4 5],
+           [6 7]],
+          [[8 9],
+           [10 11]],
+          [[12 13],
+           [14 15]],
+         ]]
+        >>> output = channel_shuffle(x)
+        >>> print(output)
+        [[[[0 1],
+           [2 3]],
+          [[8 9],
+           [10 11]],
+          [[4 5],
+           [6 7]],
+          [[12 13],
+           [14 15]],
+         ]]
+    """
+    def __init__(self, groups):
+        """Initialize ChannelShuffle."""
+        super(ChannelShuffle, self).__init__()
+        if not isinstance(groups, int):
+            raise TypeError("For ChannelShuffle, the param `groups` must be int, but got {}.".format(type(groups)))
+        if groups < 1:
+            raise ValueError(f"For ChannelShuffle, the param `groups` must be larger than 0, but got {groups}.")
+
+        self.groups = groups
+        self.shape = P.Shape()
+        self.reshape = P.Reshape()
+        self.transpose = P.Transpose()
+
+    @staticmethod
+    @_primexpr
+    def _check_input_dim(shape, channels, groups, cls_name):
+        """check input dim"""
+        dim = len(shape)
+        if dim < 3:
+            raise ValueError(f"For {cls_name}, the in_shape must have more than 2 dims, but got {dim}.")
+
+        if channels % groups != 0:
+            raise ValueError(f"For {cls_name}, number of channels must be divisible by groups, "
+                             f"but got {channels} channels and {groups} groups.")
+
+    def construct(self, x):
+        x_shape = self.shape(x)
+        n, c = x_shape[0], x_shape[1]
+        self._check_input_dim(x_shape, c, self.groups, self.cls_name)
+        out = self.reshape(x, (n, self.groups, c // self.groups, -1))
+        out = self.transpose(out, (0, 2, 1, 3))
+        return self.reshape(out, x_shape)

mindspore/nn/layer/combined.py

@@ -17,7 +17,7 @@ from __future__ import absolute_import
 
 from mindspore import nn
 from mindspore.ops.primitive import Primitive
-from mindspore._checkparam import Validator
+import mindspore._checkparam as Validator
 from mindspore.nn.layer.normalization import BatchNorm2d, BatchNorm1d
 from mindspore.nn.layer.activation import get_activation, LeakyReLU
 from mindspore.nn.cell import Cell

mindspore/nn/layer/container.py

@@ -109,7 +109,7 @@ class _CellListBase:
 class SequentialCell(Cell):
     """
     Sequential Cell container. For more details about Cell, please refer to
-    `Cell <https://www.mindspore.cn/docs/en/r1.10/api_python/nn/mindspore.nn.Cell.html#mindspore.nn.Cell>`_.
+    `Cell <https://www.mindspore.cn/docs/en/r2.0/api_python/nn/mindspore.nn.Cell.html#mindspore.nn.Cell>`_.
 
     A list of Cells will be added to it in the order they are passed in the constructor.
     Alternatively, an ordered dict of cells can also be passed in.
@@ -142,7 +142,7 @@ class SequentialCell(Cell):
         >>> conv = nn.Conv2d(3, 2, 3, pad_mode='valid', weight_init="ones")
         >>> relu = nn.ReLU()
         >>> seq = nn.SequentialCell([conv, relu])
-        >>> x = Tensor(np.ones([1, 3, 4, 4]), dtype=mindspore.float32)
+        >>> x = Tensor(np.ones([1, 3, 4, 4]), dtype = mindspore.float32)
         >>> output = seq(x)
         >>> print(output)
         [[[[27. 27.]
@@ -168,7 +168,12 @@ class SequentialCell(Cell):
         self._is_dynamic_name = []
         if len(args) == 1:
             cells = args[0]
-            if isinstance(cells, list):
+            if isinstance(cells, Cell):
+                cell = cells
+                self.insert_child_to_cell(str(0), cell)
+                cell.update_parameters_name(str(0) + ".")
+                self._is_dynamic_name.append(True)
+            elif isinstance(cells, list):
                 for index, cell in enumerate(cells):
                     self.insert_child_to_cell(str(index), cell)
                     cell.update_parameters_name(str(index) + ".")
@@ -179,7 +184,7 @@ class SequentialCell(Cell):
                     cell.update_parameters_name(name + ".")
                     self._is_dynamic_name.append(False)
             else:
-                raise TypeError(f"For '{self.__class__.__name__}', the 'args[0]' must be list or orderedDict, "
+                raise TypeError(f"For '{self.__class__.__name__}', the 'args[0]' must be Cell, list or orderedDict, "
                                 f"but got {type(cells).__name__}")
         else:
             for index, cell in enumerate(args):
@@ -233,6 +238,9 @@ class SequentialCell(Cell):
         self._cells = temp_dict
         self.cell_list = list(self._cells.values())
 
+    def __bool__(self):
+        return len(self._cells) != 0
+
     def __len__(self):
         return len(self._cells)
 
@@ -279,13 +287,40 @@ class SequentialCell(Cell):
             input_data = cell(input_data)
         return input_data
 
+    def _insert(self, index, cell):
+        """
+        Inserts a given Cell before a given index in the list.
+
+        Args:
+            index(int): The Insert index in the CellList.
+            cell(Cell): The Cell to be inserted.
+        """
+        cls_name = self.__class__.__name__
+        idx = _valid_index(len(self), index, cls_name)
+        _valid_cell(cell, cls_name)
+        length = len(self)
+        prefix, key_index = _get_prefix_and_index(self._cells)
+        while length > idx:
+            if self._auto_prefix:
+                tmp_cell = self._cells[str(length-1)]
+                for _, param in tmp_cell.parameters_and_names():
+                    param.name = f'{prefix}{str(length)}{"."}{".".join(param.name.split(".")[key_index+1:])}'
+            self._cells[str(length)] = self._cells[str(length - 1)]
+            length -= 1
+        self._cells[str(idx)] = cell
+        if self._auto_prefix:
+            cell.update_parameters_name(prefix + str(idx) + ".")
+        self.cell_list = list(self._cells.values())
+        self._is_dynamic_name.insert(index, True)
+
 
 class CellList(_CellListBase, Cell):
     """
     Holds Cells in a list. For more details about Cell, please refer to
-    `Cell <https://www.mindspore.cn/docs/en/r1.10/api_python/nn/mindspore.nn.Cell.html#mindspore.nn.Cell>`_.
+    `Cell <https://www.mindspore.cn/docs/en/r2.0/api_python/nn/mindspore.nn.Cell.html#mindspore.nn.Cell>`_.
 
-    CellList can be used like a regular Python list, the Cells it contains have been initialized.
+    CellList can be used like a regular Python list, the Cells it contains have been initialized. Unlike the
+    SequentialCell, the cells in CellList are not connected.
 
     Args:
         args (list, optional): List of subclass of Cell.
@@ -295,6 +330,8 @@ class CellList(_CellListBase, Cell):
 
     Examples:
         >>> import mindspore.nn as nn
+        >>> import mindspore as ms
+        >>> import numpy as np
         >>>
         >>> conv = nn.Conv2d(100, 20, 3)
         >>> bn = nn.BatchNorm2d(20)
@@ -303,6 +340,12 @@ class CellList(_CellListBase, Cell):
         >>> cell_ls.insert(0, conv)
         >>> cell_ls.append(relu)
         >>> cell_ls.extend([relu, relu])
+        >>> cell_ls_3 = cell_ls[3]
+        >>> input1 = ms.Tensor(np.ones([2, 3]), ms.float32)
+        >>> output = cell_ls_3(input1)
+        >>> print(output)
+        [[1. 1. 1.]
+        [1. 1. 1.]]
     """
     def __init__(self, *args, **kwargs):
         """Initialize CellList."""
@@ -355,6 +398,9 @@ class CellList(_CellListBase, Cell):
             temp_dict[str(idx)] = cell
         self._cells = temp_dict
 
+    def __bool__(self):
+        return len(self._cells) != 0
+
     def __len__(self):
         return len(self._cells)
 

mindspore/nn/layer/conv.py

@@ -20,11 +20,12 @@ import numpy as np
 from mindspore import log as logger
 from mindspore import context
 from mindspore.ops import operations as P
-from mindspore.ops.primitive import constexpr
+from mindspore.ops.primitive import _primexpr
 from mindspore.common.parameter import Parameter
 from mindspore.common.initializer import initializer
 from mindspore.common.tensor import Tensor
-from mindspore._checkparam import Validator, Rel, twice, _check_3d_int_or_tuple
+from mindspore import _checkparam as Validator
+from mindspore._checkparam import twice, _check_3d_int_or_tuple
 from mindspore._extends import cell_attr_register
 from mindspore.nn.cell import Cell
 
@@ -93,8 +94,8 @@ class _Conv(Cell):
         if transposed:
             shape = [in_channels, out_channels // group, *kernel_size]
         else:
-            shape = [out_channels, *kernel_size, in_channels // group] \
-                if self.data_format == "NHWC" else [out_channels, in_channels // group, *kernel_size]
+            shape = [out_channels, *kernel_size, in_channels // group] if self.data_format == "NHWC" else \
+                [out_channels, in_channels // group, *kernel_size]
         self.weight = Parameter(initializer(self.weight_init, shape), name='weight')
 
         if Validator.check_bool(has_bias, "has_bias", self.cls_name):
@@ -142,7 +143,7 @@ class Conv2d(_Conv):
         \sum_{k = 0}^{C_{in} - 1} \text{ccor}({\text{weight}(C_{\text{out}_j}, k), \text{X}(N_i, k)})
 
     where :math:`ccor` is the `cross-correlation <https://en.wikipedia.org/wiki/Cross-correlation>`_,
-    :math:`C_{in}` is the channel number of the input, :math:`out_{j}` corresponds to the jth channel of
+    :math:`C_{in}` is the channel number of the input, :math:`out_{j}` corresponds to the :math:`j`-th channel of
     the output and :math:`j` is in the range of :math:`[0, C_{out}-1]`. :math:`\text{weight}(C_{\text{out}_j}, k)`
     is a convolution kernel slice with shape :math:`(\text{kernel_size[0]}, \text{kernel_size[1]})`,
     where :math:`\text{kernel_size[0]}` and :math:`\text{kernel_size[1]}` are the height and width of the convolution
@@ -156,6 +157,10 @@ class Conv2d(_Conv):
     For more details, please refers to the paper `Gradient Based Learning Applied to Document
     Recognition <http://vision.stanford.edu/cs598_spring07/papers/Lecun98.pdf>`_.
 
+    Note:
+        On Ascend platform, only group convolution in depthwise convolution scenarios is supported.
+        That is, when `group>1`, condition `in\_channels` = `out\_channels` = `group` must be satisfied.
+
     Args:
         in_channels (int): The channel number of the input tensor of the Conv2d layer.
         out_channels (int): The channel number of the output tensor of the Conv2d layer.
@@ -216,17 +221,17 @@ class Conv2d(_Conv):
 
         .. math::
             \begin{array}{ll} \\
-                H_{out} ＝ \left \lceil{\frac{H_{in}}{\text{stride[0]}}} \right \rceil \\
-                W_{out} ＝ \left \lceil{\frac{W_{in}}{\text{stride[1]}}} \right \rceil \\
+                H_{out} = \left \lceil{\frac{H_{in}}{\text{stride[0]}}} \right \rceil \\
+                W_{out} = \left \lceil{\frac{W_{in}}{\text{stride[1]}}} \right \rceil \\
             \end{array}
 
         pad_mode is 'valid':
 
         .. math::
             \begin{array}{ll} \\
-                H_{out} ＝ \left \lceil{\frac{H_{in} - \text{dilation[0]} \times (\text{kernel_size[0]} - 1) }
+                H_{out} = \left \lceil{\frac{H_{in} - \text{dilation[0]} \times (\text{kernel_size[0]} - 1) }
                 {\text{stride[0]}}} \right \rceil \\
-                W_{out} ＝ \left \lceil{\frac{W_{in} - \text{dilation[1]} \times (\text{kernel_size[1]} - 1) }
+                W_{out} = \left \lceil{\frac{W_{in} - \text{dilation[1]} \times (\text{kernel_size[1]} - 1) }
                 {\text{stride[1]}}} \right \rceil \\
             \end{array}
 
@@ -234,9 +239,9 @@ class Conv2d(_Conv):
 
         .. math::
             \begin{array}{ll} \\
-                H_{out} ＝ \left \lfloor{\frac{H_{in} + padding[0] + padding[1] - (\text{kernel_size[0]} - 1) \times
+                H_{out} = \left \lfloor{\frac{H_{in} + padding[0] + padding[1] - (\text{kernel_size[0]} - 1) \times
                 \text{dilation[0]} - 1 }{\text{stride[0]}} + 1} \right \rfloor \\
-                W_{out} ＝ \left \lfloor{\frac{W_{in} + padding[2] + padding[3] - (\text{kernel_size[1]} - 1) \times
+                W_{out} = \left \lfloor{\frac{W_{in} + padding[2] + padding[3] - (\text{kernel_size[1]} - 1) \times
                 \text{dilation[1]} - 1 }{\text{stride[1]}} + 1} \right \rfloor \\
             \end{array}
 
@@ -311,7 +316,7 @@ class Conv2d(_Conv):
         return output
 
 
-@constexpr
+@_primexpr
 def _check_input_3d(input_shape, op_name):
     if len(input_shape) != 3:
         raise ValueError(f"For '{op_name}', the dimension of input must be 3d, but got {len(input_shape)}.")
@@ -329,7 +334,7 @@ class Conv1d(_Conv):
         \sum_{k = 0}^{C_{in} - 1} \text{ccor}({\text{weight}(C_{\text{out}_j}, k), \text{X}(N_i, k)})
 
     where :math:`ccor` is the `cross-correlation <https://en.wikipedia.org/wiki/Cross-correlation>`_,
-    :math:`C_{in}` is the channel number of the input, :math:`out_{j}` corresponds to the jth channel of
+    :math:`C_{in}` is the channel number of the input, :math:`out_{j}` corresponds to the :math:`j`-th channel of
     the output and :math:`j` is in the range of :math:`[0, C_{out}-1]`. :math:`\text{weight}(C_{\text{out}_j}, k)`
     is a convolution kernel slice with shape :math:`\text{kernel_size}`, where :math:`\text{kernel_size}`
     is the width of the convolution kernel. :math:`\text{bias}` is the bias parameter,
@@ -340,6 +345,10 @@ class Conv1d(_Conv):
     For more details, please refers to the paper `Gradient Based Learning Applied to Document
     Recognition <http://vision.stanford.edu/cs598_spring07/papers/Lecun98.pdf>`_.
 
+    Note:
+        On Ascend platform, only group convolution in depthwise convolution scenarios is supported.
+        That is, when `group>1`, condition `in\_channels` = `out\_channels` = `group` must be satisfied.
+
     Args:
         in_channels (int): The channel number of the input tensor of the Conv1d layer.
         out_channels (int): The channel number of the output tensor of the Conv1d layer.
@@ -432,10 +441,10 @@ class Conv1d(_Conv):
         Validator.check_value_type("stride", stride, [int], self.cls_name)
         Validator.check_value_type("padding", padding, [int], self.cls_name)
         Validator.check_value_type("dilation", dilation, [int], self.cls_name)
-        Validator.check_int(kernel_size, 1, Rel.GE, 'kernel_size', self.cls_name)
-        Validator.check_int(stride, 1, Rel.GE, 'stride', self.cls_name)
+        Validator.check_int(kernel_size, 1, Validator.GE, 'kernel_size', self.cls_name)
+        Validator.check_int(stride, 1, Validator.GE, 'stride', self.cls_name)
         Validator.check_non_negative_int(padding, 'padding', self.cls_name)
-        Validator.check_int(dilation, 1, Rel.GE, 'dilation', self.cls_name)
+        Validator.check_int(dilation, 1, Validator.GE, 'dilation', self.cls_name)
         kernel_size = (1, kernel_size)
         stride = (1, stride)
         dilation = (1, dilation)
@@ -488,7 +497,7 @@ class Conv1d(_Conv):
         return output
 
 
-@constexpr
+@_primexpr
 def _check_input_5dims(input_shape, op_name):
     if len(input_shape) != 5:
         raise ValueError(f"For '{op_name}', the dimension of input must be 5d, but got {len(input_shape)}.")
@@ -508,8 +517,8 @@ class Conv3d(_Conv):
         \sum_{k = 0}^{C_{in} - 1} \text{ccor}({\text{weight}(C_{\text{out}_j}, k), \text{X}(N_i, k)})
 
     where :math:`ccor` is the `cross-correlation <https://en.wikipedia.org/wiki/Cross-correlation>`_,
-    :math:`C_{in}` is the channel number of the input, :math:`out_{j}` corresponds to the jth channel of
-    the output and :math:`j` is in the range of :math:`[0，C_{out}-1]`. :math:`\text{weight}(C_{\text{out}_j}, k)`
+    :math:`C_{in}` is the channel number of the input, :math:`out_{j}` corresponds to the :math:`j`-th channel of
+    the output and :math:`j` is in the range of :math:`[0, C_{out}-1]`. :math:`\text{weight}(C_{\text{out}_j}, k)`
     is a convolution kernel slice with shape
     :math:`(\text{kernel_size[0]}, \text{kernel_size[1]}, \text{kernel_size[2]})`,
     where :math:`\text{kernel_size[0]}`, :math:`\text{kernel_size[1]}` and :math:`\text{kernel_size[2]}` are
@@ -522,6 +531,10 @@ class Conv3d(_Conv):
     For more details, please refers to the paper `Gradient Based Learning Applied to Document
     Recognition <http://vision.stanford.edu/cs598_spring07/papers/Lecun98.pdf>`_.
 
+    Note:
+        On Ascend platform, only group convolution in depthwise convolution scenarios is supported.
+        That is, when `group>1`, condition `in\_channels` = `out\_channels` = `group` must be satisfied.
+
     Args:
         in_channels (int): The channel number of the input tensor of the Conv3d layer.
         out_channels (int): The channel number of the output tensor of the Conv3d layer.
@@ -580,9 +593,9 @@ class Conv3d(_Conv):
 
         .. math::
             \begin{array}{ll} \\
-                D_{out} ＝ \left \lfloor{\frac{D_{in}}{\text{stride[0]}} + 1} \right \rfloor \\
-                H_{out} ＝ \left \lfloor{\frac{H_{in}}{\text{stride[1]}} + 1} \right \rfloor \\
-                W_{out} ＝ \left \lfloor{\frac{W_{in}}{\text{stride[2]}} + 1} \right \rfloor \\
+                D_{out} ＝ \left \lceil{\frac{D_{in}}{\text{stride[0]}}} \right \rceil \\
+                H_{out} ＝ \left \lceil{\frac{H_{in}}{\text{stride[1]}}} \right \rceil \\
+                W_{out} ＝ \left \lceil{\frac{W_{in}}{\text{stride[2]}}} \right \rceil \\
             \end{array}
 
 
@@ -646,6 +659,10 @@ class Conv3d(_Conv):
                  bias_init='zeros',
                  data_format='NCDHW'):
         """Initialize Conv3d."""
+        if not in_channels % group == 0 and out_channels % group == 0:
+            raise ValueError("The argument 'group' should be divisible by 'in_channels' " \
+                             "and 'out_channels'")
+
         kernel_size = _check_3d_int_or_tuple("kernel_size", kernel_size, self.cls_name)
         stride = _check_3d_int_or_tuple("stride", stride, self.cls_name)
         dilation = _check_3d_int_or_tuple("dilation", dilation, self.cls_name)
@@ -665,25 +682,42 @@ class Conv3d(_Conv):
             weight_init,
             bias_init,
             data_format)
-        self.conv3d = P.Conv3D(out_channel=self.out_channels,
+        out_channels = self.out_channels // group
+        self.conv3d = P.Conv3D(out_channel=out_channels,
                                kernel_size=self.kernel_size,
                                mode=1,
                                pad_mode=self.pad_mode,
                                pad=self.padding,
                                stride=self.stride,
                                dilation=self.dilation,
-                               group=self.group,
+                               group=1,
                                data_format=self.data_format)
         self.bias_add = P.BiasAdd(data_format=self.data_format)
         self.shape = P.Shape()
+        self.concat = P.Concat(1)
+        self.split_0 = P.Split(0, self.group)
+        self.split_1 = P.Split(1, self.group)
 
     def construct(self, x):
         x_shape = self.shape(x)
         _check_input_5dims(x_shape, self.cls_name)
-        output = self.conv3d(x, self.weight)
-        if self.has_bias:
-            output = self.bias_add(output, self.bias)
-        return output
+        if self.group == 1:
+            out = self.conv3d(x, self.weight)
+            if self.has_bias:
+                out = self.bias_add(out, self.bias)
+        else:
+            features = self.split_1(x)
+            weights = self.split_0(self.weight)
+            outputs = ()
+            for i in range(self.group):
+                output = self.conv3d(features[i], weights[i])
+                outputs = outputs + (output,)
+            out = self.concat(outputs)
+            if self.bias is not None:
+                new_shape = [1 for _ in range(out.ndim)]
+                new_shape[1] = self.out_channels
+                out = out + self.bias.reshape(new_shape)
+        return out
 
 
 class Conv3dTranspose(_Conv):
@@ -691,7 +725,8 @@ class Conv3dTranspose(_Conv):
     Calculates a 3D transposed convolution, which can be regarded as Conv3d for the gradient of the input.
     It also called deconvolution (although it is not an actual deconvolution).
 
-    The input is typically of shape :math:`(N, C, D, H, W)`, where :math:`N` is batch size, :math:`C` is a number of
+    he input is typically of shape :math:`(N, C_{in}, D_{in}, H_{in}, W_{in})`,
+    where :math:`N` is batch size, :math:`C_{in}` is a number of
     channels, :math:`D_{in}, H_{in}, W_{in}` are the depth, height and width of the feature layer respectively.
 
     When Conv3d and Conv3dTranspose are initialized with the same parameters, and `pad_mode` is set to 'pad',
@@ -940,6 +975,12 @@ class Conv2dTranspose(_Conv):
             If `padding` is a tuple of 4 integers, then the top, bottom, left, and right padding
             is equal to `padding[0]`, `padding[1]`, `padding[2]`, and `padding[3]` respectively.
             The value should be greater than or equal to 0. Default: 0.
+        output_padding (Union[int, tuple[int]]): The number of padding on the height and width directions of the output.
+            The data type is an integer or a tuple of two integers. If `output_padding` is an integer,
+            then the bottom and right padding are all equal to `output_padding`. If `output_padding` is a tuple of
+            2 integers, then the bottom and right padding is equal to `output_padding[0]`, `output_padding[1]`
+            respectively. If `output_padding` is not equal to 0, `pad_mode` must be `pad`.
+            The value should be in range of `[0, max(stride, dilation))` . Default: 0.
         dilation (Union[int, tuple[int]]): Dilation size of 2D convolution kernel.
             The data type is an integer or a tuple of two integers. If :math:`k > 1`, the kernel is sampled
             every `k` elements. The value of `k` on the height and width directions is in range of [1, H]
@@ -985,12 +1026,12 @@ class Conv2dTranspose(_Conv):
 
         .. math::
             \begin{array}{ll} \\
-                H_{out} = \text H_{in}\times \text {stride[0]} - (padding[0] + padding[1]) +
-                \text{kernel_size[0]} + (\text{dilation[0]} - 1) \times
-                (\text{kernel_size[0]} - 1) - \text {stride[0]} \\
-                W_{out} = \text W_{in}\times \text {stride[1]} - (padding[2] + padding[3]) +
-                \text{kernel_size[1]} + (\text{dilation[1]} - 1) \times
-                (\text{kernel_size[1]} - 1) - \text {stride[1]} \\
+                H_{out} = \text H_{in}\times \text {stride[0]} - (padding[0] + padding[1])
+                + \text{kernel_size[0]} + (\text{dilation[0]} - 1) \times
+                (\text{kernel_size[0]} - 1) - \text {stride[0]} + \text {output_padding[0]} \\
+                W_{out} = \text W_{in}\times \text {stride[1]} - (padding[2] + padding[3])
+                + \text{kernel_size[1]} + (\text{dilation[1]} - 1) \times
+                (\text{kernel_size[1]} - 1) - \text {stride[1]} + \text {output_padding[1]} \\
             \end{array}
 
     Raises:
@@ -1020,6 +1061,7 @@ class Conv2dTranspose(_Conv):
                  stride=1,
                  pad_mode='same',
                  padding=0,
+                 output_padding=0,
                  dilation=1,
                  group=1,
                  has_bias=False,
@@ -1032,6 +1074,9 @@ class Conv2dTranspose(_Conv):
         Validator.check_value_type('padding', padding, (int, tuple), self.cls_name)
         if isinstance(padding, tuple):
             Validator.check_equal_int(len(padding), 4, 'padding size', self.cls_name)
+        Validator.check_value_type('output_padding', output_padding, (int, tuple), self.cls_name)
+        if isinstance(output_padding, tuple):
+            Validator.check_equal_int(len(output_padding), 2, 'output_padding size', self.cls_name)
         # out_channels and in_channels swap.
         # cause Conv2DBackpropInput's out_channel refers to Conv2D's out_channel,
         # then Conv2dTranspose's out_channel refers to Conv2DBackpropInput's in_channel.
@@ -1056,6 +1101,7 @@ class Conv2dTranspose(_Conv):
         self.is_valid = self.pad_mode == 'valid'
         self.is_same = self.pad_mode == 'same'
         self.is_pad = self.pad_mode == 'pad'
+        self.output_padding = output_padding
         if Validator.check_bool(has_bias, "has_bias", self.cls_name):
             self.bias = Parameter(initializer(bias_init, [out_channels]), name='bias')
 
@@ -1087,7 +1133,29 @@ class Conv2dTranspose(_Conv):
         if self.has_bias:
             return self.bias_add(self.conv2d_transpose(x, self.weight, (n, self.out_channels, h_out, w_out)),
                                  self.bias)
-        return self.conv2d_transpose(x, self.weight, (n, self.out_channels, h_out, w_out))
+        conv2d_trans_ret = self.conv2d_transpose(x, self.weight, (n, self.out_channels, h_out, w_out))
+        if isinstance(self.output_padding, tuple):
+            if self.output_padding[0] < 0 or self.output_padding[0] >= max(self.dilation[0], self.stride[0]):
+                raise ValueError("output_padding[0] must be in range of [0, max(stride_h, dilation_h)).")
+            if self.output_padding[1] < 0 or self.output_padding[1] >= max(self.dilation[1], self.stride[1]):
+                raise ValueError("output_padding[1] must be in range of [0, max(stride_w, dilation_w)).")
+            if not self.is_pad and (self.output_padding[0] > 0 or self.output_padding[1] > 0):
+                raise ValueError("when output_padding is not zero, pad_mode must be 'pad'")
+
+            pad = P.Pad(paddings=((0, 0), (0, 0), (0, self.output_padding[0]), (0, self.output_padding[1])))
+            return pad(conv2d_trans_ret)
+
+        if self.output_padding == 0:
+            return conv2d_trans_ret
+
+        if self.output_padding < 0 or self.output_padding >= max(self.dilation[0], self.stride[0]):
+            raise ValueError("output_padding must be in range of [0, max(stride_h, dilation_h)).")
+        if self.output_padding < 0 or self.output_padding >= max(self.dilation[1], self.stride[1]):
+            raise ValueError("output_padding must be in range of [0, max(stride_w, dilation_w)).")
+        if not self.is_pad and self.output_padding > 0:
+            raise ValueError("when output_padding is not zero, pad_mode must be 'pad'")
+        pad = P.Pad(paddings=((0, 0), (0, 0), (0, self.output_padding), (0, self.output_padding)))
+        return pad(conv2d_trans_ret)
 
 
 class Conv1dTranspose(_Conv):
@@ -1095,7 +1163,8 @@ class Conv1dTranspose(_Conv):
     Calculates a 1D transposed convolution, which can be regarded as Conv1d for the gradient of the input,
     also called deconvolution (although it is not an actual deconvolution).
 
-    The input is typically of shape :math:`(N, C, L)`, where :math:`N` is batch size, :math:`C` is a number of channels
+    The input is typically of shape :math:`(N, C_{in}, L_{in})`, where :math:`N` is batch size,
+    :math:`C` is a number of channels
     and :math:`L_{in}` is a length of sequence.
 
     When Conv1d and ConvTranspose1d are initialized with the same parameters, and `pad_mode` is set to 'pad',
@@ -1147,18 +1216,18 @@ class Conv1dTranspose(_Conv):
         pad_mode is 'same':
 
         .. math::
-            L_{out} ＝ \left \lfloor{\frac{L_{in}}{\text{stride}} + 1} \right \rfloor
+            L_{out} = \left \lfloor{\frac{L_{in}}{\text{stride}} + 1} \right \rfloor
 
         pad_mode is 'valid':
 
         .. math::
-            L_{out} ＝ \left \lfloor{\frac{L_{in} - \text{dilation} \times (\text{kernel_size} - 1) }
+            L_{out} = \left \lfloor{\frac{L_{in} - \text{dilation} \times (\text{kernel_size} - 1) }
             {\text{stride}} + 1} \right \rfloor
 
         pad_mode is 'pad':
 
         .. math::
-            L_{out} ＝ \left \lfloor{\frac{L_{in} + 2 \times padding - (\text{dilation} - 1) \times
+            L_{out} = \left \lfloor{\frac{L_{in} + 2 \times padding - (\text{dilation} - 1) \times
             \text{kernel_size} - 1 }{\text{stride}} + 1} \right \rfloor
 
     Raises:
@@ -1195,10 +1264,10 @@ class Conv1dTranspose(_Conv):
         Validator.check_value_type("stride", stride, [int], self.cls_name)
         Validator.check_value_type("padding", padding, [int], self.cls_name)
         Validator.check_value_type("dilation", dilation, [int], self.cls_name)
-        Validator.check_int(kernel_size, 1, Rel.GE, 'kernel_size', self.cls_name)
-        Validator.check_int(stride, 1, Rel.GE, 'stride', self.cls_name)
+        Validator.check_int(kernel_size, 1, Validator.GE, 'kernel_size', self.cls_name)
+        Validator.check_int(stride, 1, Validator.GE, 'stride', self.cls_name)
         Validator.check_non_negative_int(padding, 'padding', self.cls_name)
-        Validator.check_int(dilation, 1, Rel.GE, 'dilation', self.cls_name)
+        Validator.check_int(dilation, 1, Validator.GE, 'dilation', self.cls_name)
         kernel_size = (1, kernel_size)
         stride = (1, stride)
         dilation = (1, dilation)

mindspore/nn/layer/dense.py

@@ -23,14 +23,14 @@ import mindspore.common.dtype as mstype
 from mindspore.common.tensor import Tensor
 from mindspore.common.initializer import initializer, Uniform
 from mindspore.common.parameter import Parameter
-from mindspore.ops.primitive import constexpr
-from mindspore._checkparam import Validator
+from mindspore.ops.primitive import constexpr, _primexpr
+from mindspore import _checkparam as Validator
 from mindspore.nn.cell import Cell
 
 __all__ = ['BiDense']
 
 
-@constexpr
+@_primexpr
 def check_dense_inputs_same_shape(input1, input2, prim_name=None):
     msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
     if input1[:-1] != input2[:-1]:
@@ -38,7 +38,7 @@ def check_dense_inputs_same_shape(input1, input2, prim_name=None):
                          f"{input1} of 'input1' and {input2} of 'input2'")
 
 
-@constexpr
+@constexpr(check=False)
 def _check_is_tensor(param_name, input_data, cls_name):
     """Internal function, used to check whether the input data is Tensor."""
     if input_data is not None and not isinstance(P.typeof(input_data), mstype.tensor_type):
@@ -46,7 +46,7 @@ def _check_is_tensor(param_name, input_data, cls_name):
                         f"but got '{P.typeof(input_data)}'")
 
 
-@constexpr
+@_primexpr
 def check_last_dimension(input_dim, input_channels, input_name, input_channels_name, prim_name=None):
     msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
     if input_dim != input_channels:
@@ -63,7 +63,7 @@ class BiDense(Cell):
     .. math::
         y = x_1^T A x_2 + b,
 
-    where :math:`x_1` is the first input tensor, :math:`x_2` is the second input tensor
+    where :math:`x_{1}` is the first input tensor, :math:`x_{2}` is the second input tensor
     , :math:`A` is a weight matrix with the same data type as the :math:`x_{*}` created by the layer
     , and :math:`b` is a bias vector with the same data type as the :math:`x_{*}` created by the layer
     (only if has_bias is True).
@@ -76,7 +76,7 @@ class BiDense(Cell):
             The values of str refer to the function `initializer`. Default: None.
         bias_init (Union[Tensor, str, Initializer, numbers.Number]): The trainable bias_init parameter.
             The values of str refer to the function `initializer`. Default: None.
-        has_bias (bool): Specifies whether the layer uses a bias vector. Default: True.
+        has_bias (bool): Specifies whether the layer uses :math:`\text{bias}` vector. Default: True.
 
     Shape:
         - **input1** - :math:`(*, H_{in1})` where :math:`H_{in1}=\text{in1_channels}` and
@@ -85,8 +85,9 @@ class BiDense(Cell):
         - **input2** - :math:`(*, H_{in2})` where :math:`H_{in2}=\text{in2_channels}` and
           :math:`*` means any number of additional dimensions including none. All but the last dimension
           of the inputs should be the same.
-        - **output** - :math:`(*, H_{out})` where :math:`H_{out}=\text{out_channels}`
-          and all but the last dimension are the same shape as the inputs.
+        - **output** - :math:`(*, H_{out})` where :math:`H_{out}=\text{out_channels}` and
+          :math:`*` means any number of additional dimensions including none. All but the last dimension
+          are the same shape as the inputs.
 
     Dtype:
         - **input1** (Tensor) - The dtype must be float16 or float32 and be same as **input2**.