mindspore 2.5.0__cp311-cp311-win_amd64.whl → 2.6.0rc1__cp311-cp311-win_amd64.whl

mindspore/mint/nn/layer/activation.py

@@ -77,6 +77,55 @@ class SiLU(Cell):
         return mint.nn.functional.silu(x)
 
 
+class Sigmoid(Cell):
+    r"""
+    Applies sigmoid activation function element-wise.
+
+    Sigmoid function is defined as:
+
+    .. math::
+
+        \text{sigmoid}(x_i) = \frac{1}{1 + \exp(-x_i)},
+
+    where :math:`x_i` is the element of `x`.
+
+    Sigmoid Activation Function Graph:
+
+    .. image:: ../images/Sigmoid.png
+        :align: center
+
+    Inputs:
+        - **input** (Tensor) - `input` is :math:`x` in the preceding formula. Tensor of any dimension,
+          the data type is float16, float32, float64, complex64 or complex128.
+
+    Outputs:
+        Tensor, with the same type and shape as the `input`.
+
+    Raises:
+        TypeError: If dtype of `input` is not float16, float32, float64, complex64 or complex128.
+        TypeError: If `input` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, nn
+        >>> import numpy as np
+        >>> input = Tensor(np.array([-1, -2, 0, 2, 1]), mindspore.float16)
+        >>> sigmoid = mint.nn.Sigmoid()
+        >>> output = sigmoid(input)
+        >>> print(output)
+        [0.2688  0.11914 0.5     0.881   0.7305 ]
+    """
+    def __init__(self):
+        """Initialize LogSigmoid."""
+        super(Sigmoid, self).__init__()
+
+    def construct(self, input):
+        return mint.nn.functional.sigmoid(input)
+
+
 class LogSigmoid(Cell):
     r"""
     Applies logsigmoid activation element-wise. The input is a Tensor with any valid shape.
@@ -140,7 +189,8 @@ class ELU(Cell):
         \alpha * (\exp(x_i) - 1), &\text{otherwise.}
         \end{cases}
 
-    where :math:`x_i` represents the element of the input and :math:`\alpha` represents the `alpha` parameter.
+    where :math:`x_i` represents the element of the input and :math:`\alpha` represents the `alpha` parameter, and
+    `alpha` represents the smoothness of the ELU.
 
     ELU Activation Function Graph:
 
@@ -151,16 +201,18 @@ class ELU(Cell):
         This is an experimental API that is subject to change or deletion.
 
     Args:
-        alpha (float, optional): The alpha value of ELU, the data type is float. Default: ``1.0`` .
+        alpha (float, optional): The alpha value of ELU, the data type is float. Default: ``1.0``.
+        inplace (bool, optional): Whether to use inplace mode, the data type is bool. Default: ``False``.
 
     Inputs:
         - **input** (Tensor) - The input of ELU is a Tensor of any dimension.
 
     Outputs:
-        Tensor, with the same type and shape as the `input`.
+        Tensor, with the same shape and type as the `input`.
 
     Raises:
-        TypeError: If `alpha` is not a float.
+        RuntimeError: If the dtype of `input` is not float16, float32 or bfloat16.
+        TypeError: If the dtype of `alpha` is not float.
 
     Supported Platforms:
         ``Ascend``
@@ -176,13 +228,14 @@ class ELU(Cell):
         [-0.63212055  -0.86466473  0.  2.  1.]
     """
 
-    def __init__(self, alpha=1.0):
+    def __init__(self, alpha=1.0, inplace=False):
         """Initialize ELU."""
         super(ELU, self).__init__()
         self.alpha = alpha
+        self.inplace = inplace
 
     def construct(self, input):
-        return mint.nn.functional.elu(input, self.alpha)
+        return mint.nn.functional.elu(input, self.alpha, self.inplace)
 
 
 class GLU(Cell):
@@ -197,9 +250,6 @@ class GLU(Cell):
     Here :math:`\sigma` is the sigmoid function, and :math:`\otimes` is the Hadamard product.
     See `Language Modeling with Gated Convluational Networks <https://arxiv.org/abs/1612.08083>`_ .
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     Args:
         dim (int, optional): The dimension to split the input `input`. The value range is `[-r, r)` where `r`
             is the number of dimensions of `input`. Default: ``-1`` , the last dimension in `input`.
@@ -224,10 +274,10 @@ class GLU(Cell):
         ``Ascend`` ``CPU``
 
     Examples:
-        >>> import mindspore as ms
-        >>> m = ms.mint.nn.GLU()
-        >>> input = ms.Tensor([[0.1,0.2,0.3,0.4],[0.5,0.6,0.7,0.8]])
-        >>> output = m(input)
+        >>> from mindspore import mint, Tensor
+        >>> glu = mint.nn.GLU()
+        >>> input = Tensor([[0.1, 0.2, 0.3, 0.4], [0.5, 0.6, 0.7, 0.8]])
+        >>> output = glu(input)
         >>> print(output)
         [[0.05744425 0.11973753]
          [0.33409387 0.41398472]]
@@ -292,10 +342,67 @@ class Tanh(Cell):
         return mint.nn.functional.tanh(input)
 
 
+class Threshold(Cell):
+    r"""
+    Compute the Threshold activation function element-wise.
+
+    The Threshold is defined as:
+
+    .. math::
+        y =
+        \begin{cases}
+        x, &\text{ if } x > \text{threshold} \\
+        \text{value}, &\text{ otherwise }
+        \end{cases}
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        threshold (Union[int, float]): The value of the threshold.
+        value (Union[int, float]): The value to replace with when element is less than threshold.
+        inplace (bool, optional): Whether to apply erasing inplace. Default: ``False``.
+
+    Inputs:
+        - **input** (Tensor) - The input Tensor.
+
+    Outputs:
+        Tensor, the same shape and data type as the input.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `threshold` is not a float or an int.
+        TypeError: If `value` is not a float or an int.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, mint
+        >>> inputs = mindspore.Tensor([0.0, 2, 3], mindspore.float32)
+        >>> net = mint.nn.Threshold(1, 100)
+        >>> outputs = net(inputs)
+        >>> print(outputs)
+        [100.   2.   3.]
+    """
+
+    def __init__(self, threshold, value, inplace=False):
+        """Initialize Tanh."""
+        super(Threshold, self).__init__()
+        self.threshold = threshold
+        self.value = value
+        self.inplace = inplace
+
+    def construct(self, input):
+        return mint.nn.functional.threshold(input, self.threshold, self.value,
+                                            self.inplace)
+
 __all__ = [
     'LogSigmoid',
     'SiLU',
     'ELU',
     'GLU',
     'Tanh',
+    'Threshold',
 ]

mindspore/mint/nn/layer/conv.py

@@ -17,19 +17,20 @@ from __future__ import absolute_import
 
 import math
 
-from mindspore.ops.auto_generate.gen_ops_prim import conv2d_ext_op, conv2d_padding_op, conv3d_ext_op, conv3d_padding_op
+from mindspore.ops.auto_generate.gen_ops_prim import (conv1d_ext_op, conv1d_padding_op, conv2d_ext_op,
+                                                      conv2d_padding_op, conv3d_ext_op, conv3d_padding_op)
 from mindspore.ops.function.nn_func import pad_ext, conv_transpose2d
 from mindspore.ops.function.array_func import rank
 import mindspore.common.dtype as mstype
 from mindspore.common.parameter import Parameter
 from mindspore.common.initializer import initializer, HeUniform, Uniform, _calculate_fan_in_and_fan_out
 from mindspore import _checkparam as Validator
-from mindspore._checkparam import twice, triple
+from mindspore._checkparam import once, twice, triple
 from mindspore._extends import cell_attr_register
 from mindspore.nn.cell import Cell
 from mindspore.ops.functional import isconstant
 
-__all__ = ['Conv2d', 'ConvTranspose2d', 'Conv3d']
+__all__ = ['Conv2d', 'ConvTranspose2d', 'Conv3d', 'Conv1d']
 
 
 class _Conv(Cell):
@@ -135,6 +136,185 @@ class _Conv(Cell):
         return s
 
 
+class Conv1d(_Conv):
+    r"""
+    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 sequence length.
+
+    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:`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.
+
+    - :math:`i` corresponds to the batch number, the range is :math:`[0, N-1]`,
+      where :math:`N` is the batch size of the input.
+
+    - :math:`j` corresponds to the output channel, the range is :math:`[0, C_{out}-1]`,
+      where :math:`C_{out}` is the number of
+      output channels, which is also equal to the number of kernels.
+
+    - :math:`k` corresponds to the input channel, the range is :math:`[0, C_{in}-1]`,
+      where :math:`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_{\text{out}_j})` represents the bias of the :math:`j`-th
+    output channel, :math:`{weight}(C_{\text{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})`,
+    where :math:`\text{kernel_size}` is the length of the kernel.
+    If we consider the input and output channels as well as the `groups` parameter, the complete kernel shape
+    will be :math:`(C_{out}, C_{in} / \text{groups}, \text{kernel_size})`,
+    where `groups` is the number of groups dividing `x`'s input channel when applying groups 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>`_.
+
+    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.
+        kernel_size (Union[int, tuple[int], list[int]]): Specifies the length of the 1D convolution kernel.
+            The data type is an integer or a tuple of one integer.
+        stride (Union[int, tuple[int], list[int]], optional): The movement stride of the 1D convolution kernel.
+            The data type is an integer or a tuple of one integer. Default: ``1`` .
+        padding (Union[int, tuple[int], list[int], str], optional): The number of padding
+            on the input.
+            The data type is an integer or a tuple of one integer or string {``"valid"``, ``"same"``}.
+            The value should be greater than or equal to 0. Default: ``0`` .
+
+            - ``"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 side.
+              If this mode is set, `stride` must be 1.
+
+            - ``"valid"``: No padding is applied to the input, and the output returns the maximum
+              possible length. Extra sequence that could not complete a full stride will
+              be discarded.
+
+        padding_mode (str, optional): Specifies the padding mode with a padding value of 0. It can be set to:
+            ``"zeros"`` , ``"reflect"`` ``"circular"`` or ``"replicate"`` . Default: ``"zeros"`` .
+        dilation (Union[int, tuple[int], list[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=(d)`, the convolutional kernel samples the input with a
+            spacing of :math:`d-1` elements in the length direction.
+            Default: ``1`` .
+        groups (int, optional): Splits filter into groups, `in_channels` and `out_channels` must be
+            divisible by `groups`. If the groups is equal to `in_channels` and `out_channels`,
+            this 1D convolution layer also can be called 1D depthwise convolution layer. Default: ``1`` .
+            The following restraints must be met:
+
+              - :math:`(C_{in} \text{ % } \text{groups} == 0)`
+              - :math:`(C_{out} \text{ % } \text{groups} == 0)`
+              - :math:`(C_{out} >= \text{groups})`
+              - :math:`(\text{kernel_size[1]} = C_{in} / \text{groups})`
+
+        bias (bool, optional): Whether the Conv1d layer has a bias parameter. Default: ``True`` .
+        dtype (:class:`mindspore.dtype`, optional): Dtype of Parameters. Default: ``None``, using ``mstype.float32``.
+
+    Inputs:
+        - **x** (Tensor) - Tensor of shape :math:`(N, C_{in}, L_{in})` \
+          or :math:`(C_{in}, L_{in})`.
+
+    Outputs:
+        Tensor of shape :math:`(N, C_{out}, L_{out})` or :math:`(C_{out}, L_{out})`.
+
+        padding is ``'same'``:
+
+        .. math::
+            \begin{array}{ll} \\
+                L_{out} = \left \lceil{\frac{L_{in}}{\text{stride}}} \right \rceil \\
+            \end{array}
+
+        padding is ``'valid'``:
+
+        .. math::
+            \begin{array}{ll} \\
+                L_{out} = \left \lceil{\frac{L_{in} - \text{dilation} \times (\text{kernel_size} - 1) }
+                {\text{stride}}} \right \rceil \\
+            \end{array}
+
+        padding is int or tuple/list:
+
+        .. math::
+            \begin{array}{ll} \\
+                L_{out} = \left \lfloor{\frac{L_{in} + 2 \times {padding} - (\text{kernel_size} - 1) \times
+                \text{dilation} - 1 }{\text{stride}} + 1} \right \rfloor \\
+            \end{array}
+
+    Raises:
+        ValueError: Args and size of the input feature map should satisfy the output formula to ensure that the size of
+            the output feature map is positive; otherwise, an error will be reported.
+        RuntimeError: On Ascend, due to the limitation of the L1 cache size of different NPU chip, if input size or
+            kernel size is too large, it may trigger an error.
+        TypeError: If `in_channels`, `out_channels` or `groups` is not an int.
+        TypeError: If `kernel_size`, `stride` or `dilation` is neither an int nor a tuple.
+        ValueError: If `in_channels`, `out_channels`, `kernel_size`, `stride` or `dilation` is less than 1.
+        ValueError: If `padding` is less than 0.
+        ValueError: If `padding` is `same` , `stride` is not equal to 1.
+        ValueError: The input parameters do not satisfy the convolution output formula.
+        ValueError: The `kernel_size` cannot exceed the size of the input feature map.
+        ValueError: The value of padding cannot cause the calculation area to exceed the input size.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, mint
+        >>> import numpy as np
+        >>> net = mint.nn.Conv1d(120, 240, 4, bias=False)
+        >>> x = Tensor(np.ones([1, 120, 1024]), mindspore.float32)
+        >>> output = net(x).shape
+        >>> print(output)
+        (1, 240, 1021)
+    """
+    @cell_attr_register
+    def __init__(self,
+                 in_channels,
+                 out_channels,
+                 kernel_size,
+                 stride=1,
+                 padding=0,
+                 dilation=1,
+                 groups=1,
+                 bias=True,
+                 padding_mode='zeros',
+                 dtype=None):
+        """Initialize Conv1d."""
+        kernel_size_ = once(kernel_size)
+        stride_ = once(stride)
+        padding_ = padding if isinstance(padding, str) else once(padding)
+        dilation_ = once(dilation)
+        if not dtype:
+            dtype = mstype.float32
+        super(Conv1d, self).__init__(in_channels, out_channels, kernel_size_, stride_, padding_, dilation_, False,
+                                     once(0), groups, bias, padding_mode, dtype)
+        if isinstance(padding, str) and padding_mode == "zeros":
+            self.conv1d = conv1d_padding_op
+        else:
+            self.conv1d = conv1d_ext_op
+
+
+    def construct(self, input):
+        if self.padding_mode != "zeros":
+            output = self.conv1d(pad_ext(input, self._reversed_padding, mode=self.padding_mode), self.weight,
+                                 self.bias, self.stride, (0,), self.dilation, self.groups)
+        else:
+            output = self.conv1d(input, self.weight, self.bias, self.stride, self.padding, self.dilation, self.groups)
+        return output
+
+
 class Conv2d(_Conv):
     r"""
     2D convolution layer.
@@ -182,18 +362,18 @@ class Conv2d(_Conv):
     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.
-        kernel_size (Union[int, tuple[int]]): Specifies the height and width of the 2D convolution kernel.
+        kernel_size (Union[int, tuple[int], list[int]]): Specifies the height and width of the 2D convolution kernel.
             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]], optional): The movement stride of the 2D convolution kernel.
+        stride (Union[int, tuple[int], list[int]], optional): 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`` .
-        padding (Union[int, tuple[int], str], optional): The number of padding
+        padding (Union[int, tuple[int], list[int], str], optional): The number of padding
             on the height and width directions of the input.
-            The data type is an integer or a tuple of two integers or string {`valid`, `same`}. If `padding` is an
-            integer, then `padding_{H}` and `padding_{W}` are all equal to `padding`.
+            The data type is an integer or a tuple of two integers or string {``"valid"``, ``"same"``}.
+            If `padding` is an integer, then `padding_{H}` and `padding_{W}` are all equal to `padding`.
             If `padding` is a tuple of 2 integers, then `padding_{H}` and `padding_{W}`
             is equal to `padding[0]` and `padding[1]` respectively.
             The value should be greater than or equal to 0. Default: ``0`` .
@@ -210,7 +390,7 @@ class Conv2d(_Conv):
 
         padding_mode (str, optional): Specifies the padding mode with a padding value of 0. It can be set to:
             ``"zeros"`` , ``"reflect"`` ``"circular"`` or ``"replicate"`` . Default: ``"zeros"`` .
-        dilation (Union[int, tuple[int]], optional): Specifies the dilation rate to use for dilated convolution.
+        dilation (Union[int, tuple[int], list[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
@@ -223,12 +403,15 @@ class Conv2d(_Conv):
         groups (int, optional): Splits filter into groups, `in_channels` and `out_channels` must be
             divisible by `groups`. If the groups is equal to `in_channels` and `out_channels`,
             this 2D convolution layer also can be called 2D depthwise convolution layer. Default: ``1`` .
+            The following restraints must be met:
 
-            - :math:`(C_{in} \text{ % } \text{groups} == 0)` , :math:`(C_{out} \text{ % } \text{groups} == 0)` ,
-              :math:`(C_{out} >= \text{groups})` , :math:`(\text{kernel_size[1]} = C_{in} / \text{groups})`
+            - :math:`(C_{in} \text{ % } \text{groups} == 0)`
+            - :math:`(C_{out} \text{ % } \text{groups} == 0)`
+            - :math:`(C_{out} >= \text{groups})`
+            - :math:`(\text{kernel_size[1]} = C_{in} / \text{groups})`
 
         bias (bool, optional): Whether the Conv2d layer has a bias parameter. Default: ``True`` .
-        dtype (mindspore.dtype, optional): Dtype of Parameters. Default: mstype.float32 .
+        dtype (:class:`mindspore.dtype`, optional): Dtype of Parameters. Default: ``None``, using ``mstype.float32``.
 
     Inputs:
         - **x** (Tensor) - Tensor of shape :math:`(N, C_{in}, H_{in}, W_{in})` \
@@ -255,18 +438,28 @@ class Conv2d(_Conv):
                 {\text{stride[1]}}} \right \rceil \\
             \end{array}
 
+        padding is int or tuple/list:
+
+        .. math::
+            \begin{array}{ll} \\
+                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
+                \text{dilation[1]} - 1 }{\text{stride[1]}} + 1} \right \rfloor \\
+            \end{array}
+
     Raises:
         ValueError: Args and size of the input feature map should satisfy the output formula to ensure that the size of
             the output feature map is positive; otherwise, an error will be reported.
         RuntimeError: On Ascend, due to the limitation of the L1 cache size of different NPU chip, if input size or
             kernel size is too large, it may trigger an error.
         TypeError: If `in_channels`, `out_channels` or `groups` is not an int.
-        TypeError: If `kernel_size`, `stride` or `dilation` is neither an int not a tuple.
+        TypeError: If `kernel_size`, `stride` or `dilation` is neither an int nor a tuple.
         ValueError: If `in_channels`, `out_channels`, `kernel_size`, `stride` or `dilation` is less than 1.
         ValueError: If `padding` is less than 0.
         ValueError: If `padding` is `same` , `stride` is not equal to 1.
         ValueError: The input parameters do not satisfy the convolution output formula.
-        ValueError: The KernelSize cannot exceed the size of the input feature map.
+        ValueError: The `kernel_size` cannot exceed the size of the input feature map.
         ValueError: The value of padding cannot cause the calculation area to exceed the input size.
 
     Supported Platforms:
@@ -280,7 +473,7 @@ class Conv2d(_Conv):
         >>> x = Tensor(np.ones([1, 120, 1024, 640]), mindspore.float32)
         >>> output = net(x).shape
         >>> print(output)
-        (1, 240, 1024, 640)
+        (1, 240, 1021, 637)
     """
     @cell_attr_register
     def __init__(self,
@@ -375,17 +568,17 @@ class Conv3d(_Conv):
     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.
-        kernel_size (Union[int, tuple[int]]): Specifies the height and width of the 3D convolution kernel.
+        kernel_size (Union[int, tuple[int], list[int]]): Specifies the height and width of the 3D convolution kernel.
             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]], optional): The movement stride of the 3D convolution kernel.
+        stride (Union[int, tuple[int], list[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 both height and width directions. A tuple of three integers represents the movement step size in the depth, height
-            and width directions respectively. Default: ``1`` .
-        padding (Union[int, tuple[int], str], optional): The number of padding
+            in both height and width directions. A tuple of three integers represents the movement step size in the
+            depth, height and width directions respectively. Default: ``1`` .
+        padding (Union[int, tuple[int], list[int], str], optional): The number of padding
             on the depth, height and width directions of the input.
-            The data type is an integer or string {`valid`, `same`} or a tuple of three integers.
+            The data type is an integer or string {``"valid"``, ``"same"``} or a tuple of three integers.
             The value should be greater than or equal to 0. Default: ``0`` .
 
             - ``"same"``: Pad the input around its edges so that the shape of input and output
@@ -400,11 +593,12 @@ class Conv3d(_Conv):
 
         padding_mode (str, optional): Specifies the padding mode with a padding value of 0. It can be set to:
             ``"zeros"`` , ``"reflect"`` ``"circular"`` or ``"replicate"`` . Default: ``"zeros"`` .
-        dilation (Union[int, tuple[int]], optional): Controlling the space between the kernel points. Default: ``1`` .
+        dilation (Union[int, tuple[int], list[int]], optional): Controlling the space between the kernel points.
+            Default: ``1`` .
         groups (int, optional): Splits filter into groups, `in_channels` and `out_channels` must be
             divisible by `groups`. If the groups is equal to `in_channels` and `out_channels`. Default: ``1`` .
         bias (bool, optional): Whether the Conv3d layer has a bias parameter. Default: ``True`` .
-        dtype (mindspore.dtype, optional): Dtype of Parameters. Default: ``mstype.float32`` .
+        dtype (:class:`mindspore.dtype`, optional): Dtype of Parameters. Default: ``None``, using ``mstype.float32``.
 
     Inputs:
         - **x** (Tensor) - Tensor of shape :math:`(N, C_{in}, D_{in}, H_{in}, W_{in})` \
@@ -437,7 +631,7 @@ class Conv3d(_Conv):
 
     Raises:
         TypeError: If `in_channels`, `out_channels` or `groups` is not an int.
-        TypeError: If `kernel_size`, `stride`, `padding` or `dilation` is neither an int not a tuple.
+        TypeError: If `kernel_size`, `stride`, `padding` or `dilation` is neither an int nor a tuple.
         ValueError: If `in_channels`, `out_channels`, `kernel_size`, `stride` or `dilation` is less than 1.
         ValueError: If `padding` is less than 0.
 

mindspore/mint/nn/layer/normalization.py

@@ -68,7 +68,7 @@ class _NormBase(Cell):
                                           requires_grad=False, name="running_mean")
             self.running_var = Parameter(Tensor(np.ones(num_features), dtype=self.dtype),
                                          requires_grad=False, name="running_var")
-            self.num_batches_tracked = Parameter(Tensor(0, dtype=ms.float32),
+            self.num_batches_tracked = Parameter(Tensor(0, dtype=ms.int64),
                                                  requires_grad=False, name="num_batches_tracked")
         else:
             self.running_mean = None
@@ -84,7 +84,7 @@ class _NormBase(Cell):
                 np.zeros(self.num_features), dtype=self.dtype)
             one_running_var = Tensor(
                 np.ones(self.num_features), dtype=self.dtype)
-            zero_num_batches_tracked = Tensor(0, dtype=ms.float32)
+            zero_num_batches_tracked = Tensor(0, dtype=ms.int64)
 
             ops.assign(self.running_mean, zero_running_mean)
             ops.assign(self.running_var, one_running_var)
@@ -136,11 +136,9 @@ class _BatchNorm(_NormBase):
 
         if self.training and self.track_running_stats:
             if self.num_batches_tracked is not None:
-                num_batches_tracked_one = Tensor(1, dtype=ms.float32)
-                ops.assign_add(self.num_batches_tracked,
-                               num_batches_tracked_one)
+                self.num_batches_tracked += 1
                 if self.momentum is None:
-                    exponential_average_factor = float(1.0 / self.num_batches_tracked)
+                    exponential_average_factor = 1.0 / float(self.num_batches_tracked)
                 else:
                     exponential_average_factor = self.momentum
 
@@ -250,8 +248,8 @@ class BatchNorm2d(_BatchNorm):
     elements of :math:`\gamma` are set to 1 and the elements of :math:`\beta` are set to 0.
 
     .. warning::
-        This API does not support Dynamic Rank.
-        This is an experimental API that is subject to change or deletion.
+        - This API does not support Dynamic Rank.
+        - This is an experimental API that is subject to change or deletion.
 
     Args:
         num_features (int): `C` from an expected input of shape :math:`(N, C, H, W)`.
@@ -264,7 +262,7 @@ class BatchNorm2d(_BatchNorm):
         track_running_stats (bool, optional): a boolean value that when set to ``True``, this
             cell tracks the running mean and variance, and when set to ``False``,
             this cell does not track such statistics. And this cell always uses batch statistics
-            in both training and eval modes. Default: ``True`` .
+            in both train and eval modes. Default: ``True`` .
         dtype (:class:`mindspore.dtype`, optional): Dtype of Parameters. Default: ``None`` .
 
     Inputs:
@@ -487,10 +485,12 @@ class SyncBatchNorm(_BatchNorm):
 
     Args:
         num_features (int): `C` from an expected input of size :math:`(N, C, +)`.
-        eps (float): :math:`\epsilon`, a value added to the denominator for numerical stability. Default: ``1e-5`` .
-        momentum (float): A floating hyperparameter of the momentum for the
+        eps (float, optional): :math:`\epsilon`, a value added to the denominator for numerical stability.
+            Default: ``1e-5`` .
+        momentum (float, optional): A floating hyperparameter of the momentum for the
             running_mean and running_var computation. Default: ``0.1`` .
-        affine (bool): A bool value. When set to ``True`` , :math:`\gamma` and :math:`\beta` can be learned.
+        affine (bool, optional): A bool value. When set to ``True`` , :math:`\gamma` and :math:`\beta` are learnable
+            parameters. When set to ``False`` , :math:`\gamma` and :math:`\beta` are unlearnable parameters.
             Default: ``True`` .
         track_running_stats (bool, optional): a boolean value that when set to ``True``, this
             cell tracks the running mean and variance, and when set to ``False``,
@@ -524,7 +524,7 @@ class SyncBatchNorm(_BatchNorm):
             Here, examples use msrun to pull multi-process distributed tasks across nodes with a single command
             line instruction.
             Please see the `Ascend tutorial
-            <https://www.mindspore.cn/docs/en/master/model_train/parallel/msrun_launcher.html>`_
+            <https://www.mindspore.cn/tutorials/en/master/parallel/msrun_launcher.html>`_
             for more details.
 
             This example should be run with multiple devices.
@@ -594,10 +594,9 @@ class SyncBatchNorm(_BatchNorm):
             exponential_average_factor = self.momentum
 
         if self.training and self.track_running_stats:
-            one_tensor = Tensor(1, dtype=ms.float32)
-            ops.assign_add(self.num_batches_tracked, one_tensor)
+            self.num_batches_tracked += 1
             if self.momentum is None:  # use cumulative moving average
-                exponential_average_factor = 1.0 / self.num_batches_tracked.value()
+                exponential_average_factor = 1.0 / float(self.num_batches_tracked.value())
             else:  # use exponential moving average
                 exponential_average_factor = self.momentum
 

mindspore/mint/nn/layer/padding.py

@@ -634,7 +634,7 @@ class ReplicationPad1d(ReplicationPadNd_):
         - **input** (Tensor) - 2D or 3D input Tensor with shape: :math:`(C, W_{in})` or :math:`(N, C, W_{in})`.
 
     Outputs:
-        Tensor, the tensor after padding.
+        The tensor after padding.
 
     Raises:
         TypeError: If `padding` is not an integer of a list or tuple of 2 integers.