mindspore 2.0.0rc1__cp38-none-any.whl → 2.2.0__cp38-none-any.whl

mindspore/nn/layer/conv.py

@@ -15,14 +15,15 @@
 """conv"""
 from __future__ import absolute_import
 
+import math
 import numpy as np
 
-from mindspore import log as logger
 from mindspore import context
 from mindspore.ops import operations as P
+import mindspore.common.dtype as mstype
 from mindspore.ops.primitive import _primexpr
 from mindspore.common.parameter import Parameter
-from mindspore.common.initializer import initializer
+from mindspore.common.initializer import initializer, HeUniform, Uniform, _calculate_fan_in_and_fan_out
 from mindspore.common.tensor import Tensor
 from mindspore import _checkparam as Validator
 from mindspore._checkparam import twice, _check_3d_int_or_tuple
@@ -50,7 +51,8 @@ class _Conv(Cell):
                  weight_init,
                  bias_init,
                  data_format='NCHW',
-                 transposed=False):
+                 transposed=False,
+                 dtype=mstype.float32):
         """Initialize _Conv."""
         super(_Conv, self).__init__()
         self.in_channels = Validator.check_positive_int(in_channels, 'in_channels', self.cls_name)
@@ -58,8 +60,6 @@ class _Conv(Cell):
         self.kernel_size = kernel_size
         self.stride = stride
         self.pad_mode = pad_mode
-        self.weight_init = weight_init
-        self.bias_init = bias_init
         self.data_format = Validator.check_string(data_format, ['NCHW', 'NHWC', 'NCDHW'], 'format', self.cls_name)
         if context.get_context("device_target") != "GPU" and self.data_format == "NHWC":
             raise ValueError(f"For '{self.cls_name}', the \"NHWC\" format only support in GPU target, "
@@ -96,13 +96,23 @@ class _Conv(Cell):
         else:
             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 weight_init is None:
+            weight_init = HeUniform(math.sqrt(5))
+        self.weight_init = weight_init
+        self.weight = Parameter(initializer(self.weight_init, shape, dtype=dtype), name='weight')
 
+        self.bias_init = bias_init
         if Validator.check_bool(has_bias, "has_bias", self.cls_name):
-            self.bias = Parameter(initializer(self.bias_init, [out_channels]), name='bias')
+            if bias_init is None:
+                fan_in, _ = _calculate_fan_in_and_fan_out(shape)
+                if fan_in != 0:
+                    bound = 1 / math.sqrt(fan_in)
+                    bias_init = Uniform(bound)
+                else:
+                    bias_init = 'zeros'
+                self.bias_init = bias_init
+            self.bias = Parameter(initializer(self.bias_init, [out_channels], dtype=dtype), name='bias')
         else:
-            if self.bias_init != 'zeros':
-                logger.warning("Value of 'has_bias' is False, value of 'bias_init' will be ignored.")
             self.bias = None
 
     def construct(self, *inputs):
@@ -131,31 +141,44 @@ class _Conv(Cell):
 
 class Conv2d(_Conv):
     r"""
-    Calculates the 2D convolution on the input tensor.
-    The input is typically of shape :math:`(N, C_{in}, H_{in}, W_{in})`,
-    where :math:`N` is batch size, :math:`C_{in}` is a number of channels,
-    :math:`H_{in}, W_{in}` are the height and width of the feature layer respectively.
-    For the tensor of each batch, its shape is :math:`(C_{in}, H_{in}, W_{in})`, the formula is defined as:
+    2D convolution layer.
+
+    Applies a 2D convolution over an input tensor which is typically of shape :math:`(N, C_{in}, H_{in}, W_{in})`,
+    where :math:`N` is batch size, :math:`C` is channel number, :math:`H` is feature height, :math:`W` is feature width.
+
+    The output is calculated based on formula:
 
     .. math::
 
         \text{out}(N_i, C_{\text{out}_j}) = \text{bias}(C_{\text{out}_j}) +
         \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 :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
-    kernel respectively. :math:`\text{bias}` is the bias parameter and :math:`\text{X}` is the input tensor.
-    In this case, `data_format` of the input tensor is 'NCHW' and the shape of full convolution kernel is
-    :math:`(C_{out}, C_{in} / \text{group}, \text{kernel_size[0]}, \text{kernel_size[1]})`,
-    where `group` is the number of groups to split the input `x` in the channel dimension. If `data_format` of the
-    input tensor is 'NHWC', the shape of full convolution kernel will be
-    :math:`(C_{out}, \text{kernel_size[0]}, \text{kernel_size[1]}), C_{in} / \text{group}`.
-
-    For more details, please refers to the paper `Gradient Based Learning Applied to Document
-    Recognition <http://vision.stanford.edu/cs598_spring07/papers/Lecun98.pdf>`_.
+    where :math:`bias` is the output channel bias, :math:`ccor` is
+    the `cross-correlation <https://en.wikipedia.org/wiki/Cross-correlation>`_,
+    , :math:`weight` is the convolution kernel value and :math:`X` represents the input feature map.
+
+    Here are the indices' meanings:
+    - :math:`i` corresponds to the batch number, ranging from 0 to N-1, where N is the batch size of the input.
+
+    - :math:`j` corresponds to the output channel, ranging from 0 to C_{out}-1, where C_{out} is the number of
+      output channels, which is also equal to the number of kernels.
+
+    - :math:`k` corresponds to the input channel, ranging from 0 to C_{in}-1, where C_{in} is the number of
+      input channels, which is also equal to the number of channels in the convolutional kernels.
+
+    Therefore, in the above formula, :math:`{bias}(C_{out_j})` represents the bias of the :math:`j`-th
+    output channel, :math:`{weight}(C_{out_j}, k)` represents the slice of the :math:`j`-th convolutional
+    kernel in the :math:`k`-th channel, and :math:`{X}(N_i, k)` represents the slice of the :math:`k`-th input
+    channel in the :math:`i`-th batch of the input feature map.
+
+    The shape of the convolutional kernel is given by :math:`(kernel\_size[0], kernel\_size[1])`,
+    where :math:`kernel\_size[0]` and :math:`kernel\_size[1]` are the height and width of the kernel, respectively.
+    If we consider the input and output channels as well as the `group` parameter, the complete kernel shape
+    will be :math:`(C_{out}, C_{in} / \text{group}, \text{kernel_size[0]}, \text{kernel_size[1]})`,
+    where `group` is the number of groups dividing `x`'s input channel when applying group convolution.
+
+    For more details about convolution layer, please refer to `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.
@@ -168,47 +191,62 @@ class Conv2d(_Conv):
             The data type is an integer or a tuple of two integers. An integer represents the height
             and width of the convolution kernel. A tuple of two integers represents the height
             and width of the convolution kernel respectively.
-        stride (Union[int, tuple[int]]): The movement stride of the 2D convolution kernel.
-            The data type is an integer or a tuple of two integers. An integer represents the movement step size
+        stride (Union[int, tuple[int]], optional): The movement stride of the 2D convolution kernel.
+            The data type is an integer or a tuple of two or four integers. An integer represents the movement step size
             in both height and width directions. A tuple of two integers represents the movement step size in the height
-            and width directions respectively. Default: 1.
-        pad_mode (str): Specifies padding mode. The optional values are
-            "same", "valid", "pad". Default: "same".
-
-            - same: The width of the output is the same as the value of the input divided by `stride`.
-              If this mode is set, the value of `padding` must be 0.
-
-            - valid: Returns a valid calculated output without padding. Excess pixels that do not satisfy the
-              calculation will be discarded. If this mode is set, the value of `padding` must be 0.
-
-            - pad: Pads the input. Padding `padding` size of zero on both sides of the input.
-              If this mode is set, the value of `padding` must be greater than or equal to 0.
-
-        padding (Union[int, tuple[int]]): The number of padding on the height and width directions of the input.
+            and width directions respectively. Default: ``1`` .
+        pad_mode (str, optional): Specifies the padding mode with a padding value of 0. It can be set to:
+            ``"same"`` , ``"valid"`` or ``"pad"`` . Default: ``"same"`` .
+
+            - ``"same"``: Pad the input around its edges so that the shape of input and output
+              are the same when `stride` is set to ``1``.
+              The amount of padding to is calculated by the operator internally, If the amount is even, it is
+              uniformly distributed around the input, if it is odd, the excess amount goes to the right/bottom side.
+              If this mode is set, `padding` must be 0.
+            - ``"valid"``: No padding is applied to the input, and the output returns the maximum
+              possible height and width. Extra pixels that could not complete a full stride will
+              be discarded. If this mode is set, `padding` must be 0.
+            - ``"pad"``: Pad the input with a specified amount. In this mode, the amount of padding
+              in the height and width directions is determined by the `padding` parameter.
+              If this mode is set, `padding` must be greater than or equal to 0.
+
+        padding (Union[int, tuple[int]], optional): The number of padding
+            on the height and width directions of the input.
             The data type is an integer or a tuple of four integers. If `padding` is an integer,
             then the top, bottom, left, and right padding are all equal to `padding`.
             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.
-        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]
-            and [1, W] respectively. Default: 1.
-        group (int): Splits filter into groups, `in_channels` and `out_channels` must be
+            The value should be greater than or equal to 0. Default: ``0`` .
+        dilation (Union(int, tuple[int]), optional): Specifies the dilation rate to use for dilated convolution.
+            It can be a single int or a tuple of 2 or 4 integers. A single int means the dilation size is the same
+            in both the height and width directions. A tuple of two ints represents the dilation size in
+            the height and width directions, respectively. For a tuple of four ints, the two ints correspond
+            to (N, C) dimension are treated as 1, and the two correspond to (H, W) dimensions is the
+            dilation size in the height and width directions respectively.
+            Assuming :math:`dilation=(d0, d1)`, the convolutional kernel samples the input with a
+            spacing of :math:`d0-1` elements in the height direction and :math:`d1-1` elements in the width direction.
+            The values in the height and width dimensions are in the ranges [1, H] and [1, W], respectively.
+            Default: ``1`` .
+        group (int, optional): Splits filter into groups, `in_channels` and `out_channels` must be
             divisible by `group`. If the group is equal to `in_channels` and `out_channels`,
-            this 2D convolution layer also can be called 2D depthwise convolution layer. Default: 1.
-        has_bias (bool): Whether the Conv2d layer has a bias parameter. Default: False.
-        weight_init (Union[Tensor, str, Initializer, numbers.Number]): Initialization method of weight parameter.
+            this 2D convolution layer also can be called 2D depthwise convolution layer. Default: ``1`` .
+        has_bias (bool, optional): Whether the Conv2d layer has a bias parameter. Default: ``False`` .
+        weight_init (Union[Tensor, str, Initializer, numbers.Number], optional): Initialization method of
+            weight parameter.
             It can be a Tensor, a string, an Initializer or a numbers.Number. When a string is specified,
-            values from 'TruncatedNormal', 'Normal', 'Uniform', 'HeUniform' and 'XavierUniform' distributions as well
-            as constant 'One' and 'Zero' distributions are possible. Alias 'xavier_uniform', 'he_uniform', 'ones'
-            and 'zeros' are acceptable. Uppercase and lowercase are both acceptable. Refer to the values of
-            Initializer for more details. Default: 'normal'.
-        bias_init (Union[Tensor, str, Initializer, numbers.Number]): Initialization method of bias parameter.
+            values from ``'TruncatedNormal'`` , ``'Normal'`` , ``'Uniform'`` , ``'HeUniform'`` and ``'XavierUniform'``
+            distributions as well as constant ``'One'`` and ``'Zero'`` distributions are possible. Alias
+            ``'xavier_uniform'`` , ``'he_uniform'`` , ``'ones'`` and ``'zeros'`` are acceptable. Uppercase and
+            lowercase are both acceptable. Refer to the values of
+            `Initializer <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.common.initializer.html>`_,
+            for more details. Default: ``None`` , weight will be initialized using ``'HeUniform'``.
+        bias_init (Union[Tensor, str, Initializer, numbers.Number], optional): Initialization method of bias parameter.
             Available initialization methods are the same as 'weight_init'. Refer to the values of
-            Initializer for more details. Default: 'zeros'.
-        data_format (str): The optional value for data format, is 'NHWC' or 'NCHW'.
-            Default: 'NCHW'.
+            `Initializer <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.common.initializer.html>`_,
+            for more details. Default: ``None`` , bias will be initialized using ``'Uniform'`` .
+        data_format (str, optional): The optional value for data format, is ``'NHWC'`` or ``'NCHW'`` .
+            Default: ``'NCHW'`` .
+        dtype (:class:`mindspore.dtype`): Dtype of Parameters. Default: ``mstype.float32`` .
 
     Inputs:
         - **x** (Tensor) - Tensor of shape :math:`(N, C_{in}, H_{in}, W_{in})` \
@@ -217,7 +255,7 @@ class Conv2d(_Conv):
     Outputs:
         Tensor of shape :math:`(N, C_{out}, H_{out}, W_{out})` or :math:`(N, H_{out}, W_{out}, C_{out})`.
 
-        pad_mode is 'same':
+        pad_mode is ``'same'``:
 
         .. math::
             \begin{array}{ll} \\
@@ -225,7 +263,7 @@ class Conv2d(_Conv):
                 W_{out} = \left \lceil{\frac{W_{in}}{\text{stride[1]}}} \right \rceil \\
             \end{array}
 
-        pad_mode is 'valid':
+        pad_mode is ``'valid'``:
 
         .. math::
             \begin{array}{ll} \\
@@ -235,7 +273,7 @@ class Conv2d(_Conv):
                 {\text{stride[1]}}} \right \rceil \\
             \end{array}
 
-        pad_mode is 'pad':
+        pad_mode is ``'pad'``:
 
         .. math::
             \begin{array}{ll} \\
@@ -259,6 +297,9 @@ class Conv2d(_Conv):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, nn
+        >>> import numpy as np
         >>> net = nn.Conv2d(120, 240, 4, has_bias=False, weight_init='normal')
         >>> x = Tensor(np.ones([1, 120, 1024, 640]), mindspore.float32)
         >>> output = net(x).shape
@@ -277,14 +318,20 @@ class Conv2d(_Conv):
                  dilation=1,
                  group=1,
                  has_bias=False,
-                 weight_init='normal',
-                 bias_init='zeros',
-                 data_format='NCHW'):
+                 weight_init=None,
+                 bias_init=None,
+                 data_format='NCHW',
+                 dtype=mstype.float32):
         """Initialize Conv2d."""
         kernel_size = twice(kernel_size)
         stride = twice(stride)
         self._dilation = dilation
         dilation = twice(dilation)
+        Validator.check_positive_int(group, 'group', self.cls_name)
+        if not (in_channels % group == 0 and out_channels % group == 0):
+            raise ValueError(f"The argument 'group' should be divisible by 'in_channels' " \
+                             f"and 'out_channels', but got group:{group}, in_channels:{in_channels}, " \
+                             f"out_channels:{out_channels}.")
         super(Conv2d, self).__init__(
             in_channels,
             out_channels,
@@ -297,7 +344,8 @@ class Conv2d(_Conv):
             has_bias,
             weight_init,
             bias_init,
-            data_format)
+            data_format,
+            dtype=dtype)
         self.conv2d = P.Conv2D(out_channel=self.out_channels,
                                kernel_size=self.kernel_size,
                                mode=1,
@@ -324,26 +372,45 @@ def _check_input_3d(input_shape, op_name):
 
 class Conv1d(_Conv):
     r"""
-    Calculates the 1D convolution on the input tensor. The input is typically of shape :math:`(N, C_{in}, L_{in})`,
-    where :math:`N` is batch size, :math:`C_{in}` is a number of channels and :math:`L_{in}` is a length of sequence.
-    For the tensor of each batch, its shape is :math:`(C_{in}, L_{in})`, and the formula is defined as:
+    1D convolution layer.
+
+    Applies a 1D convolution over an input tensor which is typically of shape :math:`(N, C_{in}, L_{in})`,
+    where :math:`N` is batch size, :math:`C` is channel number, :math:`L` is input sequence width.
+
+    The output is calculated based on formula:
 
     .. math::
 
         \text{out}(N_i, C_{\text{out}_j}) = \text{bias}(C_{\text{out}_j}) +
         \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 :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,
-    and :math:`\text{X}` is the input tensor. The shape of full convolution kernel is
-    :math:`(C_{out}, C_{in} / \text{group}, \text{kernel_size})`,
-    where `group` is the number of groups to split the input `x` in the channel dimension.
+    where :math:`bias` is the output channel bias, :math:`ccor` is
+    the `cross-correlation <https://en.wikipedia.org/wiki/Cross-correlation>`_,
+    , :math:`weight` is the convolution kernel value and :math:`X` represents the input feature map.
 
-    For more details, please refers to the paper `Gradient Based Learning Applied to Document
-    Recognition <http://vision.stanford.edu/cs598_spring07/papers/Lecun98.pdf>`_.
+    Here are the indices' meanings:
+    - :math:`i` corresponds to the batch number, ranging from 0 to N-1, where N is the batch size of the input.
+
+    - :math:`j` corresponds to the output channel, ranging from 0 to C_{out}-1, where C_{out} is the number of
+      output channels, which is also equal to the number of kernels.
+
+    - :math:`k` corresponds to the input channel, ranging from 0 to C_{in}-1, where C_{in} is the number of
+      input channels, which is also equal to the number of channels in the convolutional kernels.
+
+    Therefore, in the above formula, :math:`{bias}(C_{out_j})` represents the bias of the :math:`j`-th
+    output channel, :math:`{weight}(C_{out_j}, k)` represents the slice of the :math:`j`-th convolutional
+    kernel in the :math:`k`-th channel, and :math:`{X}(N_i, k)` represents the slice of the :math:`k`-th input
+    channel in the :math:`i`-th batch of the input feature map.
+
+    The shape of the convolutional kernel is given by :math:`(kernel\_size)`,
+    where :math:`kernel\_size` is the width of the kernel.
+    If we consider the input and output channels as well as the `group` parameter, the complete kernel shape
+    will be :math:`(C_{out}, C_{in} / \text{group}, \text{kernel_size})`,
+    where `group` is the number of groups dividing `x`'s input channel when applying group convolution.
+
+    For more details about convolution layer, please refer to `Gradient Based Learning Applied to Document Recognition
+    <http://vision.stanford.edu/cs598_spring07/papers/Lecun98.pdf>`_
+    and `ConvNets <http://cs231n.github.io/convolutional-networks/>`_ .
 
     Note:
         On Ascend platform, only group convolution in depthwise convolution scenarios is supported.
@@ -353,54 +420,68 @@ class Conv1d(_Conv):
         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.
         kernel_size (int): Specifies the width of the 1D convolution kernel.
-        stride (int): The movement stride of the 1D convolution kernel. Default: 1.
-        pad_mode (str): Specifies padding mode. The optional values are
-            "same", "valid", "pad". Default: "same".
-
-            - same: The width of the output is the same as the value of the input divided by `stride`.
-              If this mode is set, the value of `padding` must be 0.
-
-            - valid: Returns a valid calculated output without padding. Excess pixels that do not satisfy the
-              calculation will be discarded. If this mode is set, the value of `padding` must be 0.
-
-            - pad: Pads the input. Padding `padding` size of zero on both sides of the input.
-              If this mode is set, the value of `padding` must be greater than or equal to 0.
-
-        padding (int): The number of padding on both sides of input.
-            The value should be greater than or equal to 0. Default: 0.
-        dilation (int): Dilation size of 1D convolution kernel. If :math:`k > 1`, the kernel is sampled
-            every `k` elements. The value of `k` is in range of [1, L]. Default: 1.
-        group (int): Splits filter into groups, `in_channels` and `out_channels` must be
-            divisible by `group`. Default: 1.
-        has_bias (bool): Whether the Conv1d layer has a bias parameter. Default: False.
-        weight_init (Union[Tensor, str, Initializer, numbers.Number]): Initialization method of weight parameter.
+        stride (int, optional): The movement stride of the 1D convolution kernel. Default: ``1`` .
+        pad_mode (str, optional): Specifies the padding mode with a padding value of 0. It can be set to:
+            ``"same"`` , ``"valid"`` or ``"pad"`` . Default: ``"same"`` .
+
+            - ``"same"``: Pad the input at the begin and end so that the shape of input and output
+              are the same when `stride` is set to ``1``.
+              The amount of padding to is calculated by the operator internally. If the amount is even, it is
+              uniformly distributed around the input, if it is odd, the excess padding is goes to the right side.
+              If this mode is set, `padding` must be 0.
+            - ``"valid"``: No padding is applied to the input, and the output returns the maximum
+              possible length. Extra pixels that could not complete a full stride will
+              be discarded. If this mode is set, `padding` must be 0.
+            - ``"pad"``: Pad the input with a specified amount. In this mode, the amount of padding
+              at the begin and end is determined by the `padding` parameter.
+              If this mode is set, `padding` must be greater than or equal to 0.
+
+        padding (Union(int, tuple[int], list[int]), optional):  Specifies the amount of padding to apply on
+            both side of `input` when `pad_mode` is set to ``"pad"``. The
+            paddings of left and right are the same, equal to padding or padding[0] when padding is a tuple of
+            1 integer. Default: ``0`` .
+        dilation (Union(int, tuple[int]), optional): Specifies the dilation rate to use for dilated convolution.
+            It can be a single int or a tuple of 1 integer.
+            Assuming :math:`dilation=(d0,)`, the convolutional kernel samples the input with a
+            spacing of :math:`d0-1` elements in the width direction.
+            The value should be in the ranges [1, L].
+            Default: ``1`` .
+        group (int, optional): Splits filter into groups, `in_channels` and `out_channels` must be
+            divisible by `group`. Default: ``1`` .
+        has_bias (bool, optional): Whether the Conv1d layer has a bias parameter. Default: ``False`` .
+        weight_init (Union[Tensor, str, Initializer, numbers.Number], optional):
+            Initialization method of weight parameter.
             It can be a Tensor, a string, an Initializer or a numbers.Number. When a string is specified,
-            values from 'TruncatedNormal', 'Normal', 'Uniform', 'HeUniform' and 'XavierUniform' distributions as well
-            as constant 'One' and 'Zero' distributions are possible. Alias 'xavier_uniform', 'he_uniform', 'ones'
-            and 'zeros' are acceptable. Uppercase and lowercase are both acceptable. Refer to the values of
-            Initializer for more details. Default: 'normal'.
-        bias_init (Union[Tensor, str, Initializer, numbers.Number]): Initialization method of bias parameter.
+            values from ``'TruncatedNormal'`` , ``'Normal'`` , ``'Uniform'`` , ``'HeUniform'`` and ``'XavierUniform'``
+            distributions as well as constant 'One' and 'Zero' distributions are possible. Alias ``'xavier_uniform'`` ,
+            ``'he_uniform'`` , ``'ones'`` and ``'zeros'`` are acceptable. Uppercase and lowercase are both acceptable.
+            Refer to the values of
+            `Initializer <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.common.initializer.html>`_,
+            for more details. Default: ``None`` , weight will be initialized using ``'HeUniform'``.
+        bias_init (Union[Tensor, str, Initializer, numbers.Number], optional): Initialization method of bias parameter.
             Available initialization methods are the same as 'weight_init'. Refer to the values of
-            Initializer for more details. Default: 'zeros'.
+            `Initializer <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.common.initializer.html>`_,
+            for more details. Default: ``None`` , bias will be initialized using ``'Uniform'``.
+        dtype (:class:`mindspore.dtype`): Dtype of Parameters. Default: ``mstype.float32`` .
 
     Inputs:
-        - **x** (Tensor) - Tensor of shape :math:`(N, C_{in}, L_{in})`.
+        - **x** (Tensor) - Tensor of shape :math:`(N, C_{in}, L_{in})` .
 
     Outputs:
         Tensor of shape :math:`(N, C_{out}, L_{out})`.
 
-        pad_mode is 'same':
+        pad_mode is ``'same'``:
 
         .. math::
             L_{out} = \left \lceil{\frac{L_{in}}{\text{stride}}} \right \rceil
 
-        pad_mode is 'valid':
+        pad_mode is ``'valid'``:
 
         .. math::
             L_{out} = \left \lceil{\frac{L_{in} - \text{dilation} \times (\text{kernel_size} - 1) }
             {\text{stride}}} \right \rceil
 
-        pad_mode is 'pad':
+        pad_mode is ``'pad'``:
 
         .. math::
             L_{out} = \left \lfloor{\frac{L_{in} + 2 \times padding - (\text{kernel_size} - 1) \times
@@ -416,6 +497,9 @@ class Conv1d(_Conv):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, nn
+        >>> import numpy as np
         >>> net = nn.Conv1d(120, 240, 4, has_bias=False, weight_init='normal')
         >>> x = Tensor(np.ones([1, 120, 640]), mindspore.float32)
         >>> output = net(x).shape
@@ -434,8 +518,9 @@ class Conv1d(_Conv):
                  dilation=1,
                  group=1,
                  has_bias=False,
-                 weight_init='normal',
-                 bias_init='zeros'):
+                 weight_init=None,
+                 bias_init=None,
+                 dtype=mstype.float32):
         """Initialize Conv1d."""
         Validator.check_value_type("kernel_size", kernel_size, [int], self.cls_name)
         Validator.check_value_type("stride", stride, [int], self.cls_name)
@@ -445,6 +530,11 @@ class Conv1d(_Conv):
         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, Validator.GE, 'dilation', self.cls_name)
+        Validator.check_positive_int(group, 'group', self.cls_name)
+        if not (in_channels % group == 0 and out_channels % group == 0):
+            raise ValueError(f"The argument 'group' should be divisible by 'in_channels' " \
+                             f"and 'out_channels', but got group:{group}, in_channels:{in_channels}, " \
+                             f"out_channels:{out_channels}.")
         kernel_size = (1, kernel_size)
         stride = (1, stride)
         dilation = (1, dilation)
@@ -469,7 +559,8 @@ class Conv1d(_Conv):
             group,
             has_bias,
             weight_init,
-            bias_init)
+            bias_init,
+            dtype=dtype)
         self.padding = (0, 0, padding, padding)
         Validator.check_string(pad_mode, ['valid', 'same', 'pad'], 'pad_mode', self.cls_name)
         self.conv2d = P.Conv2D(out_channel=self.out_channels,
@@ -505,31 +596,48 @@ def _check_input_5dims(input_shape, op_name):
 
 class Conv3d(_Conv):
     r"""
-    Calculates the 3D convolution on the input tensor. The 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.
-    For the tensor of each batch, its shape is :math:`(C_{in}, D_{in}, H_{in}, W_{in})`, the formula is defined as:
+    3D convolution layer.
+
+    Applies a 3D convolution over an input tensor which is typically of shape
+    :math:`(N, C_{in}, D_{in}, H_{in}, W_{in})`, where :math:`N` is batch size, :math:`C` is channel number,
+    :math:`D` is feature depth, :math:`H` is feature height, :math:`W` is feature width.
+
+    The output is calculated based on formula:
 
     .. math::
 
         \text{out}(N_i, C_{\text{out}_j}) = \text{bias}(C_{\text{out}_j}) +
         \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 :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
-    the depth, height and width of the convolution kernel respectively. :math:`\text{bias}` is the bias parameter
-    and :math:`\text{X}` is the input tensor.
-    The shape of full convolution kernel is
-    :math:`(C_{out}, C_{in} / \text{group}, \text{kernel_size[0]}, \text{kernel_size[1]}, \text{kernel_size[2]})`,
-    where `group` is the number of groups to split the input `x` in the channel dimension.
-
-    For more details, please refers to the paper `Gradient Based Learning Applied to Document
-    Recognition <http://vision.stanford.edu/cs598_spring07/papers/Lecun98.pdf>`_.
+    where :math:`bias` is the output channel bias, :math:`ccor` is
+    the `cross-correlation <https://en.wikipedia.org/wiki/Cross-correlation>`_,
+    , :math:`weight` is the convolution kernel value and :math:`X` represents the input feature map.
+
+    Here are the indices' meanings:
+    - :math:`i` corresponds to the batch number, ranging from 0 to N-1, where N is the batch size of the input.
+
+    - :math:`j` corresponds to the output channel, ranging from 0 to C_{out}-1, where C_{out} is the number of
+      output channels, which is also equal to the number of kernels.
+
+    - :math:`k` corresponds to the input channel, ranging from 0 to C_{in}-1, where C_{in} is the number of
+      input channels, which is also equal to the number of channels in the convolutional kernels.
+
+    Therefore, in the above formula, :math:`{bias}(C_{out_j})` represents the bias of the :math:`j`-th
+    output channel, :math:`{weight}(C_{out_j}, k)` represents the slice of the :math:`j`-th convolutional
+    kernel in the :math:`k`-th channel, and :math:`{X}(N_i, k)` represents the slice of the :math:`k`-th input
+    channel in the :math:`i`-th batch of the input feature map.
+
+    The shape of the convolutional kernel is given by
+    :math:`(\text{kernel_size[0]}, \text{kernel_size[1]}, \text{kernel_size[2]})`
+    where :math:`kernel\_size[0]` , :math:`kernel\_size[1]` and :math:`kernel\_size[2]` are the depth,
+    height and width of the kernel, respectively.
+    If we consider the input and output channels as well as the `group` parameter, the complete kernel shape
+    will be :math:`(C_{out}, C_{in} / \text{group}, \text{kernel_size[0]},
+    \text{kernel_size[1]}, \text{kernel_size[2]})`,
+    where `group` is the number of groups dividing `x`'s input channel when applying group convolution.
+
+    For more details about convolution layer, please refer to `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.
@@ -539,48 +647,65 @@ class Conv3d(_Conv):
         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.
         kernel_size (Union[int, tuple[int]]): Specifies the depth, height and width of the 3D convolution kernel.
-            The data type is an integer or a tuple of three integers. An integer represents the depth, height
-            and width of the convolution kernel. A tuple of three integers represents the depth, height
-            and width of the convolution kernel respectively.
-        stride (Union[int, tuple[int]]): The movement stride of the 3D convolution kernel.
+            It can be a single int or a tuple of 3 integers. A single int means the value is for depth, height
+            and the width. A tuple of 3 ints means the first value is
+            for depth and the rest is for the height and width.
+        stride (Union[int, tuple[int]], optional): The movement stride of the 3D convolution kernel.
             The data type is an integer or a tuple of three integers. An integer represents the movement step size
             in depth, height and width directions. A tuple of three integers represents the movement step size
-            in the depth, height and width directions respectively. Default: 1.
-        pad_mode (str): Specifies padding mode. The optional values are
-            "same", "valid", "pad". Default: "same".
-
-            - same: The width of the output is the same as the value of the input divided by `stride`.
-              If this mode is set, the value of `padding` must be 0.
-
-            - valid: Returns a valid calculated output without padding. Excess pixels that do not satisfy the
-              calculation will be discarded. If this mode is set, the value of `padding` must be 0.
-
-            - pad: Pads the input. Padding `padding` size of zero on both sides of the input.
-              If this mode is set, the value of `padding` must be greater than or equal to 0.
-
-        padding (Union(int, tuple[int])): The number of padding on the depth, height and width directions of the input.
+            in the depth, height and width directions respectively. Default: ``1`` .
+        pad_mode (str, optional): Specifies the padding mode with a padding value of 0. It can be set to:
+            ``"same"`` , ``"valid"`` or ``"pad"`` . Default: ``"same"`` .
+
+            - ``"same"``: Pad the input around its depth/height/width dimension so that the shape of input and output
+              are the same when `stride` is set to ``1``.
+              The amount of padding to is calculated by the operator internally.  If the amount is even,
+              it isuniformly distributed around the input, if it is odd, the excess amount goes
+              to the front/right/bottom side.
+              If this mode is set, `padding` must be 0.
+            - ``"valid"``: No padding is applied to the input, and the output returns the maximum
+              possible depth, height and width. Extra pixels that could not complete a full stride will
+              be discarded. If this mode is set, `padding` must be 0.
+            - ``"pad"``: Pad the input with a specified amount. In this mode, the amount of padding
+              in the depth, height and width dimension is determined by the `padding` parameter.
+              If this mode is set, `padding` must be greater than or equal to 0.
+
+        padding (Union(int, tuple[int]), optional): The number of padding on the depth,
+            height and width directions of the input.
             The data type is an integer or a tuple of six integers. If `padding` is an integer,
             then the head, tail, top, bottom, left, and right padding are all equal to `padding`.
             If `padding` is a tuple of six integers, then the head, tail, top, bottom, left, and right padding
             is equal to `padding[0]`, `padding[1]`, `padding[2]`, `padding[3]`, `padding[4]` and `padding[5]`
-            respectively. The value should be greater than or equal to 0. Default: 0.
-        dilation (Union[int, tuple[int]]): Dilation size of 3D convolution kernel.
-            The data type is an integer or a tuple of three integers. If :math:`k > 1`, the kernel is sampled
-            every `k` elements. The value of `k` on the depth, height and width directions is in range of
-            [1, D], [1, H] and [1, W] respectively. Default: 1.
-        group (int): Splits filter into groups, `in_channels` and `out_channels` must be
-            divisible by `group`. Default: 1. Only 1 is currently supported.
-        has_bias (bool): Whether the Conv3d layer has a bias parameter. Default: False.
-        weight_init (Union[Tensor, str, Initializer, numbers.Number]): Initialization method of weight parameter.
+            respectively. The value should be greater than or equal to 0. Default: ``0`` .
+        dilation (Union[int, tuple[int]], optional): Specifies the dilation rate to use for dilated convolution.
+            It can be a single int or a tuple of 3 integers. A single int means the dilation size is the same
+            in the depth, height and width directions. A tuple of 3 ints represents the dilation size in
+            the depth, height and width directions, respectively.
+            Assuming :math:`dilation=(d0, d1, d2)`, the convolutional kernel samples the input with a
+            spacing of :math:`d0-1` elements in the depth direction, :math:`d1-1` elements in the height direction,
+            :math:`d2-1` elements in the width direction respectively.
+            The values in the depth, height and width dimensions are in
+            the ranges [1, D], [1, H] and [1, W], respectively.
+            Default: ``1`` .
+        group (int, optional): Splits filter into groups, `in_channels` and `out_channels` must be
+            divisible by `group`. Default: ``1`` .
+        has_bias (bool, optional): Whether the Conv3d layer has a bias parameter. Default: ``False`` .
+        weight_init (Union[Tensor, str, Initializer, numbers.Number], optional):
+            Initialization method of weight parameter.
             It can be a Tensor, a string, an Initializer or a numbers.Number. When a string is specified,
-            values from 'TruncatedNormal', 'Normal', 'Uniform', 'HeUniform' and 'XavierUniform' distributions as well
-            as constant 'One' and 'Zero' distributions are possible. Alias 'xavier_uniform', 'he_uniform', 'ones'
-            and 'zeros' are acceptable. Uppercase and lowercase are both acceptable. Refer to the values of
-            Initializer for more details. Default: 'normal'.
-        bias_init (Union[Tensor, str, Initializer, numbers.Number]): Initialization method of bias parameter.
+            values from ``'TruncatedNormal'`` , ``'Normal'`` , ``'Uniform'`` , ``'HeUniform'`` and ``'XavierUniform'``
+            distributions as well as constant ``'One'`` and ``'Zero'`` distributions are possible. Alias
+            ``'xavier_uniform'`` , ``'he_uniform'`` , ``'ones'`` and ``'zeros'`` are acceptable. Uppercase and
+            lowercase are both acceptable. Refer to the values of
+            `Initializer <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.common.initializer.html>`_,
+            for more details. Default: ``None`` , weight will be initialized using ``'HeUniform'``.
+        bias_init (Union[Tensor, str, Initializer, numbers.Number], optional): Initialization method of bias parameter.
             Available initialization methods are the same as 'weight_init'. Refer to the values of
-            Initializer for more details. Default: 'zeros'.
-        data_format (str): The optional value for data format. Currently only support "NCDHW".
+            `Initializer <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.common.initializer.html>`_,
+            for more details. Default: ``None`` , bias will be initialized using ``'Uniform'`` .
+        data_format (str, optional): The optional value for data format. Currently only support ``'NCDHW'`` .
+        dtype (:class:`mindspore.dtype`): Dtype of Parameters. Default: ``mstype.float32`` .
+
 
     Inputs:
         - **x** (Tensor) - Tensor of shape :math:`(N, C_{in}, D_{in}, H_{in}, W_{in})`.
@@ -589,7 +714,7 @@ class Conv3d(_Conv):
     Outputs:
         Tensor of shape is :math:`(N, C_{out}, D_{out}, H_{out}, W_{out})`.
 
-        pad_mode is 'same':
+        pad_mode is ``'same'`` :
 
         .. math::
             \begin{array}{ll} \\
@@ -599,7 +724,7 @@ class Conv3d(_Conv):
             \end{array}
 
 
-        pad_mode is 'valid':
+        pad_mode is ``'valid'`` :
 
         .. math::
             \begin{array}{ll} \\
@@ -611,7 +736,7 @@ class Conv3d(_Conv):
                 {\text{stride[2]}} + 1} \right \rfloor \\
             \end{array}
 
-        pad_mode is 'pad':
+        pad_mode is ``'pad'`` :
 
         .. math::
             \begin{array}{ll} \\
@@ -637,6 +762,9 @@ class Conv3d(_Conv):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, nn
+        >>> import numpy as np
         >>> x = Tensor(np.ones([16, 3, 10, 32, 32]), mindspore.float32)
         >>> conv3d = nn.Conv3d(in_channels=3, out_channels=32, kernel_size=(4, 3, 3))
         >>> output = conv3d(x)
@@ -655,11 +783,12 @@ class Conv3d(_Conv):
                  dilation=1,
                  group=1,
                  has_bias=False,
-                 weight_init='normal',
-                 bias_init='zeros',
-                 data_format='NCDHW'):
+                 weight_init=None,
+                 bias_init=None,
+                 data_format='NCDHW',
+                 dtype=mstype.float32):
         """Initialize Conv3d."""
-        if not in_channels % group == 0 and out_channels % group == 0:
+        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'")
 
@@ -681,8 +810,9 @@ class Conv3d(_Conv):
             has_bias,
             weight_init,
             bias_init,
-            data_format)
-        out_channels = self.out_channels // group
+            data_format,
+            dtype=dtype)
+        out_channels = self.out_channels
         self.conv3d = P.Conv3D(out_channel=out_channels,
                                kernel_size=self.kernel_size,
                                mode=1,
@@ -690,33 +820,17 @@ class Conv3d(_Conv):
                                pad=self.padding,
                                stride=self.stride,
                                dilation=self.dilation,
-                               group=1,
+                               group=group,
                                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)
-        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)
+        out = self.conv3d(x, self.weight)
+        if self.has_bias:
+            out = self.bias_add(out, self.bias)
         return out
 
 
@@ -725,7 +839,7 @@ 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).
 
-    he input is typically of shape :math:`(N, C_{in}, D_{in}, H_{in}, W_{in})`,
+    The 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.
 
@@ -745,58 +859,65 @@ class Conv3dTranspose(_Conv):
         stride (Union[int, tuple[int]]): The movement stride of the 3D convolution kernel.
             The data type is an integer or a tuple of three integers. An integer represents the movement step size
             in depth, height and width directions. A tuple of three integers represents the movement step size
-            in the depth, height and width directions respectively. Default: 1.
-        pad_mode (str): Specifies padding mode. The optional values are
-            "same", "valid", "pad". Default: "same".
-
-            - same: The width of the output is the same as the value of the input divided by `stride`.
-              If this mode is set, the value of `padding` must be 0.
-
-            - valid: Returns a valid calculated output without padding. Excess pixels that do not satisfy the
-              calculation will be discarded. If this mode is set, the value of `padding` must be 0.
-
-            - pad: Pads the input. Padding `padding` size of zero on both sides of the input.
-              If this mode is set, the value of `padding` must be greater than or equal to 0.
+            in the depth, height and width directions respectively. Default: ``1`` .
+        pad_mode (str, optional): Specifies the padding mode with a padding value of 0. It can be set to:
+            ``"same"`` , ``"valid"`` or ``"pad"`` . Default: ``"same"`` .
+
+            - ``"same"``: Pad the input around its depth/height/width dimension so that the shape of input and output
+              are the same when `stride` is set to ``1``.
+              The amount of padding to is calculated by the operator internally.  If the amount is even,
+              it isuniformly distributed around the input, if it is odd, the excess amount goes
+              to the front/right/bottom side.
+              If this mode is set, `padding` must be 0.
+            - ``"valid"``: No padding is applied to the input, and the output returns the maximum
+              possible depth, height and width. Extra pixels that could not complete a full stride will
+              be discarded. If this mode is set, `padding` must be 0.
+            - ``"pad"``: Pad the input with a specified amount. In this mode, the amount of padding
+              in the depth, height and width dimension is determined by the `padding` parameter.
+              If this mode is set, `padding` must be greater than or equal to 0.
 
         padding (Union(int, tuple[int])): The number of padding on the depth, height and width directions of the input.
             The data type is an integer or a tuple of six integers. If `padding` is an integer,
             then the head, tail, top, bottom, left, and right padding are all equal to `padding`.
             If `padding` is a tuple of six integers, then the head, tail, top, bottom, left, and right padding
             is equal to `padding[0]`, `padding[1]`, `padding[2]`, `padding[3]`, `padding[4]` and `padding[5]`
-            respectively. The value should be greater than or equal to 0. Default: 0.
+            respectively. The value should be greater than or equal to 0. Default: ``0`` .
         dilation (Union[int, tuple[int]]): Dilation size of 3D convolution kernel.
             The data type is an integer or a tuple of three integers. If :math:`k > 1`, the kernel is sampled
             every `k` elements. The value of `k` on the depth, height and width directions is in range of
-            [1, D], [1, H] and [1, W] respectively. Default: 1.
+            [1, D], [1, H] and [1, W] respectively. Default: ``1`` .
         group (int): Splits filter into groups, `in_channels` and `out_channels` must be
-            divisible by `group`. Default: 1. Only 1 is currently supported.
+            divisible by `group`. Default: ``1`` .
         output_padding (Union(int, tuple[int])): The number of padding on the depth, height and width directions of
             the output. The data type is an integer or a tuple of six integers. If `output_padding` is an integer,
             then the head, tail, top, bottom, left, and right padding are all equal to `output_padding`.
             If `output_padding` is a tuple of six integers, then the head, tail, top, bottom, left, and right padding
             is equal to `output_padding[0]`, `output_padding[1]`, `output_padding[2]`, `output_padding[3]`,
             `output_padding[4]` and `output_padding[5]` respectively. The value should be greater than or equal to 0.
-            Default: 0.
-        has_bias (bool): Whether the Conv3dTranspose layer has a bias parameter. Default: False.
+            Default: ``0`` .
+        has_bias (bool): Whether the Conv3dTranspose layer has a bias parameter. Default: ``False`` .
         weight_init (Union[Tensor, str, Initializer, numbers.Number]): Initialization method of weight parameter.
             It can be a Tensor, a string, an Initializer or a numbers.Number. When a string is specified,
-            values from 'TruncatedNormal', 'Normal', 'Uniform', 'HeUniform' and 'XavierUniform' distributions as well
-            as constant 'One' and 'Zero' distributions are possible. Alias 'xavier_uniform', 'he_uniform', 'ones'
-            and 'zeros' are acceptable. Uppercase and lowercase are both acceptable. Refer to the values of
-            Initializer for more details. Default: 'normal'.
+            values from ``'TruncatedNormal'`` , ``'Normal'`` , ``'Uniform'`` , ``'HeUniform'`` and ``'XavierUniform'``
+            distributions as well as constant ``'One'`` and ``'Zero'`` distributions are possible. Alias
+            ``'xavier_uniform'`` , ``'he_uniform'`` , ``'ones'`` and ``'zeros'`` are acceptable. Uppercase and
+            lowercase are both acceptable. Refer to the values of Initializer for more details. Default: ``None`` ,
+            weight will be initialized using HeUniform.
         bias_init (Union[Tensor, str, Initializer, numbers.Number]): Initialization method of bias parameter.
             Available initialization methods are the same as 'weight_init'. Refer to the values of
-            Initializer for more details. Default: 'zeros'.
-        data_format (str): The optional value for data format. Currently only support 'NCDHW'.
+            Initializer for more details. Default: ``None`` , bias will be initialized using Uniform.
+        data_format (str): The optional value for data format. Currently only support ``'NCDHW'`` .
+            Default: ``'NCDHW'`` .
+        dtype (:class:`mindspore.dtype`): Dtype of Parameters. Default: ``mstype.float32`` .
 
     Inputs:
         - **x** (Tensor) - Tensor of shape :math:`(N, C_{in}, D_{in}, H_{in}, W_{in})`.
-          Currently input data type only support float16 and float32.
+          Currently input data dtype only support float16 and float32.
 
     Outputs:
         Tensor, the shape is :math:`(N, C_{out}, D_{out}, H_{out}, W_{out})`.
 
-        pad_mode is 'same':
+        pad_mode is ``'same'`` :
 
         .. math::
             \begin{array}{ll} \\
@@ -806,7 +927,7 @@ class Conv3dTranspose(_Conv):
             \end{array}
 
 
-        pad_mode is 'valid':
+        pad_mode is ``'valid'`` :
 
         .. math::
             \begin{array}{ll} \\
@@ -818,7 +939,7 @@ class Conv3dTranspose(_Conv):
                 {\text{stride[2]}} + 1} \right \rfloor \\
             \end{array}
 
-        pad_mode is 'pad':
+        pad_mode is ``'pad'`` :
 
         .. math::
             \begin{array}{ll} \\
@@ -846,6 +967,9 @@ class Conv3dTranspose(_Conv):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, nn
+        >>> import numpy as np
         >>> x = Tensor(np.ones([32, 16, 10, 32, 32]), mindspore.float32)
         >>> conv3d_transpose = nn.Conv3dTranspose(in_channels=16, out_channels=3, kernel_size=(4, 6, 2),
         ...                                       pad_mode='pad')
@@ -859,16 +983,21 @@ class Conv3dTranspose(_Conv):
                  out_channels,
                  kernel_size,
                  stride=1,
-                 pad_mode='same',
+                 pad_mode="same",
                  padding=0,
                  dilation=1,
                  group=1,
                  output_padding=0,
                  has_bias=False,
-                 weight_init='normal',
-                 bias_init='zeros',
-                 data_format='NCDHW'):
+                 weight_init=None,
+                 bias_init=None,
+                 data_format='NCDHW',
+                 dtype=mstype.float32):
         """Initialize Conv3dTranspose."""
+        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)
@@ -890,7 +1019,8 @@ class Conv3dTranspose(_Conv):
             weight_init,
             bias_init,
             data_format,
-            transposed=True)
+            transposed=True,
+            dtype=dtype)
         self.conv3d_transpose = P.Conv3DTranspose(in_channel=self.in_channels,
                                                   out_channel=self.out_channels,
                                                   kernel_size=self.kernel_size,
@@ -956,47 +1086,52 @@ class Conv2dTranspose(_Conv):
         stride (Union[int, tuple[int]]): The movement stride of the 2D convolution kernel.
             The data type is an integer or a tuple of two integers. An integer represents the movement step size
             in both height and width directions. A tuple of two integers represents the movement step size in the height
-            and width directions respectively. Default: 1.
-        pad_mode (str): Specifies padding mode. The optional values are
-            "same", "valid", "pad". Default: "same".
-
-            - same: The width of the output is the same as the value of the input divided by `stride`.
-              If this mode is set, the value of `padding` must be 0.
-
-            - valid: Returns a valid calculated output without padding. Excess pixels that do not satisfy the
-              calculation will be discarded. If this mode is set, the value of `padding` must be 0.
-
-            - pad: Pads the input. Padding `padding` size of zero on both sides of the input.
-              If this mode is set, the value of `padding` must be greater than or equal to 0.
+            and width directions respectively. Default: ``1`` .
+        pad_mode (str, optional): Specifies the padding mode with a padding value of 0. It can be set to:
+            ``"same"`` , ``"valid"`` or ``"pad"`` . Default: ``"same"`` .
+
+            - ``"same"``: Pad the input around its edges so that the shape of input and output
+              are the same when `stride` is set to ``1``.
+              The amount of padding to is calculated by the operator internally, If the amount is even, it is
+              uniformly distributed around the input, if it is odd, the excess amount goes to the right/bottom side.
+              If this mode is set, `padding` must be 0.
+            - ``"valid"``: No padding is applied to the input, and the output returns the maximum
+              possible height and width. Extra pixels that could not complete a full stride will
+              be discarded. If this mode is set, `padding` must be 0.
+            - ``"pad"``: Pad the input with a specified amount. In this mode, the amount of padding
+              in the height and width directions is determined by the `padding` parameter.
+              If this mode is set, `padding` must be greater than or equal to 0.
 
         padding (Union[int, tuple[int]]): The number of padding on the height and width directions of the input.
             The data type is an integer or a tuple of four integers. If `padding` is an integer,
             then the top, bottom, left, and right padding are all equal to `padding`.
             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.
+            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.
+            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]
-            and [1, W] respectively. Default: 1.
+            and [1, W] respectively. Default: ``1`` .
         group (int): Splits filter into groups, `in_channels` and `out_channels` must be divisible by `group`.
-            Default: 1.
-        has_bias (bool): Whether the Conv2dTranspose layer has a bias parameter. Default: False.
+            Default: ``1`` .
+        has_bias (bool): Whether the Conv2dTranspose layer has a bias parameter. Default: ``False`` .
         weight_init (Union[Tensor, str, Initializer, numbers.Number]): Initialization method of weight parameter.
             It can be a Tensor, a string, an Initializer or a numbers.Number. When a string is specified,
-            values from 'TruncatedNormal', 'Normal', 'Uniform', 'HeUniform' and 'XavierUniform' distributions as well
-            as constant 'One' and 'Zero' distributions are possible. Alias 'xavier_uniform', 'he_uniform', 'ones'
-            and 'zeros' are acceptable. Uppercase and lowercase are both acceptable. Refer to the values of
-            Initializer for more details. Default: 'normal'.
+            values from ``'TruncatedNormal'`` , ``'Normal'`` , ``'Uniform'`` , ``'HeUniform'`` and ``'XavierUniform'``
+            distributions as well as constant ``'One'`` and ``'Zero'`` distributions are possible. Alias
+            ``'xavier_uniform'`` , ``'he_uniform'`` , ``'ones'`` and ``'zeros'`` are acceptable. Uppercase and
+            lowercase are both acceptable. Refer to the values of Initializer for more details. Default: ``None`` ,
+            weight will be initialized using HeUniform.
         bias_init (Union[Tensor, str, Initializer, numbers.Number]): Initialization method of bias parameter.
             Available initialization methods are the same as 'weight_init'. Refer to the values of
-            Initializer for more details. Default: 'zeros'.
+            Initializer for more details. Default: ``None`` , bias will be initialized using Uniform.
+        dtype (:class:`mindspore.dtype`): Dtype of Parameters. Default: ``mstype.float32`` .
 
     Inputs:
         - **x** (Tensor) - Tensor of shape :math:`(N, C_{in}, H_{in}, W_{in})`.
@@ -1004,7 +1139,7 @@ class Conv2dTranspose(_Conv):
     Outputs:
         Tensor of shape :math:`(N, C_{out}, H_{out}, W_{out})`.
 
-        pad_mode is 'same':
+        pad_mode is ``'same'``:
 
         .. math::
             \begin{array}{ll} \\
@@ -1012,7 +1147,7 @@ class Conv2dTranspose(_Conv):
                 W_{out} = \text W_{in}\times \text {stride[1]} \\
             \end{array}
 
-        pad_mode is 'valid':
+        pad_mode is ``'valid'``:
 
         .. math::
             \begin{array}{ll} \\
@@ -1022,7 +1157,7 @@ class Conv2dTranspose(_Conv):
                 (\text{kernel_size[1]} - 1) - \text {stride[1]}, 0 \} \\
             \end{array}
 
-        pad_mode is 'pad':
+        pad_mode is ``'pad'``:
 
         .. math::
             \begin{array}{ll} \\
@@ -1047,6 +1182,9 @@ class Conv2dTranspose(_Conv):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, nn
+        >>> import numpy as np
         >>> net = nn.Conv2dTranspose(3, 64, 4, has_bias=False, weight_init='normal', pad_mode='pad')
         >>> x = Tensor(np.ones([1, 3, 16, 50]), mindspore.float32)
         >>> output = net(x).shape
@@ -1065,8 +1203,9 @@ class Conv2dTranspose(_Conv):
                  dilation=1,
                  group=1,
                  has_bias=False,
-                 weight_init='normal',
-                 bias_init='zeros'):
+                 weight_init=None,
+                 bias_init=None,
+                 dtype=mstype.float32):
         """Initialize Conv2dTranspose."""
         kernel_size = twice(kernel_size)
         stride = twice(stride)
@@ -1092,7 +1231,8 @@ class Conv2dTranspose(_Conv):
             has_bias,
             weight_init,
             bias_init,
-            transposed=True)
+            transposed=True,
+            dtype=dtype)
 
         self.in_channels = in_channels
         self.out_channels = out_channels
@@ -1102,8 +1242,6 @@ class Conv2dTranspose(_Conv):
         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')
 
         # cause Conv2DTranspose's out_channel refers to Conv2D's out_channel.
         self.conv2d_transpose = P.Conv2DTranspose(out_channel=in_channels,
@@ -1130,10 +1268,9 @@ class Conv2dTranspose(_Conv):
                                       self.stride[0], self.dilation[0], self.padding_top + self.padding_bottom)
         w_out = _deconv_output_length(self.is_valid, self.is_same, self.is_pad, w, self.kernel_size[1],
                                       self.stride[1], self.dilation[1], self.padding_left + self.padding_right)
-        if self.has_bias:
-            return self.bias_add(self.conv2d_transpose(x, self.weight, (n, self.out_channels, h_out, w_out)),
-                                 self.bias)
         conv2d_trans_ret = self.conv2d_transpose(x, self.weight, (n, self.out_channels, h_out, w_out))
+        if self.has_bias:
+            conv2d_trans_ret = self.bias_add(conv2d_trans_ret, self.bias)
         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)).")
@@ -1164,7 +1301,7 @@ class Conv1dTranspose(_Conv):
     also called deconvolution (although it is not an actual deconvolution).
 
     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
+    :math:`C_{in}` 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',
@@ -1177,35 +1314,40 @@ class Conv1dTranspose(_Conv):
         in_channels (int): The channel number of the input tensor of the Conv1dTranspose layer.
         out_channels (int): The channel number of the output tensor of the Conv1dTranspose layer.
         kernel_size (int): Specifies the width of the 1D convolution kernel.
-        stride (int): The movement stride of the 1D convolution kernel. Default: 1.
-        pad_mode (str): Specifies padding mode. The optional values are
-            "same", "valid", "pad". Default: "same".
-
-            - same: The width of the output is the same as the value of the input divided by `stride`.
-              If this mode is set, the value of `padding` must be 0.
-
-            - valid: Returns a valid calculated output without padding. Excess pixels that do not satisfy the
-              calculation will be discarded. If this mode is set, the value of `padding` must be 0.
-
-            - pad: Pads the input. Padding `padding` size of zero on both sides of the input.
-              If this mode is set, the value of `padding` must be greater than or equal to 0.
+        stride (int): The movement stride of the 1D convolution kernel. Default: ``1`` .
+        pad_mode (str, optional): Specifies the padding mode with a padding value of 0. It can be set to:
+            ``"same"`` , ``"valid"`` or ``"pad"`` . Default: ``"same"`` .
+
+            - ``"same"``: Pad the input at the begin and end so that the shape of input and output
+              are the same when `stride` is set to ``1``.
+              The amount of padding to is calculated by the operator internally. If the amount is even, it is
+              uniformly distributed around the input, if it is odd, the excess padding is goes to the right side.
+              If this mode is set, `padding` must be 0.
+            - ``"valid"``: No padding is applied to the input, and the output returns the maximum
+              possible length. Extra pixels that could not complete a full stride will
+              be discarded. If this mode is set, `padding` must be 0.
+            - ``"pad"``: Pad the input with a specified amount. In this mode, the amount of padding
+              at the begin and end is determined by the `padding` parameter.
+              If this mode is set, `padding` must be greater than or equal to 0.
 
         padding (int): The number of padding on both sides of input.
-            The value should be greater than or equal to 0. Default: 0.
+            The value should be greater than or equal to 0. Default: ``0`` .
         dilation (int): Dilation size of 1D convolution kernel. If :math:`k > 1`, the kernel is sampled
-            every `k` elements. The value of `k` is in range of [1, L]. Default: 1.
+            every `k` elements. The value of `k` is in range of [1, L]. Default: ``1`` .
         group (int): Splits filter into groups, `in_channels` and `out_channels` must be
-            divisible by `group`. When `group` > 1, the Ascend platform is not supported yet. Default: 1.
-        has_bias (bool): Whether the Conv1dTranspose layer has a bias parameter. Default: False.
+            divisible by `group`. When `group` > 1, the Ascend platform is not supported yet. Default: ``1`` .
+        has_bias (bool): Whether the Conv1dTranspose layer has a bias parameter. Default: ``False``.
         weight_init (Union[Tensor, str, Initializer, numbers.Number]): Initialization method of weight parameter.
             It can be a Tensor, a string, an Initializer or a numbers.Number. When a string is specified,
-            values from 'TruncatedNormal', 'Normal', 'Uniform', 'HeUniform' and 'XavierUniform' distributions as well
-            as constant 'One' and 'Zero' distributions are possible. Alias 'xavier_uniform', 'he_uniform', 'ones'
-            and 'zeros' are acceptable. Uppercase and lowercase are both acceptable. Refer to the values of
-            Initializer for more details. Default: 'normal'.
+            values from ``'TruncatedNormal'`` , ``'Normal'`` , ``'Uniform'`` , ``'HeUniform'`` and ``'XavierUniform'``
+            distributions as well as constant ``'One'`` and ``'Zero'`` distributions are possible. Alias
+            ``'xavier_uniform'`` , ``'he_uniform'``, ``'ones'`` and ``'zeros'`` are acceptable. Uppercase and lowercase
+            are both acceptable. Refer to the values of Initializer for more details. Default: ``None`` ,
+            weight will be initialized using HeUniform.
         bias_init (Union[Tensor, str, Initializer, numbers.Number]): Initialization method of bias parameter.
             Available initialization methods are the same as 'weight_init'. Refer to the values of
-            Initializer for more details. Default: 'zeros'.
+            Initializer for more details. Default: ``None`` , bias will be initialized using Uniform.
+        dtype (:class:`mindspore.dtype`): Dtype of Parameters. Default: ``mstype.float32`` .
 
     Inputs:
         - **x** (Tensor) - Tensor of shape :math:`(N, C_{in}, L_{in})`.
@@ -1213,22 +1355,14 @@ class Conv1dTranspose(_Conv):
     Outputs:
         Tensor of shape :math:`(N, C_{out}, L_{out})`.
 
-        pad_mode is 'same':
-
-        .. math::
-            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) }
-            {\text{stride}} + 1} \right \rfloor
+        pad_mode is ``'same'``: :math:`L_{out} = \frac{ L_{in} + \text{stride} - 1 }{ \text{stride} }`
 
-        pad_mode is 'pad':
+        pad_mode is ``'valid'``:
+        :math:`L_{out} = (L_{in} - 1) \times \text{stride} + \text{dilation} \times (\text{kernel_size} - 1) + 1`
 
-        .. math::
-            L_{out} = \left \lfloor{\frac{L_{in} + 2 \times padding - (\text{dilation} - 1) \times
-            \text{kernel_size} - 1 }{\text{stride}} + 1} \right \rfloor
+        pad_mode is ``'pad'``:
+        :math:`L_{out} = (L_{in} - 1) \times \text{stride} - 2 \times \text{padding}
+        + \text{dilation} \times (\text{kernel_size} - 1) + 1`
 
     Raises:
         TypeError: If `in_channels`, `out_channels`, `kernel_size`, `stride`, `padding` or `dilation` is not an int.
@@ -1240,6 +1374,9 @@ class Conv1dTranspose(_Conv):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, nn
+        >>> import numpy as np
         >>> net = nn.Conv1dTranspose(3, 64, 4, has_bias=False, weight_init='normal', pad_mode='pad')
         >>> x = Tensor(np.ones([1, 3, 50]), mindspore.float32)
         >>> output = net(x).shape
@@ -1257,8 +1394,9 @@ class Conv1dTranspose(_Conv):
                  dilation=1,
                  group=1,
                  has_bias=False,
-                 weight_init='normal',
-                 bias_init='zeros'):
+                 weight_init=None,
+                 bias_init=None,
+                 dtype=mstype.float32):
         """Initialize Conv1dTranspose."""
         Validator.check_value_type("kernel_size", kernel_size, [int], self.cls_name)
         Validator.check_value_type("stride", stride, [int], self.cls_name)
@@ -1295,7 +1433,8 @@ class Conv1dTranspose(_Conv):
             has_bias,
             weight_init,
             bias_init,
-            transposed=True)
+            transposed=True,
+            dtype=dtype)
         self.padding = (0, 0, padding, padding)
         self.in_channels = in_channels
         self.out_channels = out_channels
@@ -1304,8 +1443,6 @@ class Conv1dTranspose(_Conv):
         self.is_valid = self.pad_mode == 'valid'
         self.is_same = self.pad_mode == 'same'
         self.is_pad = self.pad_mode == 'pad'
-        if Validator.check_bool(has_bias, "has_bias", self.cls_name):
-            self.bias = Parameter(initializer(bias_init, [out_channels]), name='bias')
 
         # cause Conv2DBackpropInput's out_channel refers to Conv2D's out_channel.
         self.conv2d_transpose = P.Conv2DBackpropInput(out_channel=in_channels,