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

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``
@@ -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.
@@ -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

@@ -226,7 +226,8 @@ class DropoutExt(Cell):
     Args:
         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): If set to ``True`` , will do this operation in-place. Default: ``False`` .
+        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.
@@ -347,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.
 
@@ -631,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`.
 
@@ -668,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``
@@ -770,6 +773,9 @@ class Linear(Cell):
     .. math::
         \text{outputs} = X * kernel + bias
 
+    .. warning::
+        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 the parameter `bias` is True).
@@ -808,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``
@@ -1565,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 "
@@ -1573,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/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

@@ -272,20 +272,20 @@ class Conv2d(_Conv):
 
         .. math::
             \begin{array}{ll} \\
-                H_{out} = \left \lceil{\frac{H_{in} - \text{dilation[0]} \times (\text{kernel_size[0]} - 1) }
-                {\text{stride[0]}}} \right \rceil \\
-                W_{out} = \left \lceil{\frac{W_{in} - \text{dilation[1]} \times (\text{kernel_size[1]} - 1) }
-                {\text{stride[1]}}} \right \rceil \\
+                H_{out} = \left \lfloor{\frac{H_{in} - \text{dilation[0]} \times (\text{kernel_size[0]} - 1) - 1}
+                {\text{stride[0]}}} \right \rfloor + 1 \\
+                W_{out} = \left \lfloor{\frac{W_{in} - \text{dilation[1]} \times (\text{kernel_size[1]} - 1) - 1}
+                {\text{stride[1]}}} \right \rfloor + 1 \\
             \end{array}
 
         pad_mode is ``'pad'``:
 
         .. 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 \\
+                H_{out} = \left \lfloor{\frac{H_{in} + padding[0] + padding[1] - \text{dilation[0]} \times
+                (\text{kernel_size[0]} - 1) - 1}{\text{stride[0]}}} \right \rfloor + 1 \\
+                W_{out} = \left \lfloor{\frac{W_{in} + padding[2] + padding[3] - \text{dilation[1]} \times
+                (\text{kernel_size[1]} - 1) - 1}{\text{stride[1]}}} \right \rfloor + 1 \\
             \end{array}
 
     Raises:
@@ -476,19 +476,25 @@ class Conv1d(_Conv):
         pad_mode is ``'same'``:
 
         .. math::
-            L_{out} = \left \lceil{\frac{L_{in}}{\text{stride}}} \right \rceil
+            \begin{array}{ll} \\
+                L_{out} = \left \lceil{\frac{L_{in}}{\text{stride}}} \right \rceil \\
+            \end{array}
 
         pad_mode is ``'valid'``:
 
         .. math::
-            L_{out} = \left \lceil{\frac{L_{in} - \text{dilation} \times (\text{kernel_size} - 1) }
-            {\text{stride}}} \right \rceil
+            \begin{array}{ll} \\
+                L_{out} = \left \lfloor{\frac{L_{in} - \text{dilation} \times (\text{kernel_size} - 1) - 1}
+                {\text{stride}}} \right \rfloor + 1 \\
+            \end{array}
 
         pad_mode is ``'pad'``:
 
         .. math::
-            L_{out} = \left \lfloor{\frac{L_{in} + 2 \times padding - (\text{kernel_size} - 1) \times
-            \text{dilation} - 1 }{\text{stride}} + 1} \right \rfloor
+            \begin{array}{ll} \\
+                L_{out} = \left \lfloor{\frac{L_{in} + 2 \times {padding} - \text{dilation} \times
+                (\text{kernel_size} - 1) - 1}{\text{stride}}} \right \rfloor + 1 \\
+            \end{array}
 
     Raises:
         TypeError: If `in_channels`, `out_channels`, `kernel_size`, `stride`, `padding` or `dilation` is not an int.
@@ -727,24 +733,24 @@ class Conv3d(_Conv):
 
         .. math::
             \begin{array}{ll} \\
-                D_{out} = \left \lfloor{\frac{D_{in} - \text{dilation[0]} \times (\text{kernel_size[0]} - 1) }
-                {\text{stride[0]}} + 1} \right \rfloor \\
-                H_{out} = \left \lfloor{\frac{H_{in} - \text{dilation[1]} \times (\text{kernel_size[1]} - 1) }
-                {\text{stride[1]}} + 1} \right \rfloor \\
-                W_{out} = \left \lfloor{\frac{W_{in} - \text{dilation[2]} \times (\text{kernel_size[2]} - 1) }
-                {\text{stride[2]}} + 1} \right \rfloor \\
+                D_{out} = \left \lfloor{\frac{D_{in} - \text{dilation[0]} \times (\text{kernel_size[0]} - 1) - 1}
+                {\text{stride[0]}}} \right \rfloor + 1 \\
+                H_{out} = \left \lfloor{\frac{H_{in} - \text{dilation[1]} \times (\text{kernel_size[1]} - 1) - 1}
+                {\text{stride[1]}}} \right \rfloor + 1 \\
+                W_{out} = \left \lfloor{\frac{W_{in} - \text{dilation[2]} \times (\text{kernel_size[2]} - 1) - 1}
+                {\text{stride[2]}}} \right \rfloor + 1 \\
             \end{array}
 
         pad_mode is ``'pad'`` :
 
         .. math::
             \begin{array}{ll} \\
-                D_{out} = \left \lfloor{\frac{D_{in} + padding[0] + padding[1] - (\text{dilation[0]} - 1) \times
-                \text{kernel_size[0]} - 1 }{\text{stride[0]}} + 1} \right \rfloor \\
-                H_{out} = \left \lfloor{\frac{H_{in} + padding[2] + padding[3] - (\text{dilation[1]} - 1) \times
-                \text{kernel_size[1]} - 1 }{\text{stride[1]}} + 1} \right \rfloor \\
-                W_{out} = \left \lfloor{\frac{W_{in} + padding[4] + padding[5] - (\text{dilation[2]} - 1) \times
-                \text{kernel_size[2]} - 1 }{\text{stride[2]}} + 1} \right \rfloor \\
+                D_{out} = \left \lfloor{\frac{D_{in} + padding[0] + padding[1] - \text{dilation[0]} \times
+                (\text{kernel_size[0]} - 1) - 1}{\text{stride[0]}}} \right \rfloor + 1 \\
+                H_{out} = \left \lfloor{\frac{H_{in} + padding[2] + padding[3] - \text{dilation[1]} \times
+                (\text{kernel_size[1]} - 1) - 1}{\text{stride[1]}}} \right \rfloor + 1 \\
+                W_{out} = \left \lfloor{\frac{W_{in} + padding[4] + padding[5] - \text{dilation[2]} \times
+                (\text{kernel_size[2]} - 1) - 1}{\text{stride[2]}}} \right \rfloor + 1 \\
             \end{array}
 
     Raises:
@@ -856,11 +862,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 +879,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 +899,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 +917,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 +991,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

@@ -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,