mindspore 2.4.10__cp39-cp39-win_amd64.whl → 2.6.0__cp39-cp39-win_amd64.whl

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,

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']
@@ -287,37 +286,40 @@ class BatchNorm2d(_BatchNorm):
         Note that the formula for updating the :math:`moving\_mean` and :math:`moving\_var` is
 
         .. math::
-            \text{moving_mean}=\text{moving_mean*momentum}+μ_β\text{*(1−momentum)}\\
-            \text{moving_var}=\text{moving_var*momentum}+σ^2_β\text{*(1−momentum)}
+            \text{moving_mean}=\text{moving_mean*momentum}+μ_β\text{*(1-momentum)}\\
+            \text{moving_var}=\text{moving_var*momentum}+σ^2_β\text{*(1-momentum)}
 
         where :math:`moving\_mean` is the updated mean, :math:`moving\_var` is the updated variance,
-        :math:`μ_β, σ^2_β` are the observed value (mean and variance) of each batch of data.
+        :math:`μ_β, σ^2_β` are the observed value (mean and variance respectively) of each batch of data.
 
     Args:
         num_features (int): The number of channels of the input tensor. Expected input size is :math:`(N, C, H, W)`,
             `C` represents the number of channels.
-        eps (float): :math:`\epsilon` 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` 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.9`` .
-        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` can be learned.
             Default: ``True`` .
-        gamma_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the :math:`\gamma` weight.
+        gamma_init (Union[Tensor, str, Initializer, numbers.Number], optional): Initializer for the
+            :math:`\gamma` weight.
             The values of str refer to the function `mindspore.common.initializer
             <https://www.mindspore.cn/docs/en/master/api_python/mindspore.common.initializer.html>`_
             including ``'zeros'`` , ``'ones'`` , etc. Default: ``'ones'`` .
-        beta_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the :math:`\beta` weight.
+        beta_init (Union[Tensor, str, Initializer, numbers.Number], optional): Initializer for the
+            :math:`\beta` weight.
             The values of str refer to the function `mindspore.common.initializer
             <https://www.mindspore.cn/docs/en/master/api_python/mindspore.common.initializer.html>`_
             including ``'zeros'`` , ``'ones'`` , etc. Default: ``'zeros'`` .
-        moving_mean_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the moving mean.
+        moving_mean_init (Union[Tensor, str, Initializer, numbers.Number], optional): Initializer for the moving mean.
             The values of str refer to the function `mindspore.common.initializer
             <https://www.mindspore.cn/docs/en/master/api_python/mindspore.common.initializer.html>`_
             including ``'zeros'`` , ``'ones'`` , etc. Default: ``'zeros'`` .
-        moving_var_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the moving variance.
+        moving_var_init (Union[Tensor, str, Initializer, numbers.Number], optional): Initializer for
+            the moving variance.
             The values of str refer to the function `mindspore.common.initializer
             <https://www.mindspore.cn/docs/en/master/api_python/mindspore.common.initializer.html>`_
             including ``'zeros'`` , ``'ones'`` , etc. Default: ``'ones'`` .
-        use_batch_statistics (bool): Default: ``None`` .
+        use_batch_statistics (bool, optional): Default: ``None`` .
 
             - If ``true`` , use the mean value and variance value of current batch data and track running mean
               and running variance.
@@ -326,9 +328,9 @@ class BatchNorm2d(_BatchNorm):
               training and evaluation mode. During training, the parameter is set to true, and during evaluation, the
               parameter is set to false.
 
-        data_format (str): The optional value for data format, is ``'NHWC'`` or ``'NCHW'`` .
+        data_format (str, optional): The optional value for data format, is ``'NHWC'`` or ``'NCHW'`` .
             Default: ``'NCHW'`` .
-        dtype (:class:`mindspore.dtype`): Dtype of Parameters. Default: ``mstype.float32`` .
+        dtype (:class:`mindspore.dtype`, optional): Dtype of Parameters. Default: ``mstype.float32`` .
 
     Inputs:
         - **x** (Tensor) - Tensor of shape :math:`(N, C, H, W)`. Supported types: float16, float32.
@@ -341,7 +343,7 @@ class BatchNorm2d(_BatchNorm):
         TypeError: If `eps` is not a float.
         ValueError: If `num_features` is less than 1.
         ValueError: If `momentum` is not in range [0, 1].
-        ValueError: If `data_format` is neither 'NHWC' not 'NCHW'.
+        ValueError: If `data_format` is neither ``'NHWC'`` not ``'NCHW'``.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -509,32 +511,34 @@ class SyncBatchNorm(_BatchNorm):
 
     Args:
         num_features (int): `C` from an expected input of size :math:`(N, C, H, W)`.
-        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.9`` .
-        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`` .
-        gamma_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the :math:`\gamma` weight.
-            The values of str refer to the function `initializer` including ``'zeros'`` , ``'ones'`` ,
+        gamma_init (Union[Tensor, str, Initializer, numbers.Number], optional): Initializer for the :math:`\gamma`
+            weight. The values of str refer to the function `initializer` including ``'zeros'`` , ``'ones'`` ,
             ``'xavier_uniform'`` , ``'he_uniform'`` , etc. Default: ``'ones'`` .
-        beta_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the :math:`\beta` weight.
+        beta_init (Union[Tensor, str, Initializer, numbers.Number], optional): Initializer for the :math:`\beta` weight.
             The values of str refer to the function `initializer` including ``'zeros'`` , ``'ones'`` ,
             ``'xavier_uniform'`` , ``'he_uniform'`` , etc. Default: ``'zeros'`` .
-        moving_mean_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the moving mean.
+        moving_mean_init (Union[Tensor, str, Initializer, numbers.Number], optional): Initializer for the moving mean.
             The values of str refer to the function `initializer` including ``'zeros'`` , ``'ones'`` ,
             ``'xavier_uniform'`` , ``'he_uniform'`` , etc. Default: ``'zeros'`` .
-        moving_var_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the moving variance.
-            The values of str refer to the function `initializer` including ``'zeros'`` , ``'ones'`` ,
+        moving_var_init (Union[Tensor, str, Initializer, numbers.Number], optional): Initializer for the moving
+            variance. The values of str refer to the function `initializer` including ``'zeros'`` , ``'ones'`` ,
             ``'xavier_uniform'`` , ``'he_uniform'`` , etc. Default: ``'ones'`` .
-        use_batch_statistics (bool): If ``true`` , use the mean value and variance value of current batch data. If
-            ``false`` , use the mean value and variance value of specified value. If ``None`` , training process will
-            use the mean and variance of current batch data and track the running mean and variance, eval process will
-            use the running mean and variance. Default: ``None`` .
-        process_groups (list): A list to divide devices into different sync groups, containing N subtraction lists.
-            Each subtraction list contains int numbers identifying rank ids which need to be synchronized in the same
-            group. All int values must be in [0, rank_size) and different from each other. Default: ``None`` ,
+        use_batch_statistics (bool, optional): If ``true`` , use the mean value and variance value of current batch
+            data. If ``false`` , use the mean value and variance value of specified value. If ``None`` , training
+            process will use the mean and variance of current batch data and track the running mean and variance, eval
+            process will use the running mean and variance. Default: ``None`` .
+        process_groups (list, optional): A list to divide devices into different sync groups, containing N subtraction
+            lists. Each subtraction list contains int numbers identifying rank ids which need to be synchronized in the
+            same group. All int values must be in [0, rank_size) and different from each other. Default: ``None`` ,
             indicating synchronization across all devices.
-        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}, H_{in}, W_{in})`.
@@ -559,14 +563,14 @@ class SyncBatchNorm(_BatchNorm):
 
             For the Ascend devices, users need to prepare the rank table, set rank_id and device_id.
             Please see the `Ascend tutorial
-            <https://www.mindspore.cn/docs/en/master/model_train/parallel/rank_table.html>`_
+            <https://www.mindspore.cn/tutorials/en/master/parallel/rank_table.html>`_
             for more details.
 
             For the GPU devices, users need to prepare the host file and mpi, please see the `mpirun Startup
-            <https://www.mindspore.cn/docs/en/master/model_train/parallel/mpirun.html>`_ .
+            <https://www.mindspore.cn/tutorials/en/master/parallel/mpirun.html>`_ .
 
             For the CPU device, users need to write a dynamic cluster startup script, please see the `Dynamic Cluster
-            Startup <https://www.mindspore.cn/docs/en/master/model_train/parallel/dynamic_cluster.html>`_ .
+            Startup <https://www.mindspore.cn/tutorials/en/master/parallel/dynamic_cluster.html>`_ .
 
             This example should be run with multiple devices.
 
@@ -795,13 +799,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.
@@ -986,8 +992,8 @@ class InstanceNorm1d(_InstanceNorm):
         ValueError: If `num_features` is less than 1.
         ValueError: If `momentum` is not in range [0, 1].
         ValueError: If the shape of `gamma_init` / `beta_init` is not :math:`(C)`.
-        KeyError: If any of `gamma_init`/`beta_init` is str and the homonymous class inheriting from `Initializer` not
-            exists.
+        KeyError: If any of `gamma_init`/`beta_init` is str and
+            there is no homonymous class inheriting from `Initializer`.
 
     Supported Platforms:
         ``GPU``
@@ -1064,8 +1070,8 @@ class InstanceNorm2d(_InstanceNorm):
         ValueError: If `num_features` is less than 1.
         ValueError: If `momentum` is not in range [0, 1].
         ValueError: If the shape of `gamma_init` / `beta_init` is not :math:`(C)`.
-        KeyError: If any of `gamma_init`/`beta_init` is str and the homonymous class inheriting from `Initializer` not
-            exists.
+        KeyError: If any of `gamma_init`/`beta_init` is str and
+            there is no homonymous class inheriting from `Initializer`.
 
     Supported Platforms:
         ``GPU``
@@ -1170,10 +1176,11 @@ class GroupNorm(Cell):
 
     Group Normalization is widely used in recurrent neural networks. It applies
     normalization on a mini-batch of inputs for each single training case as described
-    in the paper `Group Normalization <https://arxiv.org/pdf/1803.08494.pdf>`_. Group Normalization
-    divides the channels into groups and computes within each group the mean and variance for normalization,
-    and it performs very stable over a wide range of batch size. :math:`\gamma` and :math:`\beta` are trainable scale
-    and shift.
+    in the paper `Group Normalization <https://arxiv.org/pdf/1803.08494.pdf>`_.
+    Group Normalization
+    divides the channels into groups and computes within each group the mean and variance for normalization.
+    :math:`\gamma` and :math:`\beta` are scale
+    and shift values obtained by training learning.
     It can be described using the following formula:
 
     .. math::
@@ -1248,7 +1255,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.

mindspore/nn/layer/pooling.py

@@ -18,23 +18,21 @@ from __future__ import absolute_import
 from mindspore.ops import operations as P
 from mindspore.ops import functional as F
 import mindspore.ops as ops
-from mindspore.ops.function.nn_func import avg_pool2d_ext
 from mindspore._checkparam import _check_3d_int_or_tuple
 from mindspore import _checkparam as validator
 from mindspore.ops.primitive import constexpr, _primexpr
 from mindspore.common.tensor import Tensor
 import mindspore.context as context
 from mindspore.common import dtype as mstype
-from mindspore.ops.operations.nn_ops import AdaptiveMaxPool2D
-from mindspore.ops.operations.nn_ops import AdaptiveMaxPool3D, AdaptiveAvgPool3D
-from mindspore.ops.auto_generate.gen_ops_prim import MaxPoolWithIndices, MaxPoolWithMask
 from mindspore.nn.cell import Cell
 from mindspore._c_expression import MSContext
+from mindspore.ops.auto_generate import avg_pool1d_ext
+
 
 __all__ = ['AvgPool3d', 'MaxPool3d', 'AvgPool2d', 'MaxPool2d', 'AvgPool1d', 'MaxPool1d', 'FractionalMaxPool2d',
            'FractionalMaxPool3d', 'AdaptiveAvgPool1d', 'AdaptiveMaxPool1d', 'AdaptiveMaxPool2d', 'AdaptiveMaxPool3d',
            'AdaptiveAvgPool2d', 'AdaptiveAvgPool3d', 'MaxUnpool1d', 'MaxUnpool2d', 'MaxUnpool3d', 'LPPool1d',
-           'LPPool2d', 'AvgPool2dExt', 'MaxPool2dExt']
+           'LPPool2d', 'AvgPool2dExt', 'AvgPool3dExt', 'MaxPool2dExt', 'AvgPool1dExt']
 
 
 class _PoolNd(Cell):
@@ -301,11 +299,12 @@ class MaxPool3d(_PoolNd):
         For Atlas training series products, this interface is not supported.
 
     Args:
-        kernel_size (Union[int, tuple[int]]): The size of kernel used to take the maximum value,
+        kernel_size (Union[int, tuple[int]], optional): The size of kernel used to take the maximum value,
             is an int number or a single element tuple that represents depth, height and width of the kernel, or a tuple
             of three int numbers that represent depth, height and width respectively.
             The value must be a positive integer. Default: ``1`` .
-        stride (Union[int, tuple[int]]): The moving stride of pooling operation, an int number or a single element tuple
+        stride (Union[int, tuple[int]], optional): The moving stride of pooling operation,
+            an int number or a single element tuple
             that represents the moving stride of pooling kernel in the directions of depth, height and the width,
             or a tuple of three int numbers that represent depth, height and width of movement respectively.
             The value must be a positive integer. If the value is None, the default value `kernel_size` is used.
@@ -326,18 +325,19 @@ class MaxPool3d(_PoolNd):
               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], list[int])): Pooling padding value. Default: ``0`` .
+        padding (Union(int, tuple[int], list[int]), optional): Pooling padding value. Default: ``0`` .
             `padding` can only be an integer or a tuple/list containing one or three integers.
             If `padding` is an integer or a tuple/list containing one integer, it will be padded in six directions of
             front, back, top, bottom, left and right of the input. If `padding` is a tuple/list containing three
             integers, it will be padded in front and back of the input `padding[0]` times, up and down `padding[1]`
             times, and left and right of the input `padding[2]` times.
-        dilation (Union(int, tuple[int])): The spacing between the elements of the kernel in convolution,
+        dilation (Union(int, tuple[int]), optional): The spacing between the elements of the kernel in convolution,
             used to increase the receptive field of the pooling operation. If it is a tuple, it must contain one or
             three integers. Default: ``1`` .
-        return_indices (bool): If ``True`` , output is a Tuple of 2 Tensors, representing the maxpool result and where
+        return_indices (bool, optional): If ``True`` , output is a Tuple of 2 Tensors,
+            representing the maxpool result and where
             the max values are generated. Otherwise, only the maxpool result is returned. Default: ``False`` .
-        ceil_mode (bool): If ``True``, use ceil to calculate output shape.
+        ceil_mode (bool, optional): If ``True``, use ceil to calculate output shape.
             If ``False``, use ceil to calculate output shape. Default: ``False`` .
 
     Inputs:
@@ -689,9 +689,11 @@ class MaxPool2dExt(Cell):
         self.return_indices = return_indices
         strides = stride if (stride is not None) else kernel_size
         if return_indices:
-            self.max_pool_func_ = MaxPoolWithIndices(kernel_size, strides, padding, dilation, ceil_mode)
+            self.max_pool_func_ = ops.auto_generate.gen_ops_prim.MaxPoolWithIndices(kernel_size, strides, padding,
+                                                                                    dilation, ceil_mode)
         else:
-            self.max_pool_func_ = MaxPoolWithMask(kernel_size, strides, padding, dilation, ceil_mode)
+            self.max_pool_func_ = ops.auto_generate.gen_ops_prim.MaxPoolWithMask(kernel_size, strides, padding,
+                                                                                 dilation, ceil_mode)
 
     def construct(self, input):
         out, indices = self.max_pool_func_(input)
@@ -713,9 +715,9 @@ class MaxPool1d(_PoolNd):
         \text{input}(N_i, C_j, s_0 \times l + n)
 
     Args:
-        kernel_size (int): The size of kernel used to take the max value, Default: ``1`` .
-        stride (int): The distance of kernel moving, an int number that represents
-            the width of movement is stride, Default: ``1`` .
+        kernel_size (int, optional): The size of kernel used to take the max value. Default: ``1`` .
+        stride (int, optional): The distance of kernel moving, an int number that represents
+            the width of movement is stride. Default: ``1`` .
         pad_mode (str, optional): Specifies the padding mode with a padding value of 0. It can be set to:
             ``"same"`` , ``"valid"`` or ``"pad"`` . Default: ``"valid"`` .
 
@@ -731,24 +733,25 @@ class MaxPool1d(_PoolNd):
               at the begin and end is determined by the `padding` parameter.
               If this mode is set, `padding` must be greater than or equal to 0.
 
-        padding (Union(int, tuple[int], list[int])): Padding value for the pooling. Default value is ``0``.
+        padding (Union(int, tuple[int], list[int]), optional): Padding value for the pooling. Default value is ``0``.
             padding can only be an integer or a tuple/list containing a single integer, in which case padding times or
             padding[0] times are padded on both sides of the input.
-        dilation (Union(int, tuple[int])): The spacing between the elements of the kernel in convolution,
+        dilation (Union(int, tuple[int]), optional): The spacing between the elements of the kernel in convolution,
             used to increase the receptive field of the pooling operation. If it is a tuple, its length can only be 1.
             Default: ``1`` .
-        return_indices (bool): If ``True`` , the function will return both the result of max pooling and the indices of
+        return_indices (bool, optional): If ``True`` , the function will return
+            both the result of max pooling and the indices of
             the max elements. Default: ``False`` .
-        ceil_mode (bool): If True, use ceil to compute the output shape instead of floor. Default: ``False`` .
+        ceil_mode (bool, optional): If True, use ceil to compute the output shape instead of floor. Default: ``False`` .
 
     Inputs:
         - **x** (Tensor) - Tensor of shape :math:`(N, C_{in}, L_{in})` or :math:`(C_{in}, L_{in})`.
 
     Outputs:
-        If `return_indices` is False, output is a Tensor, with shape :math:`(N, C_{out}, L_{out})` or
+        If `return_indices` is ``False``, output is a Tensor, with shape :math:`(N, C_{out}, L_{out})` or
         :math:`(C_{out}, L_{out})`. It has the same data type as `x`.
 
-        If `return_indices` is True, output is a Tuple of 2 Tensors, representing the maxpool result and where
+        If `return_indices` is ``True``, output is a Tuple of 2 Tensors, representing the maxpool result and where
         the max values are generated.
 
         - **output** (Tensor) - Maxpooling result, with shape :math:`(N, C_{out}, L_{out})` or
@@ -1021,6 +1024,81 @@ class AvgPool3d(_PoolNd):
         return out
 
 
+class AvgPool3dExt(Cell):
+    r"""
+    Applies a 3D average pooling over an input Tensor which can be regarded as
+    a composition of 3D input planes.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    For details, please refer to :func:`mindspore.mint.nn.functional.avg_pool3d`.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> pool = ms.nn.AvgPool3dExt(kernel_size=3, stride=1)
+        >>> x = ms.ops.randn(1, 2, 4, 4, 5).astype(ms.float32)
+        >>> output = pool(x)
+        >>> print(output.shape)
+        (1, 2, 2, 2, 3)
+        >>> x1 = ms.ops.randn(6, 5, 7, 7, 5).astype(ms.float32)
+        >>> pool2 = ms.nn.AvgPool3dExt(4, stride=2, padding=(2, 2, 1), divisor_override=10)
+        >>> output2 = pool2(x1)
+        >>> print(output2.shape)
+        (6, 5, 4, 4, 2)
+    """
+    def __init__(self, kernel_size, stride=None, padding=0, ceil_mode=False,
+                 count_include_pad=True, divisor_override=None):
+        super(AvgPool3dExt, self).__init__()
+        self.kernel_size = kernel_size
+        self.stride = stride
+        self.padding = padding
+        self.ceil_mode = ceil_mode
+        self.count_include_pad = count_include_pad
+        self.divisor_override = divisor_override
+
+    def construct(self, input):
+        return ops.function.nn_func.avg_pool3d_ext(input, self.kernel_size, self.stride, self.padding,
+                                                   self.ceil_mode, self.count_include_pad, self.divisor_override)
+
+
+class AvgPool1dExt(Cell):
+    r"""
+    Applies a 1D average pooling over an input Tensor which can be regarded as
+    a composition of 2D input planes.
+
+    For details, please refer to :func:`mindspore.mint.nn.functional.avg_pool1d`.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, nn
+        >>> from mindspore import dtype as mstype
+        >>> input = Tensor(np.arange(1 * 3 * 4).reshape(1, 3, 4), mstype.float32)
+        >>> net = nn.AvgPool1dExt(kernel_size=2, stride=1)
+        >>> output = net(input)
+        >>> print(output.shape)
+        (1, 3, 3)
+    """
+    def __init__(self, kernel_size, stride=None, padding=0, ceil_mode=False,
+                 count_include_pad=True):
+        super().__init__()
+        self.kernel_size = kernel_size
+        self.stride = stride
+        self.padding = padding
+        self.ceil_mode = ceil_mode
+        self.count_include_pad = count_include_pad
+
+    def construct(self, input):
+        return avg_pool1d_ext(input, self.kernel_size, self.stride, self.padding,
+                              self.ceil_mode, self.count_include_pad)
+
+
 class AvgPool2dExt(Cell):
     r"""
     Applies a 2D average pooling over an input Tensor which can be regarded as
@@ -1052,8 +1130,8 @@ class AvgPool2dExt(Cell):
         self.divisor_override = divisor_override
 
     def construct(self, input):
-        return avg_pool2d_ext(input, self.kernel_size, self.stride, self.padding,
-                              self.ceil_mode, self.count_include_pad, self.divisor_override)
+        return ops.function.nn_func.avg_pool2d_ext(input, self.kernel_size, self.stride, self.padding,
+                                                   self.ceil_mode, self.count_include_pad, self.divisor_override)
 
 
 class AvgPool2d(_PoolNd):
@@ -1127,7 +1205,7 @@ class AvgPool2d(_PoolNd):
         TypeError: If `kernel_size` or `strides` is neither int nor tuple.
         ValueError: If `pad_mode` is not ``"valid"`` , ``"same"`` or ``"pad"`` with not case sensitive.
         ValueError: If `data_format` is neither ``'NCHW'`` nor ``'NHWC'``.
-        ValueError: If `padding`, `ceil_mode`, `count_include_pad`, or `divisor_override` is used
+        ValueError: If `padding`, `ceil_mode`, `count_include_pad`, or `divisor_override` is used,
             or `pad_mode` is ``"pad"`` when `data_format` is 'NHWC'.
         ValueError: If `kernel_size` or `strides` is less than 1.
         ValueError: If length of `padding` tuple/list is not 1 or 2.
@@ -1236,8 +1314,8 @@ class AvgPool1d(_PoolNd):
         This interface currently does not support Atlas A2 training series products.
 
     Args:
-        kernel_size (int): The size of kernel window used to take the average value, Default: ``1`` .
-        stride (int): The distance of kernel moving, an int number that represents
+        kernel_size (int, optional): The size of kernel window used to take the average value, Default: ``1`` .
+        stride (int, optional): The distance of kernel moving, an int number that represents
             the width of movement is strides, Default: ``1`` .
         pad_mode (str, optional): Specifies the padding mode with a padding value of 0. It can be set to:
             ``"same"`` , ``"valid"`` or ``"pad"`` . Default: ``"valid"`` .
@@ -1248,17 +1326,20 @@ class AvgPool1d(_PoolNd):
               uniformly distributed around the input, if it is odd, the excess padding is goes to the right side.
               If this mode is set, `padding` must be 0.
             - ``"valid"``: No padding is applied to the input, and the output returns the maximum
-              possible length. Extra pixels that could not complete a full stride will
-              be discarded. If this mode is set, `padding` must be 0.
+              possible length. If a full stride cannot be formed, the extra pixels will be discarded.
+              If this mode is set, `padding` must be 0.
             - ``"pad"``: Pad the input with a specified amount. In this mode, the amount of padding
               at the begin and end is determined by the `padding` parameter.
               If this mode is set, `padding` must be greater than or equal to 0.
 
-        padding (Union(int, tuple[int], list[int])): Pooling padding value, only ``"pad"`` mode can be set to non-zero.
+        padding (Union(int, tuple[int], list[int]), optional): Pooling padding value,
+            only ``"pad"`` mode can be set to non-zero.
             Default: ``0`` . padding can only be an integer or a tuple/list containing a single integer, in which case
             padding times or padding[0] times are padded on both sides of the input.
-        ceil_mode (bool): If ``True`` , use ceil to compute the output shape instead of floor. Default: ``False`` .
-        count_include_pad (bool): If ``True`` , averaging calculation will include the zero-padding. Default: ``True`` .
+        ceil_mode (bool, optional): If ``True`` , use ceil to compute the output shape instead of floor.
+            Default: ``False`` .
+        count_include_pad (bool, optional): If ``True`` , averaging calculation will include the zero-padding.
+            Default: ``True`` .
 
     Inputs:
         - **x** (Tensor) - Tensor of shape :math:`(N, C_{in}, L_{in})` or :math:`(C_{in}, L_{in})`.
@@ -1592,7 +1673,7 @@ class AdaptiveAvgPool3d(Cell):
     def __init__(self, output_size):
         """Initialize AdaptiveAvgPool3d."""
         super(AdaptiveAvgPool3d, self).__init__()
-        self.adaptive_avg_pool3d = AdaptiveAvgPool3D(output_size)
+        self.adaptive_avg_pool3d = ops.AdaptiveAvgPool3D(output_size)
 
     def construct(self, input):
         return self.adaptive_avg_pool3d(input)
@@ -1694,13 +1775,14 @@ class AdaptiveMaxPool2d(Cell):
         \end{align}
 
     Note:
-        Ascend platform only supports float16 type for input.
+        In KBK mode, `output_size` does not support mutable.
 
     Args:
         output_size (Union[int, tuple]): The target output size. `output_size` can be a tuple :math:`(H, W)`,
             or an int H for :math:`(H, H)`. :math:`H` and :math:`W` can be int or None.
             If it is None, it means the output size is the same as the input size.
-        return_indices (bool): If `return_indices` is ``True`` , the indices of max value would be output.
+        return_indices (bool, optional): Whether to output the index of the maximum value.
+            If `return_indices` is ``True`` , the indices of max value would be output.
             Default: ``False`` .
 
     Inputs:
@@ -1763,15 +1845,11 @@ class AdaptiveMaxPool2d(Cell):
     def __init__(self, output_size, return_indices=False):
         """Initialize AdaptiveMaxPool2d."""
         super(AdaptiveMaxPool2d, self).__init__()
-        validator.check_value_type('return_indices', return_indices, [bool], self.cls_name)
-        self.adaptive_max_pool2d = AdaptiveMaxPool2D(output_size)
+        self.output_size = output_size
         self.return_indices = return_indices
 
     def construct(self, input):
-        output = self.adaptive_max_pool2d(input)
-        if self.return_indices:
-            return output
-        return output[0]
+        return ops.adaptive_max_pool2d(input, self.output_size, self.return_indices)
 
 
 class AdaptiveMaxPool3d(Cell):
@@ -1823,7 +1901,7 @@ class AdaptiveMaxPool3d(Cell):
             output_size = (output_size, output_size, output_size)
         self.output_size = Tensor(output_size, dtype=mstype.int32)
         self.return_indices = return_indices
-        self.adaptive_max_pool3d = AdaptiveMaxPool3D()
+        self.adaptive_max_pool3d = ops.AdaptiveMaxPool3D()
 
     def construct(self, input):
         output = self.adaptive_max_pool3d(input, self.output_size)

mindspore/nn/layer/rnn_cells.py

@@ -340,7 +340,7 @@ class GRUCell(RNNCellBase):
     :math:`r` is reset gate. :math:`z` is update gate. :math:`n` is n-th layer. For instance,
     :math:`W_{ir}, b_{ir}` are the weight and bias used to transform from input :math:`x` to :math:`r`.
     Details can be found in paper
-    `Learning Phrase Representations using RNN Encoder–Decoder for Statistical Machine Translation
+    `Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation
     <https://aclanthology.org/D14-1179.pdf>`_.
 
     Args:

mindspore/nn/layer/rnns.py

@@ -237,6 +237,7 @@ class _DynamicGRUCPUGPU(Cell):
                 h_0.view(1, *h_0.shape),
                 weights.astype(x.dtype)
             )
+
             if seq_length is not None:
                 h_n = get_hidden(output, seq_length)
                 mask = sequence_mask(seq_length, x.shape[0])
@@ -687,7 +688,7 @@ class GRU(_RNNBase):
     are learnable weights between the output and the input in the formula. For instance,
     :math:`W_{ir}, b_{ir}` are the weight and bias used to transform from input :math:`x` to :math:`r`.
     Details can be found in paper
-    `Learning Phrase Representations using RNN Encoder–Decoder for Statistical Machine Translation
+    `Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation
     <https://aclanthology.org/D14-1179.pdf>`_.
 
     Note: