mindspore 2.4.10__cp310-cp310-win_amd64.whl → 2.6.0rc1__cp310-cp310-win_amd64.whl

mindspore/nn/dynamic_lr.py

@@ -224,7 +224,8 @@ def inverse_decay_lr(learning_rate, decay_rate, total_step, step_per_epoch, deca
         total_step (int): The total number of steps.
         step_per_epoch (int): The number of steps in per epoch.
         decay_epoch (int): Number of epochs to decay over.
-        is_stair (bool): If true, learning rate is decayed once every `decay_epoch` times. Default: ``False`` .
+        is_stair (bool): If true, learning rate is decayed once every `decay_epoch` times. If False, the learning rate
+            decays for every epoch. Default: ``False`` .
 
     Returns:
         list[float]. The size of list is `total_step`.

mindspore/nn/layer/activation.py

@@ -82,7 +82,7 @@ class CELU(Cell):
         :align: center
 
     Args:
-        alpha (float): The :math:`\alpha` value for the Celu formulation. Default: ``1.0`` .
+        alpha (float, optional): The :math:`\alpha` value for the Celu formulation. Default: ``1.0`` .
 
     Inputs:
         - **x** (Tensor) - The input of CELU. The required dtype is float16 or float32.
@@ -136,20 +136,22 @@ class Softmin(Cell):
     where :math:`x_{i}` is the :math:`i`-th slice in the given dimension of the input Tensor.
 
     Args:
-        axis (Union[int, tuple[int]]): The axis to apply Softmin operation, if the dimension of input `x` is x.ndim,
-            the range of axis is `[-x.ndim, x.ndim)`. -1 means the last dimension. Default: ``-1`` .
+        axis (Union[int, tuple[int]], optional): The axis to apply Softmin operation,
+            if the dimension of input `x` is x.ndim,
+            the range of axis is :math:`[-x.ndim, x.ndim)`. -1 means the last dimension.
+            Default: ``-1`` . In CPU environment, `axis` only supports int type.
 
     Inputs:
         - **x** (Tensor) - Tensor for computing Softmin functions with data type of float16 or float32.
 
     Outputs:
-        Tensor, which has the same type and shape as `x` with values in the range [0,1].
+        Tensor, which has the same type and shape as `x` with values in the range :math:`[0, 1]`.
 
     Raises:
         TypeError: If `axis` is neither an int nor a tuple.
         TypeError: If dtype of `x` is neither float16 nor float32.
         ValueError: If `axis` is a tuple whose length is less than 1.
-        ValueError: If `axis` is a tuple whose elements are not all in the range [-x.ndim, x.ndim).
+        ValueError: If `axis` is a tuple whose elements are not all in the range :math:`[-x.ndim, x.ndim)`.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -179,7 +181,7 @@ class Softmax2d(Cell):
     r"""
     Softmax function applied to 2D features data.
 
-    Applies `Softmax` to each location :math:`(c, h, w)` with an input Tensor of shape :math:`(C, H, W)` .
+    Applies `Softmax` to each location with an input Tensor of shape :math:`(C, H, W)` .
 
     Inputs:
         - **x** (Tensor) - Tensor of shape :math:`(N, C_{in}, H_{in}, W_{in})` or :math:`(C_{in}, H_{in}, W_{in})`.
@@ -957,7 +959,7 @@ class GELU(Cell):
         :align: center
 
     Args:
-        approximate (bool): Whether to enable approximation. Default: ``True`` .
+        approximate (bool, optional): Whether to enable approximation. Default: ``True`` .
 
             If `approximate` is ``True``, The gaussian error linear activation is:
 
@@ -965,7 +967,14 @@ class GELU(Cell):
 
             else, it is:
 
-            :math:`x * P(X <= x) = 0.5 * x * (1 + erf(x / \sqrt(2)))`, where P(X) ~ N(0, 1).
+            :math:`x * P(X <= x) = 0.5 * x * (1 + erf(x / \sqrt(2)))`, where :math:`P(X) ~ N(0, 1)`.
+
+    Note:
+        - when calculating the input gradient of GELU with an input value of infinity, there are differences
+          in the output of the backward between ``Ascend`` and ``GPU``.
+        - when x is -inf, the computation result of ``Ascend`` is 0, and the computation result of ``GPU`` is Nan.
+        - when x is inf, the computation result of ``Ascend`` is dy, and the computation result of ``GPU`` is Nan.
+        - In mathematical terms, the result of Ascend has higher precision.
 
     Inputs:
         - **x** (Tensor) - The input of GELU with data type of float16, float32, or float64.
@@ -974,13 +983,6 @@ class GELU(Cell):
     Outputs:
         Tensor, with the same type and shape as the `x`.
 
-    Note:
-        when calculating the input gradient of GELU with an input value of infinity, there are differences
-        in the output of the backward between ``Ascend`` and ``GPU``.
-        when x is -inf, the computation result of ``Ascend`` is 0, and the computation result of ``GPU`` is Nan.
-        when x is inf, the computation result of ``Ascend`` is dy, and the computation result of ``GPU`` is Nan.
-        In mathematical terms, the result of Ascend has higher precision.
-
     Raises:
         TypeError: If dtype of `x` is not one of float16, float32, or float64.
 
@@ -1165,7 +1167,7 @@ class PReLU(Cell):
 
     where :math:`x_i` is an element of an channel of the input.
 
-    Here :math:`w` is a learnable parameter with a default initial value 0.25.
+    Here :math:`w` is a learnable parameter with a default initial value ``0.25``.
     Parameter :math:`w` has dimensionality of the argument channel. If called without argument
     channel, a single parameter :math:`w` will be shared across all channels.
 
@@ -1175,9 +1177,9 @@ class PReLU(Cell):
         :align: center
 
     Args:
-        channel (int): The elements number of parameter :math:`w`.
-          It could be an int, and the value is 1 or the channels number of input tensor `x`. Default: ``1`` .
-        w (Union[float, list, Tensor]): The initial value of parameter. It could be a float, a float list or
+        channel (int, optional): The elements number of parameter :math:`w`.
+          It could be an int, and the value is ``1`` or the channels number of input tensor `x`. Default: ``1`` .
+        w (Union[float, list, Tensor], optional): The initial value of parameter. It could be a float, a float list or
           a tensor has the same dtype as the input tensor `x`. Default: ``0.25`` .
 
     Inputs:
@@ -1189,7 +1191,7 @@ class PReLU(Cell):
 
     Raises:
         TypeError: If `channel` is not an int.
-        TypeError: If `w` is not one of a float, a float list, a float Tensor.
+        TypeError: If `w` is not one of a float, a list[float], a Tensor[float].
         TypeError: If dtype of `x` is neither float16 nor float32.
         ValueError: If the `x` is a 0-D or 1-D Tensor on Ascend.
         ValueError: If `channel` is less than 1.
@@ -1273,9 +1275,9 @@ class PReLUExt(Cell):
         no channel dim and the number of channels = 1.
 
     Args:
-        num_parameters (int): number of `w` to learn. Although it takes an int as input,
+        num_parameters (int, optional): number of `w` to learn. Although it takes an int as input,
             there is only two legitimate values: 1, or the number of channels at Tensor `input`. Default: ``1`` .
-        init (float): the initial value of `w`. Default: ``0.25`` .
+        init (float, optional): the initial value of `w`. Default: ``0.25`` .
         dtype (mindspore.dtype, optional): the type of `w`. Default: ``None`` . Supported data type
             is {float16, float32, bfloat16}.
 
@@ -1320,7 +1322,7 @@ class HSwish(Cell):
     Hard swish is defined as:
 
     .. math::
-        \text{Hardswish}(input) =
+        \text{HSwish}(input) =
         \begin{cases}
         0, & \text{ if } input \leq -3, \\
         input, & \text{ if } input \geq +3, \\
@@ -1372,7 +1374,7 @@ class HSigmoid(Cell):
     Hard Sigmoid is defined as:
 
     .. math::
-        \text{Hardsigmoid}(input) =
+        \text{HSigmoid}(input) =
         \begin{cases}
         0, & \text{ if } input \leq -3, \\
         1, & \text{ if } input \geq +3, \\
@@ -1578,7 +1580,7 @@ class HShrink(Cell):
     The formula is defined as follows:
 
     .. math::
-        \text{HardShrink}(x) =
+        \text{HShrink}(x) =
         \begin{cases}
         x, & \text{ if } x > \lambda \\
         x, & \text{ if } x < -\lambda \\
@@ -1728,7 +1730,7 @@ class GLU(Cell):
     Here :math:`\sigma` is the sigmoid function, and :math:`\otimes` is the Hadamard product.
 
     Args:
-        axis (int): the axis to split the input. Default: ``-1`` , the last axis in `x`.
+        axis (int, optional): the axis to split the input. Default: ``-1`` , the last axis in `x`.
 
     Inputs:
         - **x** (Tensor) - :math:`(\ast_1, N, \ast_2)` where `*` means, any number of additional dimensions.
@@ -1811,7 +1813,7 @@ def get_activation(name, prim_name=None):
         >>> import mindspore.nn as nn
         >>> sigmoid = nn.get_activation('sigmoid')
         >>> print(sigmoid)
-        Sigmoid<>
+        Sigmoid()
     """
     msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
     if name is None:

mindspore/nn/layer/basic.py

@@ -25,10 +25,9 @@ from mindspore.ops.composite.multitype_ops import _constexpr_utils as const_util
 from mindspore.common.seed import _get_graph_seed
 from mindspore.common.tensor import Tensor
 from mindspore.common.initializer import initializer, HeUniform, Uniform
+from mindspore import ops
 from mindspore.ops import operations as P
 from mindspore.ops import functional as F
-from mindspore.ops.function.nn_func import interpolate_ext
-from mindspore.ops.auto_generate import unfold_ext
 from mindspore.ops.operations import _inner_ops as inner
 from mindspore.ops.primitive import constexpr, Primitive, _primexpr
 from mindspore.common.parameter import Parameter
@@ -37,7 +36,6 @@ from mindspore import _checkparam as Validator
 from mindspore.nn.cell import Cell
 from mindspore.nn.layer.activation import get_activation
 from mindspore.common._decorator import deprecated
-from mindspore.ops.auto_generate import dropout_ext_op, fold_ext
 from mindspore.common.generator import default_generator
 
 __all__ = ['Dropout', 'Flatten', 'Dense', 'Linear', 'ClipByNorm', 'Norm', 'OneHot', 'Pad', 'Unfold', 'Tril', 'Triu',
@@ -140,6 +138,7 @@ class Dropout(Cell):
 
     Inputs:
         - **x** (Tensor) - The input of Dropout with data type of float16 or float32.
+          The shape of `x` cannot be less than 1.
 
     Outputs:
         Tensor, output tensor with the same shape as the `x`.
@@ -225,8 +224,10 @@ class DropoutExt(Cell):
         - Parameter `p` means the probability of the element of the input tensor to be zeroed.
 
     Args:
-        p (float): The dropout rate of input neurons, E.g. `p` =0.9, dropping out 90% of input neurons.
+        p (float, optional): The dropout rate of input neurons, E.g. `p` =0.9, dropping out 90% of input neurons.
             Default: ``0.5`` .
+        inplace (bool, optional): Whether to enable the operation in-place.
+            If set to ``True`` , will do this operation in-place. Default: ``False`` .
 
     Inputs:
         - **x** (Tensor) - The input of Dropout.
@@ -253,18 +254,23 @@ class DropoutExt(Cell):
         (2, 2, 3)
     """
 
-    def __init__(self, p=0.5):
+    def __init__(self, p=0.5, inplace=False):
         """Initialize DropoutExt."""
         super(DropoutExt, self).__init__()
         self.p = p
-        self.generator_step = Tensor(1, mstype.int64)
+        self.inplace = inplace
+        self.generator_step = Tensor(12, mstype.int64)
 
     def construct(self, x):
         if not self.training or self.p == 0:
             return x
 
         seed, offset = default_generator._step(self.generator_step)  # pylint: disable=protected-access
-        out, _ = dropout_ext_op(x, self.p, seed, offset)
+        out, _ = ops.auto_generate.dropout_ext_op(x, self.p, seed, offset)
+
+        if self.inplace:
+            x.copy_(out)
+            return x
         return out
 
 
@@ -342,8 +348,8 @@ class Dropout2d(Cell):
 
     For example, the :math:`j\_th` channel of the :math:`i\_th` sample in the batched input is a to-be-processed
     `2D` tensor input[i,j].
-    Each channel will be zeroed out independently on every forward call with probability `p` using samples
-    from a Bernoulli distribution.
+    At each forward propagation,
+    each channel will be independently determined to be set to zero with probability `p`.
 
     `Dropout2d` can improve the independence between channel feature maps.
 
@@ -479,6 +485,9 @@ class UpsampleExt(Cell):
     r"""
     For details, please refer to :func:`mindspore.mint.nn.functional.interpolate`.
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     Supported Platforms:
         ``Ascend``
 
@@ -511,8 +520,8 @@ class UpsampleExt(Cell):
         self.recompute_scale_factor = recompute_scale_factor
 
     def construct(self, input):
-        out = interpolate_ext(input, self.size, self.scale_factor, self.mode,
-                              self.align_corners, self.recompute_scale_factor)
+        out = ops.function.nn_func.interpolate_ext(input, self.size, self.scale_factor, self.mode,
+                                                   self.align_corners, self.recompute_scale_factor)
         return out
 
 
@@ -623,25 +632,27 @@ class Dense(Cell):
     where :math:`X` is the input tensors, :math:`\text{activation}` is the activation function passed as the activation
     argument (if passed in), :math:`\text{kernel}` is a weight matrix with the same
     data type as the :math:`X` created by the layer, and :math:`\text{bias}` is a bias vector
-    with the same data type as the :math:`X` created by the layer (only if has_bias is True).
+    with the same data type as the :math:`X` created by the layer (only if `has_bias` is ``True``).
 
     .. warning::
-        In PYNATIVE mode, if `bias` is ``False`` , the `x` cannot be greater than 6D.
+        On the Ascend platform, if `bias` is ``False`` , the `x` cannot be greater than 6D in PYNATIVE or KBK mode.
 
     Args:
         in_channels (int): The number of channels in the input space.
         out_channels (int): The number of channels in the output space.
-        weight_init (Union[Tensor, str, Initializer, numbers.Number]): The trainable weight_init parameter. The dtype
-            is same as `x`. The values of str refer to the function `initializer`. Default: ``None`` ,
+        weight_init (Union[Tensor, str, Initializer, numbers.Number], optional): The trainable weight_init parameter.
+            The dtype is same as `x`. The values of str refer to the function `initializer`. Default: ``None`` ,
             weight will be initialized using HeUniform.
-        bias_init (Union[Tensor, str, Initializer, numbers.Number]): The trainable bias_init parameter. The dtype is
-            same as `x`. The values of str refer to the function `initializer`. Default: ``None`` ,
+        bias_init (Union[Tensor, str, Initializer, numbers.Number], optional): The trainable bias_init parameter.
+            The dtype is same as `x`. The values of str refer to the function `initializer`. Default: ``None`` ,
             bias will be initialized using Uniform.
-        has_bias (bool): Specifies whether the layer uses a bias vector :math:`\text{bias}`. Default: ``True``.
-        activation (Union[str, Cell, Primitive, None]): activate function applied to the output of the fully connected
+        has_bias (bool, optional): Specifies whether the layer uses a bias vector :math:`\text{bias}`.
+            Default: ``True``.
+        activation (Union[str, Cell, Primitive, None], optional): activate function applied to
+            the output of the fully connected
             layer. Both activation name, e.g. 'relu', and mindspore activation function, e.g. mindspore.ops.ReLU(),
             are supported. Default: ``None`` .
-        dtype (:class:`mindspore.dtype`): Data type of Parameter. Default: ``mstype.float32`` .
+        dtype (:class:`mindspore.dtype`, optional): Data type of Parameter. Default: ``mstype.float32`` .
             When `weight_init` is Tensor, Parameter has the same data type as `weight_init` ,
             in other cases, Parameter has the same data type as `dtype`, the same goes for `bias_init`.
 
@@ -660,7 +671,7 @@ class Dense(Cell):
                     is not equal to `out_channels` or shape[1] of `weight_init` is not equal to `in_channels`.
         ValueError: If length of shape of `bias_init` is not equal to 1
                     or shape[0] of `bias_init` is not equal to `out_channels`.
-        RuntimeError: If `bias` is ``False`` and `x` is greater than 6D in PYNATIVE mode.
+        RuntimeError: On the Ascend platform, if `bias` is ``False`` and `x` is greater than 6D in PYNATIVE or KBK mode.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -763,23 +774,28 @@ class Linear(Cell):
         \text{outputs} = X * kernel + bias
 
     .. warning::
-        In PYNATIVE mode, if `bias` is ``False`` , the `x` cannot be greater than 6D.
+        On the Ascend platform, if `bias` is ``False`` , the `x` cannot be greater than 6D in PYNATIVE or KBK mode.
 
     where :math:`X` is the input tensors, :math:`\text{kernel}` is a weight matrix with the same
     data type as the :math:`X` created by the layer, and :math:`\text{bias}` is a bias vector
-    with the same data type as the :math:`X` created by the layer (only if has_bias is True).
+    with the same data type as the :math:`X` created by the layer (only if the parameter `bias` is True).
+
+    .. warning::
+        In PyNative mode, if `bias` is ``False`` , the `x` cannot be greater than 6D.
 
     Args:
         in_features (int): The number of features in the input space.
         out_features (int): The number of features in the output space.
-        bias (bool): Specifies whether the layer uses a bias vector :math:`\text{bias}`. Default: ``True``.
-        weight_init (Union[Tensor, str, Initializer, numbers.Number]): The trainable weight_init parameter. The dtype
+        bias (bool, optional): Specifies whether the layer uses a bias vector :math:`\text{bias}`. Default: ``True``.
+        weight_init (Union[Tensor, str, Initializer, numbers.Number], optional):
+            The trainable weight_init parameter. The dtype
             is same as `x`. The values of str refer to the function `initializer`. Default: ``None`` ,
             weight will be initialized using HeUniform.
-        bias_init (Union[Tensor, str, Initializer, numbers.Number]): The trainable bias_init parameter. The dtype is
+        bias_init (Union[Tensor, str, Initializer, numbers.Number], optional):
+            The trainable bias_init parameter. The dtype is
             same as `x`. The values of str refer to the function `initializer`. Default: ``None`` ,
             bias will be initialized using Uniform.
-        dtype (:class:`mindspore.dtype`): Data type of Parameter. Default: ``None`` .
+        dtype (:class:`mindspore.dtype`, optional): Data type of Parameter. Default: ``None`` .
             If `dtype` is ``None`` , `dtype` is set to ``mstype.float32`` when initializing the method.
             When `weight_init` is Tensor, Parameter has the same data type as `weight_init` ,
             in other cases, Parameter has the same data type as `dtype`, the same goes for `bias_init`.
@@ -798,7 +814,7 @@ class Linear(Cell):
                     is not equal to `out_features` or shape[1] of `weight_init` is not equal to `in_features`.
         ValueError: If length of shape of `bias_init` is not equal to 1
                     or shape[0] of `bias_init` is not equal to `out_features`.
-        RuntimeError: If `bias` is ``False`` and `x` is greater than 6D in PYNATIVE mode.
+        RuntimeError: On the Ascend platform, if `bias` is ``False`` and `x` is greater than 6D in PYNATIVE or KBK mode.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -806,10 +822,10 @@ class Linear(Cell):
     Examples:
         >>> import mindspore
         >>> from mindspore import Tensor
-        >>> from mindspore import nn
+        >>> from mindspore import mint
         >>> import numpy as np
         >>> x = Tensor(np.array([[180, 234, 154], [244, 48, 247]]), mindspore.float32)
-        >>> net = nn.mint.nn.Linear(3, 4)
+        >>> net = mint.nn.Linear(3, 4)
         >>> output = net(x)
         >>> print(output.shape)
         (2, 4)
@@ -1285,7 +1301,7 @@ class UnfoldExt(Cell):
         self.stride = stride
 
     def construct(self, input):
-        return unfold_ext(input, self.kernel_size, self.dilation, self.padding, self.stride)
+        return ops.auto_generate.unfold_ext(input, self.kernel_size, self.dilation, self.padding, self.stride)
 
 
 class Fold(Cell):
@@ -1316,8 +1332,8 @@ class Fold(Cell):
         self.stride = stride
 
     def construct(self, input):
-        return fold_ext(input, self.output_size, self.kernel_size,
-                        self.dilation, self.padding, self.stride)
+        return ops.auto_generate.fold_ext(input, self.output_size, self.kernel_size,
+                                          self.dilation, self.padding, self.stride)
 
 
 @_primexpr
@@ -1555,7 +1571,7 @@ class Roll(Cell):
         else:
             if not isinstance(self.axis, (list, tuple)):
                 self.op_list.append(
-                    (P.Roll(shift=self.shift, axis=0), self.axis))
+                    (P.Roll(shifts=self.shift, dims=0), self.axis))
             else:
                 if len(self.shift) != len(self.axis):
                     raise ValueError(f"For '{self.cls_name}', the shape of 'shift' and the shape of 'axis' must be "
@@ -1563,7 +1579,7 @@ class Roll(Cell):
                                      f"and the length of 'axis' {len(self.axis)}.")
                 for idx, _ in enumerate(self.axis):
                     self.op_list.append(
-                        (P.Roll(shift=self.shift[idx], axis=0), self.axis[idx]))
+                        (P.Roll(shifts=self.shift[idx], dims=0), self.axis[idx]))
 
     def construct(self, input_x):
         dim = len(self.shape_op(input_x))

mindspore/nn/layer/channel_shuffle.py

@@ -21,9 +21,9 @@ __all__ = ['ChannelShuffle']
 
 class ChannelShuffle(Cell):
     r"""
-    Divide the channels of Tensor whose shape is :math:`(*, C, H, W)` into :math:`g` groups to obtain a Tensor with
-    shape :math:`(*, C \frac g, g, H, W)`, and transpose along the corresponding axis of :math:`C`,
-    :math:`\frac{g}{}` and :math:`g` to restore Tensor to the original shape.
+    Divide the channels in a tensor of shape :math:`(*, C, H, W)` into :math:`g` group and
+    rearrange them as :math:`(*, \frac{C}{g}, g, H*W)`, while retaining the original tensor
+    shape in the final output.
 
     Args:
         groups (int): Number of groups to divide channels in, must be greater than 0.

mindspore/nn/layer/container.py

@@ -648,7 +648,7 @@ class CellDict(_CellDictBase, Cell):
         Remove key from the CellDict and return its cell.
 
         Args:
-            key (string): key to pop from the CellDict.
+            key (str): key to pop from the CellDict.
 
         Raises:
             KeyError: If `key` not exist in CellDict when attempt to access cell.

mindspore/nn/layer/conv.py

@@ -856,11 +856,12 @@ class Conv3dTranspose(_Conv):
     where :math:`N` is batch size, :math:`C_{in}` is a number of
     channels, :math:`D_{in}, H_{in}, W_{in}` are the depth, height and width of the feature layer respectively.
 
-    When Conv3d and Conv3dTranspose are initialized with the same parameters, and `pad_mode` is set to 'pad',
+    When Conv3d and Conv3dTranspose are initialized with the same parameters, and `pad_mode` is set to ``'pad'``,
     :math:`dilation * (kernel\_size - 1) - padding` amount of zero will be paded to the depth, height and width
     directions of the input, they are inverses of each other in regard to the input and output shapes in this case.
-    However, when `stride` > 1, Conv2d maps multiple input shapes to the same output shape. Deconvolutional network
-    can refer to `Deconvolutional Networks <https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf>`_.
+    However, when `stride` > 1, Conv2d maps multiple input shapes to the same output shape.
+    For the detailed information of Deconvolutional network,
+    refer to `Deconvolutional Networks <https://www.matthewzeiler.com/mattzeiler/deconvolutionalnetworks.pdf>`_.
 
     Note:
         For Atlas A2 training series products, `output_padding` is currently not supported.
@@ -872,7 +873,7 @@ class Conv3dTranspose(_Conv):
             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.
+        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`` .
@@ -892,13 +893,15 @@ class Conv3dTranspose(_Conv):
               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.
+        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]]): Specifies the dilation rate to use for dilated convolution. The data type
+        dilation (Union[int, tuple[int]], optional): Specifies the dilation rate to use for dilated convolution.
+            The data type
             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.
@@ -908,33 +911,35 @@ class Conv3dTranspose(_Conv):
             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): Splits filter into groups, `in_channels` and `out_channels` must be
+        group (int, optional): Splits filter into groups, `in_channels` and `out_channels` must be
             divisible by `group`. Default: ``1`` .
-        output_padding (Union(int, tuple[int])): The number of padding on the depth, height and width directions of
+        output_padding (Union(int, tuple[int]), optional): The number of padding on the depth,
+            height and width directions of
             the output. The data type is an integer or a tuple of three integers. If `output_padding` is an integer,
             then the depth, height, and width dimension padding are all equal to `output_padding`.
             If `output_padding` is a tuple of three integers, then the depth, height, and width padding is equal to
             `output_padding[0]`, `output_padding[1]` and `output_padding[2]` 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`` .
-        weight_init (Union[Tensor, str, Initializer, numbers.Number]): Initialization method of weight parameter.
+        has_bias (bool, optional): Whether the Conv3dTranspose 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: ``None`` ,
             weight will be initialized using HeUniform.
-        bias_init (Union[Tensor, str, Initializer, numbers.Number]): Initialization method of bias parameter.
+        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: ``None`` , bias will be initialized using Uniform.
-        data_format (str): The optional value for data format. Currently only support ``'NCDHW'`` .
+        data_format (str, optional): The optional value for data format. Currently only support ``'NCDHW'`` .
             Default: ``'NCDHW'`` .
-        dtype (:class:`mindspore.dtype`): Dtype of Parameters. Default: ``mstype.float32`` .
+        dtype (:class:`mindspore.dtype`, optional): 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 dtype only support float16 and float32.
+          Currently input data dtype only supports float16 and float32.
 
     Outputs:
         Tensor, the shape is :math:`(N, C_{out}, D_{out}, H_{out}, W_{out})`.
@@ -980,10 +985,10 @@ class Conv3dTranspose(_Conv):
         TypeError: If input data type is not float16 or float32.
         ValueError: If `in_channels`, `out_channels`, `kernel_size`, `stride` or `dilation` is less than 1.
         ValueError: If `padding` is less than 0.
-        ValueError: If `pad_mode` is not one of 'same', 'valid', 'pad'.
+        ValueError: If `pad_mode` is not one of ``'same'``, ``'valid'``, ``'pad'``.
         ValueError: If `padding` is a tuple whose length is not equal to 6.
-        ValueError: If `pad_mode` is not equal to 'pad' and `padding` is not equal to (0, 0, 0, 0, 0, 0).
-        ValueError: If `data_format` is not 'NCDHW'.
+        ValueError: If `pad_mode` is not equal to ``'pad'`` and `padding` is not equal to (0, 0, 0, 0, 0, 0).
+        ValueError: If `data_format` is not ``'NCDHW'``.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``

mindspore/nn/layer/embedding.py

@@ -179,7 +179,7 @@ class EmbeddingExt(Cell):
             `[-num_embeddings, num_embeddings)` if it's not ``None``. Default ``None``.
         max_norm (float, optional): If the value is not None, firstly get the p-norm result of the embedding
             vector specified by `input` where p is specified by `norm_type`; if the result is larger then `max_norm`,
-            update the embedding vector` with :math:`\frac{max\_norm}{result+1e^{-7}}`. Default ``None``.
+            update the embedding vector with :math:`\frac{max\_norm}{result+1e^{-7}}`. Default ``None``.
         norm_type (float, optional): Indicated the value of p in p-norm. Default ``2.0``.
         scale_grad_by_freq (bool, optional): If ``True`` the gradients will be scaled by the inverse of frequency
             of the index in `input`. Default ``False``.
@@ -193,8 +193,8 @@ class EmbeddingExt(Cell):
             not None. Default: ``None``.
 
     Variables:
-        weight (Parameter): The learnable weights of this module of shape (num_embeddings, embedding_dim), which
-            initialized from :math:`{N}(\text{sigma=1.0}, \text{mean=0.0})` or `_weight` .
+        - **weight** (Parameter) - The learnable weights of this module of shape (num_embeddings, embedding_dim), which
+          initialized from :math:`{N}(\text{sigma=1.0}, \text{mean=0.0})` or `_weight` .
 
     Inputs:
         - **input** (Tensor) - The indices used to lookup in the embedding vector. The data type must be
@@ -220,18 +220,19 @@ class EmbeddingExt(Cell):
         >>> import mindspore
         >>> import numpy as np
         >>> from mindspore import Tensor, nn
+        >>> mindspore.set_seed(0)
         >>> input = Tensor([[1, 0, 1, 1], [0, 0, 1, 0]])
         >>> embedding = nn.EmbeddingExt(num_embeddings=10, embedding_dim=3)
         >>> output = embedding(input)
         >>> print(output)
-        [[[-0.0024154  -0.01203444  0.00811537]
-          [ 0.00233847 -0.00596091  0.00536799]
-          [-0.0024154  -0.01203444  0.00811537]
-          [-0.0024154  -0.01203444  0.00811537]]
-         [[ 0.00233847 -0.00596091  0.00536799]
-          [ 0.00233847 -0.00596091  0.00536799]
-          [-0.0024154  -0.01203444  0.00811537]
-          [ 0.00233847 -0.00596091  0.00536799]]]
+        [[[ 0.6712398   0.5407775   1.0317237]
+          [-0.49091062 -0.42302188 -1.4807187]
+          [ 0.6712398   0.5407775   1.0317237]
+          [ 0.0024154   0.5407775   1.0317237]]
+         [[-0.49091062 -0.42302188 -1.4807187]
+          [-0.49091062 -0.42302188 -1.4807187]
+          [ 0.6712398   0.5407775   1.0317237]
+          [-0.49091062 -0.42302188 -1.4807187]]]
     """
 
     def __init__(self, num_embeddings, embedding_dim, padding_idx=None, max_norm=None, norm_type=2.0,