mindspore 2.4.10__cp39-cp39-manylinux1_x86_64.whl → 2.5.0__cp39-cp39-manylinux1_x86_64.whl

mindspore/nn/cell.py

@@ -60,7 +60,7 @@ class Cell(Cell_):
     .. note::
         Cell is the inference mode by default. For a class that inherits a Cell,
         if the training and inference have different structures, the subclass performs the inference branch by default.
-        To set the training mode, refer to `mindspore.nn.Cell.set_train` .
+        To set the training mode, refer to :func:`mindspore.nn.Cell.set_train` .
 
     .. warning::
         In the subclass of Cell, it's not allowed to define a method named 'cast' and not allowed to define an attribute
@@ -105,7 +105,8 @@ class Cell(Cell_):
                    '_func_graph_flags', '_parameter_layout_dict', '_params_list', '_phase', '_bprop_debug',
                    '_forward_pre_hook', '_forward_hook', '_backward_pre_hook', '_backward_hook',
                    '_cell_backward_pre_hook', '_cell_backward_hook', '_is_run', '_param_prefix',
-                   '_attr_synced', 'pynative', 'requires_grad', 'cell_type']
+                   '_attr_synced', 'pynative', 'requires_grad', 'cell_type',
+                   '_parameters_forward_hook', '_parameters_backward_hook']
     total_instance_count = 0
 
     def __init__(self, auto_prefix=True, flags=None):
@@ -143,6 +144,8 @@ class Cell(Cell_):
 
         # call gc to release GE session resources used by non-used cell objects
         if os.getenv('GC_COLLECT_IN_CELL') == '1':
+            logger.warning("The convenient environment 'GC_COLLECT_IN_CELL' is deprecated from version 2.5 "
+                           "and will be removed in a future version.")
             gc.collect()
 
         if flags:
@@ -158,6 +161,10 @@ class Cell(Cell_):
         self._cell_backward_hook = None
         self._is_recursion_hook = False
 
+        # parameters hook
+        self._parameters_forward_hook = None
+        self._parameters_backward_hook = None
+
         self.cell_type = None
         self.cast = Cast()
         self._has_config_recompute = False
@@ -492,14 +499,17 @@ class Cell(Cell_):
         if self._forward_pre_hook:
             inputs = self._run_forward_pre_hook(inputs)
 
-        if self._backward_hook:
-            output = self._backward_hook_construct(*inputs, **kwargs)
-        elif self._shard_fn is not None:
+        if self._shard_fn is not None:
             output = self._shard_fn(*inputs, **kwargs)
-        elif self._recompute_cell is not None:
-            output = self._recompute_cell(*inputs, **kwargs)
-        elif self.has_bprop and _pynative_executor.requires_grad():
-            output = self._call_custom_bprop(*inputs, **kwargs)
+        elif _pynative_executor.requires_grad():
+            if self._backward_hook:
+                output = self._backward_hook_construct(*inputs, **kwargs)
+            elif self._recompute_cell is not None:
+                output = self._recompute_cell(*inputs, **kwargs)
+            elif self.has_bprop:
+                output = self._call_custom_bprop(*inputs, **kwargs)
+            else:
+                output = self.construct(*inputs, **kwargs)
         else:
             output = self.construct(*inputs, **kwargs)
 
@@ -598,7 +608,7 @@ class Cell(Cell_):
         strategy for others will be set by sharding propagation.
         in_strategy and out_strategy define the input and output layout respectively.
         in_strategy/out_strategy should be a tuple, each element of which corresponds to the desired layout of
-        this input/output, which can refer to the description of `mindspore.ops.Primitive.shard`.
+        this input/output, which can refer to the description of :func:`mindspore.ops.Primitive.shard`.
         The parallel strategies of remaining operators are derived from the strategy specified by the input and output.
 
         Note:
@@ -1350,7 +1360,7 @@ class Cell(Cell_):
         def _updata(param):
             if param in replace:
                 return replace.get(param)
-            new_p = param.init_data(None, set_sliced=False)
+            new_p = param.init_data(None, set_sliced=param.sliced)
             replace[param] = new_p
             return new_p
 
@@ -1822,6 +1832,9 @@ class Cell(Cell_):
         if not hasattr(self, "_func_graph_flags"):
             self._func_graph_flags = {}
         self._func_graph_flags.update({**flags})
+        if context._get_mode() == context.PYNATIVE_MODE and self._func_graph_flags.get("output_no_recompute"):
+            raise TypeError("Recompute is not supported in PyNative mode currently, you can use "
+                            "'context.set_context(mode=context.GRAPH_MODE)' or @jit to set graph mode.")
         self.__dict__.update({**flags})
         self._add_mixed_precision_flag(**flags)
         return self
@@ -1955,9 +1968,8 @@ class Cell(Cell_):
 
     def set_grad(self, requires_grad=True):
         """
-        Sets the cell flag for gradient. In pynative mode, this parameter specifies whether the network requires
-        gradients. If ``true`` , the backward network needed to compute the gradients will be generated when the forward
-        network is executed.
+        Sets the cell flag for gradient.
+
 
         Args:
             requires_grad (bool): Specifies if the net need to grad, if it is
@@ -2217,6 +2229,8 @@ class Cell(Cell_):
             (Tensor(shape=[1], dtype=Float32, value= [ 2.00000000e+00]), Tensor(shape=[1], dtype=Float32,
             value= [ 2.00000000e+00]))
         """
+        if self.has_bprop:
+            return HookHandle()
         if context._get_mode() == context.GRAPH_MODE:
             return HookHandle()
         if not check_hook_fn("register_forward_hook", hook_fn):
@@ -2334,9 +2348,12 @@ class Cell(Cell_):
         Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
         """
-        ret = self._cell_backward_pre_hook(outputs)
         if isinstance(outputs, tuple):
-            if not isinstance(ret, tuple):
+            ret = self._cell_backward_pre_hook(*outputs)
+        else:
+            ret = self._cell_backward_pre_hook(outputs)
+        if isinstance(outputs, tuple):
+            if len(outputs) == 1:
                 ret = (ret,)
             if len(ret) != len(outputs):
                 raise TypeError(
@@ -2452,9 +2469,14 @@ class Cell(Cell_):
                 outputs = self.construct(*outputs, **kwargs)
             else:
                 outputs = self.construct(outputs, **kwargs)
-
-        outputs = self._cell_backward_hook(outputs)
-        return outputs
+        if isinstance(outputs, tuple):
+            new_outputs = self._cell_backward_hook(*outputs)
+        else:
+            new_outputs = self._cell_backward_hook(outputs)
+        # if outputs is (X,) and new_outpus is X
+        if isinstance(outputs, tuple) and len(outputs) == 1:
+            new_outputs = (new_outputs,)
+        return new_outputs
 
     def set_param_ps(self, recurse=True, init_in_server=False):
         """
@@ -2699,6 +2721,91 @@ class Cell(Cell_):
         for cell in self.cells():
             cell._add_recompute_flag()
 
+    def _register_parameters_hook(self, forward_hook=None, backward_hook=None, all=False):
+        """
+        Register the forward hook for parameters and register the backward hook for the corresponding gradient.
+
+        .. warning::
+            This is an experimental prototype that is subject to change and/or deletion.
+
+        Note:
+            - The `_register_parameters_hook(forward_hook, backward_hook)` only work in graph mode
+            - The `forward_hook` must be defined as the following code.
+              `parameters`: the tuple of the trainble parameters of the Cell, each element in the tuple shuould be
+               in the format of `(param_name, Parameter)`.
+            - The `forward_hook` should have the following signature:
+              forward_hook(parameters) -> None.
+            - The `backward_hook` must be defined as the following code.
+              `gradients`: the tuple of the gradients corresponding to the trainble parameters of the Cell, each
+               element in the tuple shuould be in the format of `(param_name, gradient)`.
+            - The `backward_hook` should have the following signature:
+              backward_hook(parameters) -> New gradients.
+
+        Args:
+            forward_hook (function, optional): Python function or ``None``, Forward hook function. Default: ``None``
+            backward_hook (function, optional): Python function or ``None``, Backward hook function. Default ``None``
+            all (bool, optional): bool, whether to set hooks for all sub cells recursively. Default: ``False``
+
+        Returns:
+            None
+
+        Raises:
+            RuntimeError: If the `forward_hook` or `backward_hook ` has unspoorted syntax under GRAPH MODE.
+            TypeError: If the `forward_hook` or `backward_hook` is not defined as required.
+
+        Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+        Examples:
+            >>> import mindspore as ms
+            >>> from mindspore import Tensor, nn, ops, Parameter
+            >>>
+            >>> ms.set_context(mode=ms.GRAPH_MODE)
+            >>> def parameter_hook(parameters):
+            ...     print("--- enter parameter hook ---")
+            ...     for name, param in parameters:
+            ...         print (name, param)
+            ...     print("--- leave parameter hook ---")
+            ...
+            >>> def gradient_hook(gradients):
+            ...     print("--- enter gradient hook ---")
+            ...     outs = []
+            ...     for name, gradient in gradients:
+            ...         print(name, gradient)
+            ...         outs.append(gradient * 2) # double gradient
+            ...     print("--- leave gradient hook ---")
+            ...     return outs
+            ...
+            >>> class Net(nn.Cell):
+            ...     def __init__(self)
+            ...         super(Net, self).__init__()
+            ...         self.w = Parameter(Tensor(np.array([3.0], np.float32)), name='w')
+            ...     def construct(self, x):
+            ...         return self.w * x
+            ...
+            >>> grad = ops.GradOperation(get_by_list=True)
+            >>> net = Net()
+            >>> net._register_parameters_hook(forward_hook=parameter_hook, backward_hook=gradient_hook)
+            >>> x = Tensor(np.array([4.0]).astype(np.float32))
+            >>> output = grad(net, net.trainable_params())(x)
+            --- enter parameter hook ---
+            w
+            Tensor(shape=[1], dtype=Float32, value=[ 3.00000000e+00])
+            --- leave parameter hook ---
+            --- enter gradient hook ---
+            w
+            Tensor(shape=[1], dtype=Float32, value=[ 4.00000000e+00])
+            --- leave gradient hook ---
+            >>> print("doubled grad: ", output)
+            doubled grad: (Tensor(shape=[1], dtype=Float32, value=[ 8.00000000e+00]),)
+        """
+        if not all:
+            self._parameters_forward_hook = forward_hook
+            self._parameters_backward_hook = backward_hook
+        else:
+            for _, cell in self.cells_and_names():
+                cell._parameters_forward_hook = forward_hook
+                cell._parameters_backward_hook = backward_hook
 
 class GraphCell(Cell):
     """

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

@@ -179,7 +179,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})`.
@@ -1273,9 +1273,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 +1320,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 +1372,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 +1578,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 \\

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,9 @@ 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): If set to ``True`` , will do this operation in-place. Default: ``False`` .
 
     Inputs:
         - **x** (Tensor) - The input of Dropout.
@@ -253,18 +253,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
 
 
@@ -479,6 +484,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 +519,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
 
 
@@ -626,7 +634,7 @@ class Dense(Cell):
     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.
+        In PyNative mode, if `bias` is ``False`` , the `x` cannot be greater than 6D.
 
     Args:
         in_channels (int): The number of channels in the input space.
@@ -660,7 +668,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: If `bias` is ``False`` and `x` is greater than 6D in PyNative mode.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -762,24 +770,26 @@ class Linear(Cell):
     .. math::
         \text{outputs} = X * kernel + bias
 
-    .. warning::
-        In PYNATIVE mode, if `bias` is ``False`` , the `x` cannot be greater than 6D.
-
     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 +808,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: If `bias` is ``False`` and `x` is greater than 6D in PyNative mode.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -806,10 +816,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 +1295,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 +1326,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

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/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

mindspore/nn/layer/normalization.py

@@ -36,7 +36,6 @@ from mindspore.common import dtype as mstype
 from mindspore.parallel._utils import _is_in_auto_parallel_mode
 from mindspore.nn.cell import Cell
 from mindspore import log as logger
-from mindspore.ops import group_norm
 
 __all__ = ['BatchNorm1d', 'BatchNorm2d', 'BatchNorm3d', 'LayerNorm', 'LayerNormExt', 'GroupNorm',
            'SyncBatchNorm', 'InstanceNorm1d', 'InstanceNorm2d', 'InstanceNorm3d']
@@ -795,13 +794,15 @@ class LayerNormExt(Cell):
         This is an experimental API that is subject to change or deletion.
 
     Args:
-        normalized_shape (Union(tuple[int], list[int], int)): The normalized shape of `x` for LayerNorm
-        eps (float): A value added to the denominator for numerical stability(:math:`\epsilon`). Default: ``1e-5`` .
-        elementwise_affine (bool): Whether affine transformation is required. When this parameter is set to ``True``,
+        normalized_shape (Union(tuple[int], list[int], int)): The normalized shape of `x` for LayerNorm.
+        eps (float, optional): A value added to the denominator for numerical stability( :math:`\epsilon` ).
+            Default: ``1e-5`` .
+        elementwise_affine (bool, optional): Whether affine transformation is required.
+            When this parameter is set to ``True``,
             the weight parameter is initialized to 1 and the offset is initialized to 0. Default: ``True``.
-        bias (bool): If set to ``False``, the layer will not learn an additive bias (only relevant if
+        bias (bool, optional): If set to ``False``, the layer will not learn an additive bias (only relevant if
              `elementwise_affine` is ``True``). Default: ``True``.
-        dtype (:class:`mindspore.dtype`): Dtype of Parameters. Default: ``None`` .
+        dtype (:class:`mindspore.dtype`, optional): Dtype of Parameters. Default: ``None`` .
 
     Inputs:
         - **x** (Tensor) - The shape is :math:`(N, *)`, where :math:`*` is equal to normalized_shape.
@@ -1248,7 +1249,7 @@ class GroupNorm(Cell):
 
     def _cal_output(self, x):
         """calculate groupnorm output"""
-        return group_norm(x, self.num_groups, self.gamma.to(x.dtype), self.beta.to(x.dtype), self.eps)
+        return ops.group_norm(x, self.num_groups, self.gamma.to(x.dtype), self.beta.to(x.dtype), self.eps)
 
     @staticmethod
     @_primexpr

mindspore/nn/layer/padding.py

@@ -442,7 +442,7 @@ class _ReflectionPadNd(Cell):
 
 class ReflectionPad1d(_ReflectionPadNd):
     r"""
-    Using a given padding to do reflection pad on the given tensor.
+    Using a given padding to do reflection pad on the given tensor. 1d means the dimension of padding is 1-dimension.
 
     Args:
         padding (union[int, tuple]): The padding size to pad the last dimension of input tensor.
@@ -490,7 +490,7 @@ class ReflectionPad1d(_ReflectionPadNd):
 
 class ReflectionPad2d(_ReflectionPadNd):
     r"""
-    Using a given padding to do reflection pad the given tensor.
+    Using a given padding to do reflection pad the given tensor. 2d means the dimension of padding is 2-dimension.
 
     Args:
         padding (union[int, tuple]): The padding size to pad the input tensor.
@@ -542,7 +542,8 @@ class ReflectionPad2d(_ReflectionPadNd):
 
 class ReflectionPad3d(_ReflectionPadNd):
     r"""
-    Pad the given tensor in a reflecting way using the input boundaries as the axis of symmetry.
+    Pad the given tensor in a reflecting way using the input boundaries as the axis of symmetry. 3d means the dimension
+    of padding is 3-dimension.
 
     Note:
         ReflectionPad3d has not supported 5D tensor yet.