mindspore 2.0.0a0__cp37-cp37m-win_amd64.whl → 2.0.0rc1__cp37-cp37m-win_amd64.whl

mindspore/nn/layer/pooling.py

@@ -18,14 +18,14 @@ 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._checkparam import Rel, Validator as validator
-from mindspore.ops.primitive import constexpr
+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.operations.nn_ops import MaxPool3DWithArgmax
 from mindspore.nn.cell import Cell
 
 __all__ = ['AvgPool3d', 'MaxPool3d', 'AvgPool2d', 'MaxPool2d', 'AvgPool1d', 'MaxPool1d', 'FractionalMaxPool2d',
@@ -41,7 +41,7 @@ class _PoolNd(Cell):
         """Initialize _PoolNd."""
         super(_PoolNd, self).__init__()
         validator.check_value_type('pad_mode', pad_mode, [str], self.cls_name)
-        self.pad_mode = validator.check_string(pad_mode.upper(), ['VALID', 'SAME'], 'pad_mode', self.cls_name)
+        self.pad_mode = validator.check_string(pad_mode.upper(), ['VALID', 'SAME', 'PAD'], 'pad_mode', self.cls_name)
         self.format = validator.check_string(data_format, ['NCHW', 'NHWC'], 'format', self.cls_name)
         if context.get_context("device_target") != "GPU" and self.format == "NHWC":
             raise ValueError(f"For '{self.cls_name}, the 'NHWC' format only support in GPU target, but got device "
@@ -50,17 +50,17 @@ class _PoolNd(Cell):
         def _check_int_or_tuple(arg_name, arg_value):
             validator.check_value_type(arg_name, arg_value, [int, tuple], self.cls_name)
             error_msg = f"For '{self.cls_name}', the '{arg_name}' must be an positive int number or " \
-                        f"a tuple of two positive int numbers, but got {arg_value}"
+                        f"a tuple, but got {arg_value}"
             if isinstance(arg_value, int):
                 if arg_value <= 0:
                     raise ValueError(error_msg)
-            elif len(arg_value) == 2:
+            else:
                 for item in arg_value:
                     if isinstance(item, int) and item > 0:
                         continue
                     raise ValueError(error_msg)
-            else:
-                raise ValueError(error_msg)
+                if len(arg_value) == 1:
+                    return arg_value[0]
             return arg_value
 
         self.kernel_size = _check_int_or_tuple('kernel_size', kernel_size)
@@ -73,19 +73,24 @@ class _PoolNd(Cell):
         return 'kernel_size={kernel_size}, stride={stride}, pad_mode={pad_mode}'.format(**self.__dict__)
 
 
-@constexpr
+@_primexpr
 def _shape_check(in_shape, prim_name=None):
     msg_prefix = f"For '{prim_name}', the" if prim_name else "The"
-    if len(in_shape) != 3:
-        raise ValueError(f"{msg_prefix} input must has 3 dim, but got {len(in_shape)}")
+
+    def _check():
+        if len(in_shape) != 3:
+            raise ValueError(f"{msg_prefix} input must has 3 dim, but got {len(in_shape)}")
+
+    _check()
 
 
 class LPPool1d(Cell):
     r"""
-    Applies a 1D power lp pooling over an input signal composed of several input planes.
+    Applying 1D LPPooling operation on an input Tensor can be regarded as forming a 1D input plane.
 
-    Typically the input is of shape :math:`(N, C, L_{in})` or :math:`(C, L_{in})`, the output is of shape
-    :math:`(N, C, L_{in})` or :math:`(C, L_{in})`, with the same shape as input, the operation is as follows.
+    Typically the input is of shape :math:`(N_{in}, C_{in}, L_{in})` or :math:`(C_{in}, L_{in})``, the output is of
+    shape :math:`(N_{out}, C_{out}, L_{out})` or :math:`(C_{out}, L_{out})`, with the same shape as input,
+    the operation is as follows.
 
     .. math::
         f(X) = \sqrt[p]{\sum_{x \in X} x^{p}}
@@ -93,8 +98,9 @@ class LPPool1d(Cell):
     Args:
         norm_type (Union[int, float]): Type of normalization, represents p in the formula, can not be 0.
 
-            - if p = 1, one gets Sum Pooling (which is proportional to Average Pooling),
-            - if p = :math:`\infty`, one gets Max Pooling.
+            - if p = 1, the result is the sum of the elements within the pooling kernel(proportional to average
+              pooling).
+            - if p = :math:`\infty`, the result is the result of maximum pooling.
 
         kernel_size (int): The size of kernel window.
         stride (int): The distance of kernel moving, an int number that represents
@@ -102,11 +108,15 @@ class LPPool1d(Cell):
         ceil_mode (bool): Whether to use ceil or floor to calculate output shape. Default: False.
 
     Inputs:
-        - **x** (Tensor) - Tensor of shape :math:`(N, C, L_{in})` or :math:`(C, L_{in})`.
+        - **x** (Tensor) - Tensor of shape :math:`(N_{in}, C_{in}, L_{in})` or :math:`(C_{in}, L_{in})`.
 
     Outputs:
-        - **output** (Tensor) - LPPool1d result, with shape :math:`(N, C, L_{in})` or :math:`(C, L_{in})`,
-          It has the same data type as `x`.
+        - **output** (Tensor) - LPPool1d result, with shape :math:`(N_{out}, C_{out}, L_{out})` or
+          :math:`(C_{out}, L_{out})`, it has the same data type as `x`, where
+
+        .. math::
+            L_{out} = \left\lfloor\frac{L_{in} - \text{kernel_size}}{\text{stride}} + 1\right\rfloor
+
 
     Raises:
         TypeError: If `x` is not an Tensor.
@@ -151,7 +161,7 @@ class LPPool1d(Cell):
 
 class LPPool2d(Cell):
     r"""
-    Applies a 2D power lp pooling over an input signal composed of several input planes.
+    Applying 2D LPPooling operation on an input Tensor can be regarded as forming a 1D input plane.
 
     Typically the input is of shape :math:`(N, C, H_{in}, W_{in})`, the output is of shape
     :math:`(N, C, H_{in}, W_{in})`, with the same shape as input, the operation is as follows.
@@ -162,8 +172,9 @@ class LPPool2d(Cell):
     Args:
         norm_type(Union[int, float]) - Type of normalization, represents p in the formula, can not be 0.
 
-            - if p = 1, one gets Sum Pooling (which is proportional to Average Pooling),
-            - if p = :math:`\infty`, one gets Max Pooling.
+            - if p = 1, the result is the sum of the elements within the pooling kernel(proportional to average
+              pooling).
+            - if p = :math:`\infty`, the result is the result of maximum pooling.
 
         kernel_size(Union[int, tuple[int]]): The size of kernel window.
             The data type of kernel_size must be int and the value represents the height and width,
@@ -179,7 +190,13 @@ class LPPool2d(Cell):
 
     Outputs:
         - **output** (Tensor) - LPPool2d result, with shape :math:`(N, C, H_{in}, W_{in})`,
-          It has the same data type as `x`.
+          It has the same data type as `x`, where
+
+        .. math::
+            H_{out} = \left\lfloor\frac{H_{in} - \text{kernel_size}[0]}{\text{stride}[0]} + 1\right\rfloor
+
+        .. math::
+            W_{out} = \left\lfloor\frac{W_{in} - \text{kernel_size}[1]}{\text{stride}[1]} + 1\right\rfloor
 
     Raises:
         TypeError: If `x` is not an Tensor.
@@ -229,7 +246,37 @@ class LPPool2d(Cell):
                              self.stride, self.ceil_mode)
 
 
-class MaxPool3d(Cell):
+def _check_maxpool_padding(padding, nd, cls_name):
+    """Calculate maxpool padding before call primitive"""
+    validator.check_value_type('padding', padding, (int, tuple, list), cls_name)
+    if isinstance(padding, int):
+        return (0,) * (3 - nd) + (padding,) * nd
+    if isinstance(padding, (tuple, list)):
+        validator.check_non_negative_int_sequence(padding, "padding", cls_name)
+        if len(padding) == 1:
+            return (0,) * (3 - nd) + tuple(padding * nd)
+        if len(padding) != nd:
+            raise ValueError(f"For {cls_name}, the length of padding must equal to {nd}, but got {len(padding)}.")
+        return (0,) * (3 - nd) + tuple(padding)
+    return padding
+
+
+def _cal_dilation(dilation, nd, cls_name):
+    """check the dilation"""
+    if isinstance(dilation, int):
+        return dilation
+    if isinstance(dilation, tuple):
+        if len(dilation) == 1:
+            return dilation[0]
+        if len(dilation) == nd:
+            return (3 - nd) * (1,) + dilation
+        if nd == 1:
+            raise ValueError(f"For {cls_name}, the length of 'dilation' must be 1, but got {len(dilation)}.")
+        raise ValueError(f"For {cls_name}, the length of 'dilation' must be 1 or {nd}, but got {len(dilation)}.")
+    raise ValueError(f"For {cls_name}, the 'dilation' must be int or tuple, but got {type(dilation)}.")
+
+
+class MaxPool3d(_PoolNd):
     r"""
     3D max pooling operation.
 
@@ -246,29 +293,46 @@ class MaxPool3d(Cell):
 
     Args:
         kernel_size (Union[int, tuple[int]]): The size of kernel used to take the maximum value,
-            is an int number that represents depth, height and width of the kernel, or a tuple
+            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.
-        stride (Union[int, tuple[int]]): The moving stride of pooling operation, an int number that represents
-            the moving stride of pooling kernel in the directions of depth, height and the width,
+            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
+            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.
-        padding (Union[int, tuple[int]]): Pooling padding length. An int number that represents the depth,
-            height and width of movement are both stride, or a tuple of three int numbers that represent depth,
-            height and width of movement respectively. The value cannot be negative. Default: 0.
-        dilation (Union[int, tuple[int]]): Control the spacing of elements in the pooling kernel. Default: 1.
+            Default: 1.
+        pad_mode (str): The optional value for pad mode, is "same", "valid" or "pad", not case sensitive.
+            Default: "valid".
+
+            - same: The output shape is the same as the input shape evenly divided by `stride`.
+
+            - valid: The possible largest height and width of output
+              will be returned without padding. Extra pixels will be discarded.
+
+            - pad: pads the input. Pads the top, bottom, left, and right sides of the input with `padding` number of
+              zeros. 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` 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,
+            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
             the max values are generated. Otherwise, only the maxpool result is returned. Default: False.
         ceil_mode (bool): Whether to use ceil or floor to calculate output shape. Default: False.
 
     Inputs:
         - **x** (Tensor) - Tensor of shape :math:`(N_{in}, C_{in}, D_{in}, H_{in}, W_{in})` or
-          :math:`(C_{in}, D_{in}, H_{in}, W_{in})` with data type of int8, int16, int32,
-          int64, uint8, uint16, uint32, uint64, float16, float32 or float64.
+          :math:`(C_{in}, D_{in}, H_{in}, W_{in})`.
 
     Outputs:
-        If `return_indices` is False, output is a Tensor, with shape :math:`(N, C, D_{out}, H_{out}, W_{out})`, or
-        :math:`(C_{out}, D_{out}, H_{out}, W_{out})`. It has the same data type as `x`.
+        If `return_indices` is False, output is a Tensor, with shape
+        :math:`(N_{out}, C_{out}, D_{out}, H_{out}, W_{out})`  or :math:`(C_{out}, D_{out}, H_{out}, W_{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
         the max values are generated.
@@ -277,72 +341,84 @@ class MaxPool3d(Cell):
           :math:`(C_{out}, D_{out}, H_{out}, W_{out})`. It has the same data type as `x`.
         - **argmax** (Tensor) - Index corresponding to the maximum value. Data type is int64.
 
+        If `pad_mode` is in `pad` mode, the output shape calculation formula is as follows:
+
+        .. math::
+            D_{out} = \left\lfloor\frac{D_{in} + 2 \times \text{padding}[0] - \text{dilation}[0] \times
+            (\text{kernel_size}[0] - 1) - 1}{\text{stride}[0]} + 1\right\rfloor
+
+        .. math::
+            H_{out} = \left\lfloor\frac{H_{in} + 2 \times \text{padding}[1] - \text{dilation}[1] \times
+            (\text{kernel_size}[1] - 1) - 1}{\text{stride}[1]} + 1\right\rfloor
+
+        .. math::
+            W_{out} = \left\lfloor\frac{W_{in} + 2 \times \text{padding}[2] - \text{dilation}[2] \times
+            (\text{kernel_size}[2] - 1) - 1}{\text{stride}[2]} + 1\right\rfloor
+
     Raises:
-        TypeError: If `x` is not a Tensor.
-        ValueError: If length of shape of `x` is not equal to 5.
+        ValueError: If length of shape of `x` is not equal to 4 or 5.
         TypeError: If `kernel_size` , `stride` , `padding` or `dilation` is neither an int nor a tuple.
         ValueError: If `kernel_size` or `stride` is less than 1.
-        ValueError: If `padding` is less than 0.
+        ValueError: If the `padding` parameter is neither an integer nor a tuple of length 3.
+        ValueError: If `pad_mode` is not set to 'pad', setting return_indices to True or dilation to a value
+            other than 1.
+        ValueError: If `padding` is non-zero when `pad_mode` is not 'pad'.
 
     Supported Platforms:
-        ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> import mindspore as ms
         >>> import mindspore.nn as nn
         >>> import numpy as np
-        >>> pool1 = nn.MaxPool3d(kernel_size=3, stride=1, padding=1)
-        >>> pool2 = nn.MaxPool3d(kernel_size=3, stride=1, padding=1, return_indices=True)
-        >>> x = ms.Tensor(np.random.randint(0, 10, [1, 2, 2, 2, 2]), ms.float32)
-        >>> output1 = pool1(x)
-        >>> print(output1)
-        [[[[[8. 8.]
-            [8. 8.]]
-           [[8. 8.]
-            [8. 8.]]]
-          [[[9. 9.]
-            [9. 9.]]
-           [[9. 9.]
-            [9. 9.]]]]]
+        >>> np_x = np.random.randint(0, 10, [5, 3, 4, 6, 7])
+        >>> x = Tensor(np_x, ms.float32)
+        >>> pool1 = nn.MaxPool3d(kernel_size=2, stride=1, pad_mode='pad', padding=1, dilation=3, return_indices=True)
+        >>> output = pool1(x)
+        >>> print(output[0].shape)
+        (5, 3, 3, 5, 6)
+        >>> print(output[1].shape)
+        (5, 3, 3, 5, 6)
+        >>> pool2 = nn.MaxPool3d(kernel_size=2, stride=1, pad_mode='pad', padding=1, dilation=3, return_indices=False)
         >>> output2 = pool2(x)
-        >>> print(output2)
-        (Tensor(shape=[1, 2, 2, 2, 2], dtype=Float32, value=
-        [[[[[8.00000000e+000, 8.00000000e+000],
-            [8.00000000e+000, 8.00000000e+000]],
-           [[8.00000000e+000, 8.00000000e+000],
-            [8.00000000e+000, 8.00000000e+000]]],
-          [[[9.00000000e+000, 9.00000000e+000],
-            [9.00000000e+000, 9.00000000e+000]],
-           [[9.00000000e+000, 9.00000000e+000],
-            [9.00000000e+000, 9.00000000e+000]]]]]), Tensor(shape=[1, 2, 2, 2, 2], dtype=Int64, value=
-        [[[[[7, 7],
-            [7, 7]],
-           [[7, 7],
-            [7, 7]]],
-          [[[2, 2],
-            [2, 2]],
-           [[2, 2],
-            [2, 2]]]]]))
+        >>> print(output2.shape)
+        (5, 3, 3, 5, 6)
     """
 
-    def __init__(self, kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False):
+    def __init__(self, kernel_size=1, stride=1, pad_mode="valid", padding=0, dilation=1, return_indices=False,
+                 ceil_mode=False):
         """Initialize MaxPool3d."""
-        super(MaxPool3d, self).__init__()
-        stride = stride if (stride is not None) else kernel_size
+        super(MaxPool3d, self).__init__(kernel_size, stride, pad_mode)
         self.return_indices = return_indices
-        self.max_pool = MaxPool3DWithArgmax(kernel_size, stride, padding, dilation, ceil_mode)
-        self.expand_dims = P.ExpandDims()
+        padding = _check_maxpool_padding(padding, 3, self.cls_name)
+        _check_3d_int_or_tuple("padding", padding, self.cls_name, greater_zero=False, ret_five=False)
+        if dilation != 1 or return_indices:
+            self.only_pad = True
+            if pad_mode.upper() != "PAD":
+                raise ValueError(f"For {self.cls_name}, the pad_mode must be 'pad' when dilation is not 1 "
+                                 f"or return_indices is True, but got pad_mode:{pad_mode}.")
+            self.max_pool = P.MaxPool3DWithArgmax(ksize=kernel_size, strides=stride, pads=padding,
+                                                  dilation=dilation, ceil_mode=ceil_mode)
+        else:
+            self.only_pad = False
+            ceil_mode = None if not ceil_mode else True
+            self.max_pool = P.MaxPool3D(kernel_size=kernel_size, strides=stride, pad_mode=pad_mode, pad_list=padding,
+                                        ceil_mode=ceil_mode)
 
     def construct(self, x):
-        _shape = x.shape
-        if len(x.shape) == 4:
-            x = self.expand_dims(x, 0)
-        output_tensor, argmax = self.max_pool(x)
-        output_tensor = output_tensor.reshape(_shape)
-        argmax = argmax.reshape(_shape)
-        if self.return_indices:
-            return output_tensor, argmax
-        return output_tensor
+        expand_batch = False
+        if x.ndim == 4:
+            x = x.unsqueeze(0)
+            expand_batch = True
+        out = self.max_pool(x)
+        if expand_batch:
+            if isinstance(out, tuple):
+                out = (out[0].squeeze(0), out[1].squeeze(0))
+            else:
+                out = out.squeeze(0)
+        if self.only_pad and not self.return_indices:
+            return out[0]
+        return out
 
 
 class MaxPool2d(_PoolNd):
@@ -351,45 +427,82 @@ class MaxPool2d(_PoolNd):
 
     Typically the input is of shape :math:`(N_{in}, C_{in}, H_{in}, W_{in})`, MaxPool2d outputs
     regional maximum in the :math:`(H_{in}, W_{in})`-dimension. Given kernel size
-    :math:`ks = (h_{ker}, w_{ker})` and stride :math:`s = (s_0, s_1)`, the operation is as follows.
+    :math:`(h_{ker}, w_{ker})` and stride :math:`(s_0, s_1)`, the operation is as follows.
 
     .. math::
         \text{output}(N_i, C_j, h, w) = \max_{m=0, \ldots, h_{ker}-1} \max_{n=0, \ldots, w_{ker}-1}
         \text{input}(N_i, C_j, s_0 \times h + m, s_1 \times w + n)
 
-    Note:
-        pad_mode for training only supports "same" and "valid".
-
     Args:
         kernel_size (Union[int, tuple[int]]): The size of kernel used to take the max value,
-            is an int number that represents height and width are both kernel_size,
+            is an int number or a single element tuple that represents height and width are both kernel_size,
             or a tuple of two int numbers that represent height and width respectively.
             Default: 1.
-        stride (Union[int, tuple[int]]): The distance of kernel moving, an int number that represents
-            the height and width of movement are both stride, or a tuple of two int numbers that
+        stride (Union[int, tuple[int]]): The distance of kernel moving, an int number or a single element tuple that
+            represents the height and width of movement are both stride, or a tuple of two int numbers that
             represent height and width of movement respectively. Default: 1.
-        pad_mode (str): The optional value for pad mode, is "same" or "valid", not case sensitive.
+        pad_mode (str): The optional value for pad mode, is "same", "valid" or "pad", not case sensitive.
             Default: "valid".
 
             - same: The output shape is the same as the input shape evenly divided by `stride`.
 
             - valid: The possible largest height and width of output
               will be returned without padding. Extra pixels will be discarded.
+
+            - pad: pads the input. Pads the top, bottom, left, and right sides of the input with `padding` number of
+              zeros. If this mode is set, `padding` must be greater than or equal to 0.
+
+        padding (Union(int, tuple[int], list[int])): Specifies the padding value of the pooling operation. Default: 0.
+            `padding` can only be an integer or a tuple/list containing one or two integers. If `padding` is an integer
+            or a tuple/list containing one integer, it will be padded `padding` times in the four directions of the
+            input. If `padding` is a tuple/list containing two integers, it will be padded `padding[0]` times in the
+            up-down direction of the input and `padding[1]` times in the left-right direction of the input.
+        dilation (Union(int, tuple[int])): 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 two
+            integers. Default: 1.
+        return_indices (bool): 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.
         data_format (str): The optional value for data format, is 'NHWC' or 'NCHW'.
             Default: 'NCHW'.
 
     Inputs:
-        - **x** (Tensor) - Tensor of shape :math:`(N, C_{in}, H_{in}, W_{in})`.
+        - **x** (Tensor) - Tensor of shape :math:`(N,C_{in},H_{in},W_{in})` or :math:`(C_{in},H_{in},W_{in})`.
 
     Outputs:
-        Tensor of shape :math:`(N, C_{out}, H_{out}, W_{out})`.
+        If `return_indices` is False, output is a Tensor, with shape :math:`(N, C, H_{out}, W_{out})` or
+        :math:`(C_{out}, H_{out}, W_{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
+        the max values are generated.
+
+        - **output** (Tensor) - Maxpooling result, with shape :math:`(N_{out}, C_{out}, H_{out}, W_{out})` or
+          :math:`(C_{out}, H_{out}, W_{out})`. It has the same data type as `x`.
+        - **argmax** (Tensor) - Index corresponding to the maximum value. Data type is int64.
+
+        If `pad_mode` is in `pad` mode, the output shape calculation formula is as follows:
+
+        .. math::
+            H_{out} = \left\lfloor\frac{H_{in} + 2 * \text{padding[0]} - \text{dilation[0]}
+                \times (\text{kernel_size[0]} - 1) - 1}{\text{stride[0]}} + 1\right\rfloor
+
+        .. math::
+            W_{out} = \left\lfloor\frac{W_{in} + 2 * \text{padding[1]} - \text{dilation[1]}
+                \times (\text{kernel_size[1]} - 1) - 1}{\text{stride[1]}} + 1\right\rfloor
 
     Raises:
         TypeError: If `kernel_size` or `stride` is neither int nor tuple.
         ValueError: If `pad_mode` is neither 'valid' nor 'same' with not case sensitive.
         ValueError: If `data_format` is neither 'NCHW' nor 'NHWC'.
         ValueError: If `kernel_size` or `stride` is less than 1.
-        ValueError: If length of shape of `x` is not equal to 4.
+        ValueError: If length of shape of `x` is not equal to 3 or 4.
+        ValueError: If `pad_mode` is not 'pad', `padding`, `dilation`, `return_indices`, `ceil_mode` parameters are not
+            set to their default values.
+        ValueError: If the length of the tuple/list `padding` parameter is not 2.
+        ValueError: If The length of the tuple dilation parameter is not 2.
+        ValueError: If dilation parameter is neither an integer nor a tuple.
+        ValueError: If `pad_mode` is 'pad' and `data_format` is 'NHWC'.
+        ValueError: If `padding` is non-zero when `pad_mode` is not 'pad'.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -400,18 +513,71 @@ class MaxPool2d(_PoolNd):
         >>> output = pool(x)
         >>> print(output.shape)
         (1, 2, 2, 2)
+        >>> np_x = np.random.randint(0, 10, [5, 3, 4, 5])
+        >>> x = Tensor(np_x, mindspore.float32)
+        >>> pool2 = nn.MaxPool2d(kernel_size=2, stride=1, pad_mode='pad', padding=1, dilation=1, return_indices=True)
+        >>> output = pool2(x)
+        >>> print(output[0].shape)
+        (5, 3, 5, 6)
+        >>> print(output[1].shape)
+        (5, 3, 5, 6)
     """
 
-    def __init__(self, kernel_size=1, stride=1, pad_mode="valid", data_format="NCHW"):
+    def __init__(self, kernel_size=1, stride=1, pad_mode="valid", padding=0, dilation=1, return_indices=False,
+                 ceil_mode=False, data_format="NCHW"):
         """Initialize MaxPool2d."""
         super(MaxPool2d, self).__init__(kernel_size, stride, pad_mode, data_format)
-        self.max_pool = P.MaxPool(kernel_size=self.kernel_size,
-                                  strides=self.stride,
-                                  pad_mode=self.pad_mode,
-                                  data_format=self.format)
+        self.return_indices = return_indices
+        if pad_mode.upper() == 'PAD':
+            if self.format == "NHWC":
+                raise ValueError(f"For '{self.cls_name}, the 'NHWC' format are not support when 'pad_mode' is 'pad'.")
+            self.use_pad = True
+            if isinstance(self.kernel_size, tuple):
+                _check_tuple_length(self.kernel_size, 'kernel_size', 2, self.cls_name)
+                kernel_size = (1,) + self.kernel_size
+            elif isinstance(self.kernel_size, int):
+                kernel_size = (1, self.kernel_size, self.kernel_size)
+            if isinstance(self.stride, tuple):
+                _check_tuple_length(self.stride, 'stride', 2, self.cls_name)
+                stride = (1,) + self.stride
+            elif isinstance(self.stride, int):
+                stride = (1, self.stride, self.stride)
+            self.padding = _check_maxpool_padding(padding, 2, self.cls_name)
+            dilation = _cal_dilation(dilation, 2, self.cls_name)
+            self.max_pool = P.MaxPool3DWithArgmax(ksize=kernel_size, strides=stride, pads=self.padding,
+                                                  dilation=dilation, ceil_mode=ceil_mode)
+        else:
+            self.use_pad = False
+            if padding != 0 or dilation != 1 or return_indices or ceil_mode:
+                raise ValueError(f"For MaxPool1d, the parameter 'padding', 'dilation', 'return_indices', 'ceil_mode' "
+                                 f"can not be set to non-default value when pad_mode is not 'pad', "
+                                 f"but got pad_mode:{pad_mode}.")
+            self.max_pool = P.MaxPool(kernel_size=self.kernel_size,
+                                      strides=self.stride,
+                                      pad_mode=self.pad_mode,
+                                      data_format=self.format)
 
     def construct(self, x):
-        out = self.max_pool(x)
+        expand_batch = False
+        if x.ndim == 3:
+            x = x.unsqueeze(0)
+            expand_batch = True
+        if self.use_pad:
+            x = x.unsqueeze(2)
+            out = self.max_pool(x)
+            if isinstance(out, tuple):
+                out = out[0].squeeze(2), out[1].squeeze(2)
+            else:
+                out = out.squeeze(2)
+        else:
+            out = self.max_pool(x)
+        if expand_batch:
+            if isinstance(out, tuple):
+                out = (out[0].squeeze(0), out[1].squeeze(0))
+            else:
+                out = out.squeeze(0)
+        if self.use_pad and not self.return_indices:
+            return out[0]
         return out
 
 
@@ -420,21 +586,18 @@ class MaxPool1d(_PoolNd):
     Applies a 1D max pooling over an input Tensor which can be regarded as a composition of 1D planes.
 
     Typically the input is of shape :math:`(N_{in}, C_{in}, L_{in})`, MaxPool1d outputs
-    regional maximum in the :math:`(L_{in})`-dimension. Given kernel size
-    :math:`ks = (l_{ker})` and stride :math:`s = (s_0)`, the operation is as follows:
+    regional maximum in the :math:`(L_{in})`-dimension. Given `kernel size`
+    :math:`ks = (l_{ker})` and `stride` :math:`s = (s_0)`, the operation is as follows:
 
     .. math::
         \text{output}(N_i, C_j, l) = \max_{n=0, \ldots, l_{ker}-1}
         \text{input}(N_i, C_j, s_0 \times l + n)
 
-    Note:
-        pad_mode for training only supports "same" and "valid".
-
     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.
-        pad_mode (str): The optional value for pad mode, is "same" or "valid", not case sensitive.
+        pad_mode (str): The optional value for pad mode, is "same", "valid" or "pad", not case sensitive.
             Default: "valid".
 
             - same: Adopts the way of completion. The total number of padding will be calculated in horizontal
@@ -444,62 +607,165 @@ class MaxPool1d(_PoolNd):
             - valid: Adopts the way of discarding. The possible largest height and width of output
               will be returned without padding. Extra pixels will be discarded.
 
+            - pad: Performs padding on the input. Adds padding size of zeros to both ends of the input.
+              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 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,
+            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 the
+            max elements. Default: False.
+        ceil_mode (bool): If True, use ceil to compute the output shape instead of floor. Default: False.
+
     Inputs:
-        - **x** (Tensor) - Tensor of shape :math:`(N, C, L_{in})`.
+        - **x** (Tensor) - Tensor of shape :math:`(N, C_{in}, L_{in})` or :math:`(C_{in}, L_{in})`.
 
     Outputs:
-        Tensor of shape :math:`(N, C, L_{out})`.
+        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
+        the max values are generated.
+
+        - **output** (Tensor) - Maxpooling result, with shape :math:`(N, C_{out}, L_{out})` or
+          :math:`(C_{out}, L_{out})`. It has the same data type as `x`.
+        - **argmax** (Tensor) - Index corresponding to the maximum value. Data type is int64.
+
+        If `pad_mode` is in `pad` mode, the output shape calculation formula is as follows:
+
+        .. math::
+            L_{out} = \left\lfloor \frac{L_{in} + 2 \times \text{padding} - \text{dilation}
+                \times (\text{kernel_size} - 1) - 1}{\text{stride}} + 1\right\rfloor
 
     Raises:
         TypeError: If `kernel_size` or `strides` is not an int.
-        ValueError: If `pad_mode` is neither 'valid' nor 'same' with not case sensitive.
+        ValueError: If `pad_mode` is not 'valid', 'same' or 'pad', case-insensitive.
         ValueError: If `data_format` is neither 'NCHW' nor 'NHWC'.
         ValueError: If `kernel_size` or `strides` is less than 1.
-        ValueError: If length of shape of `x` is not equal to 3.
+        ValueError: If length of shape of `x` is not equal to 2 or 3.
+        ValueError: If `pad_mode` is not 'pad', `padding`, `dilation`, `return_indices`, `ceil_mode` parameters are not
+            set to their default values.
+        ValueError: If the length of the tuple/list `padding` parameter is not 1.
+        ValueError: If The length of the tuple dilation parameter is not 1.
+        ValueError: If dilation parameter is neither an integer nor a tuple.
+        ValueError: If `padding` is non-zero when `pad_mode` is not 'pad'.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> max_pool = nn.MaxPool1d(kernel_size=3, stride=1)
+        >>> mpool1 = nn.MaxPool1d(kernel_size=3, stride=1)
         >>> x = Tensor(np.random.randint(0, 10, [1, 2, 4]), mindspore.float32)
-        >>> output = max_pool(x)
+        >>> output = mpool1(x)
         >>> result = output.shape
         >>> print(result)
         (1, 2, 2)
+        >>> np_x = np.random.randint(0, 10, [5, 3, 4])
+        >>> x = Tensor(np_x, mindspore.float32)
+        >>> mpool2 = nn.MaxPool1d(kernel_size=2, stride=1, pad_mode='pad', padding=1, dilation=1, return_indices=True)
+        >>> output = mpool2(x)
+        >>> print(output[0].shape)
+        (5, 3, 5)
+        >>> print(output[1].shape)
+        (5, 3, 5)
     """
 
-    def __init__(self, kernel_size=1, stride=1, pad_mode="valid"):
+    def __init__(self, kernel_size=1, stride=1, pad_mode="valid", padding=0, dilation=1, return_indices=False,
+                 ceil_mode=False):
         """Initialize MaxPool1d."""
         super(MaxPool1d, self).__init__(kernel_size, stride, pad_mode)
-        validator.check_value_type('kernel_size', kernel_size, [int], self.cls_name)
-        validator.check_value_type('stride', stride, [int], self.cls_name)
-        validator.check_value_type('pad_mode', pad_mode, [str], self.cls_name)
-        self.pad_mode = validator.check_string(pad_mode.upper(), ['VALID', 'SAME'], 'pad_mode', self.cls_name)
-        validator.check_int(kernel_size, 1, Rel.GE, "kernel_size", self.cls_name)
-        validator.check_int(stride, 1, Rel.GE, "stride", self.cls_name)
+        validator.check_int(kernel_size, 1, validator.GE, "kernel_size", self.cls_name)
+        validator.check_int(stride, 1, validator.GE, "stride", self.cls_name)
         self.kernel_size = (1, kernel_size)
         self.stride = (1, stride)
-        self.max_pool = P.MaxPool(kernel_size=self.kernel_size,
-                                  strides=self.stride,
-                                  pad_mode=self.pad_mode)
-        self.shape = F.shape
-        self.reduce_mean = P.ReduceMean(keep_dims=True)
-        self.expand = P.ExpandDims()
-        self.squeeze = P.Squeeze(2)
+        self.return_indices = return_indices
+        if pad_mode.upper() == "PAD":
+            self.use_pad = True
+            self.kernel_size = (1, 1, kernel_size)
+            self.stride = (1, 1, stride)
+            self.padding = _check_maxpool_padding(padding, 1, self.cls_name)
+            dilation = _cal_dilation(dilation, 1, self.cls_name)
+            self.max_pool = P.MaxPool3DWithArgmax(ksize=self.kernel_size, strides=self.stride, pads=self.padding,
+                                                  dilation=dilation, ceil_mode=ceil_mode)
+
+        else:
+            self.use_pad = False
+            if padding != 0 or dilation != 1 or return_indices or ceil_mode:
+                raise ValueError(f"For MaxPool1d, the parameter 'padding', 'dilation', 'return_indices', 'ceil_mode' "
+                                 f"can not be set to non-default value when pad_mode is not 'pad', "
+                                 f"but got pad_mode:{pad_mode}.")
+            self.max_pool = P.MaxPool(kernel_size=self.kernel_size,
+                                      strides=self.stride,
+                                      pad_mode=self.pad_mode)
+            self.shape = F.shape
+            self.reduce_mean = P.ReduceMean(keep_dims=True)
+            self.expand = P.ExpandDims()
+            self.squeeze = P.Squeeze(2)
 
     def construct(self, x):
-        _shape_check(self.shape(x), self.cls_name)
-        x = self.expand(x, 2)
-        output = self.max_pool(x)
-        output = self.squeeze(output)
+        expand_batch = False
+        if x.ndim == 2:
+            x = x.unsqueeze(0)
+            expand_batch = True
+        if self.use_pad:
+            x = x.unsqueeze(2).unsqueeze(3)
+            output = self.max_pool(x)
+            if isinstance(output, tuple):
+                output = output[0].squeeze(3).squeeze(2), output[1].squeeze(3).squeeze(2)
+            else:
+                output = output.squeeze(3).squeeze(2)
+        else:
+            _shape_check(self.shape(x), self.cls_name)
+            x = self.expand(x, 2)
+            output = self.max_pool(x)
+            output = self.squeeze(output)
+        if expand_batch:
+            if isinstance(output, tuple):
+                output = (output[0].squeeze(0), output[1].squeeze(0))
+            else:
+                output = output.squeeze(0)
+        if self.use_pad and not self.return_indices:
+            return output[0]
         return output
 
 
-class AvgPool3d(Cell):
+def _cal_padding(padding, cls_name, nd):
+    """Calculate padding before call primitive"""
+    validator.check_value_type('padding', padding, (int, tuple, list), cls_name)
+    if isinstance(padding, int):
+        padding = (0, 0) * (3 - nd) + (padding,) * nd * 2
+    elif isinstance(padding, (tuple, list)):
+        validator.check_non_negative_int_sequence(padding, "padding", cls_name)
+        if len(padding) == nd:
+            padding_start = (0, 0) * (3 - nd)
+            padding_end = tuple(padding[i // 2] for i in range(nd * 2))
+            padding = padding_start + padding_end
+        elif len(padding) == 1:
+            padding = (0, 0) * (3 - nd) + tuple(padding * nd * 2)
+        else:
+            if nd == 1:
+                raise ValueError(f"For {cls_name}, the padding must be a int or tuple/list contains one int, "
+                                 f"but got tuple/list with length:{len(padding)}.")
+            raise ValueError(f"For {cls_name}, the padding must be a int or tuple/list contains 1 or {nd} int, "
+                             f"but got tuple/list with length:{len(padding)}.")
+    return padding
+
+
+def _check_tuple_length(arg_name, prim_name, length, cls_name):
+    """check the tuple length"""
+    if len(arg_name) != length:
+        raise ValueError(f"For {cls_name}, the length of {prim_name} must be equal to {length}, "
+                         f"but got {len(arg_name)}.")
+    return arg_name
+
+
+class AvgPool3d(_PoolNd):
     r"""
     Applies a 3D average pooling over an input Tensor which can be regarded as a composition of 3D input planes.
-    Typically the input is of shape :math:`(N, C, D_{in}, H_{in}, W_{in})`, and AvgPool3D outputs
+    Typically, the input is of shape :math:`(N_{in}, C_{in}, D_{in}, H_{in}, W_{in})`, and AvgPool3D outputs
     regional average in the :math:`(D_{in}, H_{in}, W_{in})`-dimension. Given kernel size
     is :math:`ks = (d_{ker}, h_{ker}, w_{ker})` and stride :math:`s = (s_0, s_1, s_2)`, the operation is as follows.
 
@@ -512,23 +778,38 @@ class AvgPool3d(Cell):
         \text{input}(N_i, C_j, s_0 \times d + l, s_1 \times h + m, s_2 \times w + n)
 
     Args:
-        kernel_size (Union[int, tuple[int]]): The size of kernel used to take the average value,
-            can be an int number that represents depth, height and width, or a tuple
-            of three int numbers that represent depth, height and width respectively.
-            The value must be a positive integer.
-        stride (Union[int, tuple[int]]): The distance of kernel moving, can be an int number that represents
-            the depth, height and width of movement, 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.
-        padding (Union(int, tuple[int])): The padding value to be filled. Default: 0. The value cannot be negative.
-            If `padding` is an integer, the paddings of head, tail, top, bottom, left and right are the same,
-            equal to padding.
-            If `padding` is a tuple of six integers, the padding of head, tail, top, bottom, left and right
-            equal to padding[0], padding[1], padding[2], padding[3], padding[4] and padding[5] correspondingly.
-        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.
-        divisor_override (int): If specified, it will be used as divisor in the averaging calculation,
-            otherwise kernel_size will be used. Default: None.
+        kernel_size (Union[int, tuple[int]], optional): The size of kernel used to take the average value,
+            can be an int number or a single element tuple that represents depth, height and width, or a tuple of three
+            positive integers that represent depth, height and width respectively. Default: 1.
+        stride (Union[int, tuple[int]], optional): The distance of kernel moving, can be a positive int or a single
+            element tuple that represents the depth, height and width of movement, or a tuple of three positive integers
+            that represents depth, height and width of movement respectively. If the value is None, the default value
+            `kernel_size` is used. Default: 1.
+        pad_mode (str, optional): Specifies the padding method of pooling, optional values are "same", "valid" or "pad",
+            case insensitive. Default: "valid".
+
+            - same: The depth, height and width of the output is the same as the value after the input is divided
+              by stride.
+
+            - valid: Returns the output obtained by effective calculation without padding.
+              The excess pixels that do not meet the calculation will be discarded.
+
+            - pad: Pads the input. Fill the front, back, top, and bottom of the input with 0s of size `padding`.
+              If this mode is set, `padding` must be greater than or equal to 0.
+
+        padding (Union(int, tuple[int], list[int]), optional): Pooling padding value, only 'pad' mode can be set to
+            non-zero. Default: 0. Only the following paddings are supported:
+
+            - `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.
+
+            - `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.
+
+        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.
+        divisor_override (int, optional): If it is specified as a non-zero parameter, this parameter will be used as the
+            divisor in the average calculation. Otherwise, `kernel_size` will be used as the divisor. Default: None.
 
     Inputs:
         - **x** (Tensor) - Tensor of shape :math:`(N, C, D_{in}, H_{in}, W_{in})` or
@@ -537,53 +818,74 @@ class AvgPool3d(Cell):
 
     Outputs:
         Tensor, with shape :math:`(N, C, D_{out}, H_{out}, W_{out})` or
-        :math:`(C, D_{in}, H_{in}, W_{in})`, with the same data type as `x`.
+        :math:`(C, D_{out}, H_{out}, W_{out})`, with the same data type as `x`.
+
+        If `pad_mode` is in `pad` mode, the output shape calculation formula is as follows:
+
+        .. math::
+            D_{out} = \left\lfloor\frac{D_{in} + 2 \times \text{padding}[0] -
+                \text{kernel_size}[0]}{\text{stride}[0]} + 1\right\rfloor
+
+        .. math::
+            H_{out} = \left\lfloor\frac{H_{in} + 2 \times \text{padding}[1] -
+                \text{kernel_size}[1]}{\text{stride}[1]} + 1\right\rfloor
+
+        .. math::
+            W_{out} = \left\lfloor\frac{W_{in} + 2 \times \text{padding}[2] -
+                \text{kernel_size}[2]}{\text{stride}[2]} + 1\right\rfloor
 
     Raises:
-        TypeError: If `kernel_size`, `stride` or `padding` is neither an int nor a tuple.
+        TypeError: If `kernel_size` is neither an int nor a tuple.
+        TypeError: If `stride` is neither an int nor a tuple.
+        TypeError: If `padding` is neither an int nor a tuple/list.
         TypeError: If `ceil_mode` or `count_include_pad` is not a bool.
-        TypeError: If `data_format` is not a string.
         TypeError: If `divisor_override` is not an int.
         ValueError: If numbers in `kernel_size` or `stride` are not positive.
         ValueError: If `kernel_size` or `stride` is a tuple whose length is not equal to 3.
-        ValueError: If `padding` is a tuple whose length is not equal to 6.
+        ValueError: If `padding` is a tuple/list whose length is neither 1 nor 3.
         ValueError: If element of `padding` is less than 0.
-        ValueError: If length of shape of `x` is not equal to 5.
+        ValueError: If length of shape of `x` is neither 4 nor 5.
+        ValueError: If `divisor_override` is less than or equal to 0.
+        ValueError: If `padding` is non-zero when `pad_mode` is not 'pad'.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> import mindspore as ms
         >>> import mindspore.nn as nn
-        >>> import numpy as np
+        >>> import mindspore.ops as ops
         >>> pool = nn.AvgPool3d(kernel_size=3, stride=1)
-        >>> x = ms.Tensor(np.random.randint(0, 10, [1, 2, 4, 4, 5]), ms.float32)
+        >>> x = ops.randn(1, 2, 4, 4, 5).astype(ms.float32)
         >>> output = pool(x)
         >>> print(output.shape)
         (1, 2, 2, 2, 3)
+        >>> x1 = ops.randn(6, 5, 7, 7, 5).astype(ms.float32)
+        >>> pool2 = nn.AvgPool3d(4, stride=2, pad_mode='pad', 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,
+    def __init__(self, kernel_size=1, stride=1, pad_mode="valid", padding=0, ceil_mode=False, count_include_pad=True,
                  divisor_override=None):
         """Initialize AvgPool3d."""
-        super(AvgPool3d, self).__init__()
-        stride = stride if (stride is not None) else kernel_size
-        if not divisor_override:
-            divisor_override = 0
-        self.avg_pool = P.AvgPool3D(kernel_size, stride, "pad", padding, ceil_mode, count_include_pad,
+        super(AvgPool3d, self).__init__(kernel_size, stride, pad_mode)
+        padding = _cal_padding(padding, self.cls_name, 3)
+        if divisor_override is not None and divisor_override <= 0:
+            raise ValueError(f"For '{self.cls_name}', the 'divisor_override' must be > 0, but got {divisor_override}.")
+        divisor_override = 0 if divisor_override is None else divisor_override
+        self.avg_pool = P.AvgPool3D(self.kernel_size, self.stride, pad_mode, padding, ceil_mode, count_include_pad,
                                     divisor_override)
-        self.squeeze = P.Squeeze(0)
-        self.expand_dims = P.ExpandDims()
 
     def construct(self, x):
-        _is_squeeze = False
+        expand_batch = False
         if len(x.shape) == 4:
-            x = self.expand_dims(x, 0)
-            _is_squeeze = True
+            x = x.unsqueeze(0)
+            expand_batch = True
         out = self.avg_pool(x)
-        if _is_squeeze:
-            out = self.squeeze(out)
+        if expand_batch:
+            out = out.squeeze(0)
         return out
 
 
@@ -599,69 +901,147 @@ class AvgPool2d(_PoolNd):
         \text{output}(N_i, C_j, h, w) = \frac{1}{h_{ker} * w_{ker}} \sum_{m=0}^{h_{ker}-1} \sum_{n=0}^{w_{ker}-1}
         \text{input}(N_i, C_j, s_0 \times h + m, s_1 \times w + n)
 
-    Note:
-        pad_mode for training only supports "same" and "valid".
-
     Args:
         kernel_size (Union[int, tuple[int]]): The size of kernel used to take the average value.
-            The data type of kernel_size must be int and the value represents the height and width,
-            or a tuple of two int numbers that represent height and width respectively.
+            The data type of kernel_size must be int or a single element tuple and the value represents the height
+            and width, or a tuple of two int numbers that represent height and width respectively.
             Default: 1.
-        stride (Union[int, tuple[int]]): The distance of kernel moving, an int number that represents
-            the height and width of movement are both strides, or a tuple of two int numbers that
+        stride (Union[int, tuple[int]]): The distance of kernel moving, an int number or a single element tuple that
+            represents the height and width of movement are both strides, or a tuple of two int numbers that
             represent height and width of movement respectively. Default: 1.
-        pad_mode (str): The optional value for pad mode, is "same" or "valid", not case sensitive.
-            Default: "valid".
+        pad_mode (str) - Specifies the padding method of pooling, optional values are "same", "valid" or "pad",
+            case insensitive. Default: "valid".
 
-            - same: Adopts the way of completion. The height and width of the output will be the same as
-              the input. The total number of padding will be calculated in horizontal and vertical
-              directions and evenly distributed to top and bottom, left and right if possible.
-              Otherwise, the last extra padding will be done from the bottom and the right side.
+            - same: The height and width of the output is the same as the value after the input is divided by stride.
 
-            - valid: Adopts the way of discarding. The possible largest height and width of output
-              will be returned without padding. Extra pixels will be discarded.
+            - valid: Returns the output obtained by effective calculation without padding.
+              The excess pixels that do not meet the calculation will be discarded.
+
+            - pad: pads the input. Pads the top, bottom, left, and right sides of the input with `padding` number of
+              zeros. 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.
+            Default: 0. `padding` can only be an integer or a tuple/list containing one or two integers.
+            If `padding` is an integer or a tuple/list containing one integer, it will be padded `padding` times in the
+            four directions of the input. If `padding` is a tuple/list containing two integers, it will be padded
+            `padding[0]` times in the up-down direction of the input and `padding[1]` times in the left-right direction
+            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.
+        divisor_override (int): If it is specified as a non-zero parameter, this parameter will be used as the divisor
+            in the average calculation. Otherwise, `kernel_size` will be used as the divisor. Default: None.
         data_format (str): The optional value for data format, is 'NHWC' or 'NCHW'.
             Default: 'NCHW'.
 
-
     Inputs:
-        - **x** (Tensor) - Tensor of shape :math:`(N, C_{in}, H_{in}, W_{in})`.
+        - **x** (Tensor) - Tensor of shape :math:`(N, C_{in}, H_{in}, W_{in})` or :math:`(C_{in}, H_{in}, W_{in})`.
 
     Outputs:
-        Tensor of shape :math:`(N, C_{out}, H_{out}, W_{out})`.
+        Tensor of shape :math:`(N, C_{out}, H_{out}, W_{out})` or :math:`(C_{out}, H_{out}, W_{out})`.
+
+        If `pad_mode` is in `pad` mode, the output shape calculation formula is as follows:
+
+        .. math::
+            H_{out} = \left\lfloor\frac{H_{in}  + 2 \times \text{padding}[0] -
+            \text{kernel_size}[0]}{\text{stride}[0]} + 1\right\rfloor
+
+        .. math::
+            W_{out} = \left\lfloor\frac{W_{in}  + 2 \times \text{padding}[1] -
+            \text{kernel_size}[1]}{\text{stride}[1]} + 1\right\rfloor
 
     Raises:
         TypeError: If `kernel_size` or `strides` is neither int nor tuple.
-        ValueError: If `pad_mode` is neither 'valid' nor 'same' with not case sensitive.
+        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
+            or `pad_mode` is `pad` when `data_format` is 'NHWC'.
         ValueError: If `kernel_size` or `strides` is less than 1.
-        ValueError: If length of shape of `x` is not equal to 4.
+        ValueError: If length of `padding` tuple/list is not 1 or 2.
+        ValueError: If length of shape of `x` is not equal to 3 or 4.
+        ValueError: If `divisor_override` is less than or equal to 0.
+        ValueError: If `padding` is non-zero when `pad_mode` is not 'pad'.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore as ms
+        >>> import mindspore.nn as nn
+        >>> import mindspore.ops as ops
+        >>> import numpy as np
         >>> pool = nn.AvgPool2d(kernel_size=3, stride=1)
-        >>> x = Tensor(np.random.randint(0, 10, [1, 2, 4, 4]), mindspore.float32)
+        >>> x = ms.Tensor(np.random.randint(0, 10, [1, 2, 4, 4]), ms.float32)
         >>> output = pool(x)
         >>> print(output.shape)
         (1, 2, 2, 2)
+        >>> x = ops.randn(6, 6, 8, 8)
+        >>> pool2 = nn.AvgPool2d(4, stride=1, pad_mode='pad', padding=2, divisor_override=5)
+        >>> output2 = pool2(x)
+        >>> print(output2.shape)
+        (6, 6, 9, 9)
     """
 
     def __init__(self,
                  kernel_size=1,
                  stride=1,
                  pad_mode="valid",
+                 padding=0,
+                 ceil_mode=False,
+                 count_include_pad=True,
+                 divisor_override=None,
                  data_format="NCHW"):
         """Initialize AvgPool2d."""
         super(AvgPool2d, self).__init__(kernel_size, stride, pad_mode, data_format)
-        self.avg_pool = P.AvgPool(kernel_size=self.kernel_size,
-                                  strides=self.stride,
-                                  pad_mode=self.pad_mode,
-                                  data_format=self.format)
+        if pad_mode.upper() == 'PAD' or padding != 0 or ceil_mode or not count_include_pad \
+                or divisor_override is not None:
+            if self.format == "NHWC":
+                raise ValueError(f"For '{self.cls_name}, the 'NHWC' format are not support when 'pad_mode' is 'pad' or "
+                                 f"'padding' is not 0 or 'ceil_mode' is not False or 'count_include_pad' is not True"
+                                 f"or divisor_override is not None, but got pade_mode:{pad_mode}, padding:{padding}, "
+                                 f"ceil_mode:{ceil_mode}, count_include_pad:{count_include_pad}, "
+                                 f"divisor_override:{divisor_override}.")
+            self.is_expand = True
+            if divisor_override is not None and divisor_override <= 0:
+                raise ValueError(
+                    f"For '{self.cls_name}', the 'divisor_override' must be > 0, but got {divisor_override}.")
+            divisor_override = 0 if divisor_override is None else divisor_override
+            padding = _cal_padding(padding, self.cls_name, 2)
+
+            if isinstance(self.kernel_size, tuple):
+                _check_tuple_length(self.kernel_size, 'kernel_size', 2, self.cls_name)
+                kernel_size = (1,) + self.kernel_size
+            elif isinstance(self.kernel_size, int):
+                kernel_size = (1, self.kernel_size, self.kernel_size)
+
+            if isinstance(self.stride, tuple):
+                _check_tuple_length(self.stride, 'stride', 2, self.cls_name)
+                stride = (1,) + self.stride
+            elif isinstance(self.stride, int):
+                stride = (1, self.stride, self.stride)
+            self.avg_pool = P.AvgPool3D(kernel_size=kernel_size, strides=stride, pad_mode=pad_mode, pad=padding,
+                                        ceil_mode=ceil_mode,
+                                        count_include_pad=count_include_pad, divisor_override=divisor_override)
+        else:
+            self.is_expand = False
+            self.avg_pool = P.AvgPool(kernel_size=self.kernel_size,
+                                      strides=self.stride,
+                                      pad_mode=self.pad_mode,
+                                      data_format=self.format)
 
     def construct(self, x):
-        return self.avg_pool(x)
+        expand_batch = False
+        if x.ndim == 3:
+            x = x.unsqueeze(0)
+            expand_batch = True
+        if self.is_expand:
+            x = x.unsqueeze(2)
+            out = self.avg_pool(x)
+            res = out.squeeze(2)
+        else:
+            res = self.avg_pool(x)
+        if expand_batch:
+            res = res.squeeze(0)
+        return res
 
 
 class AvgPool1d(_PoolNd):
@@ -669,95 +1049,134 @@ class AvgPool1d(_PoolNd):
     Applies a 1D average pooling over an input Tensor which can be regarded as a composition of 1D input planes.
 
     Typically the input is of shape :math:`(N_{in}, C_{in}, L_{in})`, AvgPool1d outputs
-    regional average in the :math:`(L_{in})`-dimension. Given kernel size
-    :math:`ks = l_{ker}` and stride :math:`s = s_0`, the operation is as follows:
+    regional average in the :math:`(L_{in})`-dimension. Given `kernel_size`
+    :math:`l_{ker}` and `stride` :math:`s_0`, the operation is as follows:
 
     .. math::
         \text{output}(N_i, C_j, l) = \frac{1}{l_{ker}} \sum_{n=0}^{l_{ker}-1}
         \text{input}(N_i, C_j, s_0 \times l + n)
 
-    Note:
-        pad_mode for training only supports "same" and "valid".
-
     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
             the width of movement is strides, Default: 1.
-        pad_mode (str): The optional value for pad mode, is "same" or "valid", not case sensitive.
-            Default: "valid".
+        pad_mode (str) - Specifies the padding method of pooling, optional values are "same", "valid" or "pad",
+            case insensitive. Default: "valid".
 
-            - same: Adopts the way of completion. The height and width of the output will be the same as
-              the input. The total number of padding will be calculated in horizontal and vertical
-              directions and evenly distributed to top and bottom, left and right if possible.
-              Otherwise, the last extra padding will be done from the bottom and the right side.
+            - same: The width of the output is the same as the value after the input is divided by stride.
 
-            - valid: Adopts the way of discarding. The possible largest height and width of output
-              will be returned without padding. Extra pixels will be discarded.
+            - valid: Returns the output obtained by effective calculation without padding.
+              The excess pixels that do not meet the calculation will be discarded.
+
+            - pad: Performs padding on the input. Adds padding size of zeros to both ends of the input.
+              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.
+            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.
 
     Inputs:
-        - **x** (Tensor) - Tensor of shape :math:`(N, C_{in}, L_{in})`.
+        - **x** (Tensor) - Tensor of shape :math:`(N, C_{in}, L_{in})` or :math:`(C_{in}, L_{in})`.
 
     Outputs:
-        Tensor of shape :math:`(N, C_{out}, L_{out})`.
+        Tensor of shape :math:`(N, C_{out}, L_{out})` or :math:`(C_{out}, L_{out})`.
+
+        If `pad_mode` is in `pad` mode, the output shape calculation formula is as follows:
+
+        .. math::
+            L_{out} = \left\lfloor \frac{L_{in} +
+            2 \times \text{padding} - \text{kernel_size}}{\text{stride}} + 1\right\rfloor
 
     Raises:
         TypeError: If `kernel_size` or `stride` is not an int.
-        ValueError: If `pad_mode` is neither 'same' nor 'valid' with not case sensitive.
+        ValueError: If `pad_mode` is not 'valid' ,'same' or 'pad' with not case sensitive.
         ValueError: If `kernel_size` or `strides` is less than 1.
-        ValueError: If length of shape of `x` is not equal to 3.
+        ValueError: If length of `padding` tuple/list is not 1.
+        ValueError: If length of shape of `x` is not equal to 2 or 3.
+        ValueError: If `padding` is non-zero when `pad_mode` is not 'pad'.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore as ms
+        >>> import mindspore.nn as nn
+        >>> import mindspore.ops as ops
+        >>> import numpy as np
         >>> pool = nn.AvgPool1d(kernel_size=6, stride=1)
-        >>> x = Tensor(np.random.randint(0, 10, [1, 3, 6]), mindspore.float32)
+        >>> x = ms.Tensor(np.random.randint(0, 10, [1, 3, 6]), ms.float32)
         >>> output = pool(x)
         >>> result = output.shape
         >>> print(result)
         (1, 3, 1)
+        >>> pool2 = nn.AvgPool1d(4, stride=1, ceil_mode=True, pad_mode='pad', padding=2)
+        >>> x1 = ops.randn(6, 6, 8)
+        >>> output = pool2(x1)
+        >>> print(output.shape)
+        (6, 6, 9)
     """
 
     def __init__(self,
                  kernel_size=1,
                  stride=1,
-                 pad_mode="valid"):
+                 pad_mode="valid",
+                 padding=0,
+                 ceil_mode=False,
+                 count_include_pad=True):
         """Initialize AvgPool1d."""
-        validator.check_value_type('kernel_size', kernel_size, [int], self.cls_name)
-        validator.check_value_type('stride', stride, [int], self.cls_name)
-        validator.check_value_type('pad_mode', pad_mode, [str], self.cls_name)
-        self.pad_mode = validator.check_string(pad_mode.upper(), ['VALID', 'SAME'], 'pad_mode', self.cls_name)
-        validator.check_int(kernel_size, 1, Rel.GE, "kernel_size", self.cls_name)
-        validator.check_int(stride, 1, Rel.GE, "stride", self.cls_name)
         super(AvgPool1d, self).__init__(kernel_size, stride, pad_mode)
-        self.kernel_size = (1, kernel_size)
-        self.stride = (1, stride)
-        self.avg_pool = P.AvgPool(kernel_size=self.kernel_size,
-                                  strides=self.stride,
-                                  pad_mode=self.pad_mode)
-        self.shape = F.shape
-        self.reduce_mean = P.ReduceMean(keep_dims=True)
-        self.slice = P.Slice()
-        self.expand = P.ExpandDims()
-        self.squeeze = P.Squeeze(2)
+        validator.check_int(self.kernel_size, 1, validator.GE, "kernel_size", self.cls_name)
+        validator.check_int(self.stride, 1, validator.GE, "stride", self.cls_name)
+        if pad_mode.upper() == 'PAD' or padding != 0 or ceil_mode or not count_include_pad:
+            padding = _cal_padding(padding, self.cls_name, 1)
+            self.is_expand_3d = True
+            kernel_size = (1, 1, self.kernel_size)
+            stride = (1, 1, self.stride)
+            self.avg_pool = P.AvgPool3D(kernel_size=kernel_size, strides=stride, pad_mode=pad_mode, pad=padding,
+                                        ceil_mode=ceil_mode,
+                                        count_include_pad=count_include_pad)
+        else:
+            self.is_expand_3d = False
+            self.kernel_size = (1, self.kernel_size)
+            self.stride = (1, self.stride)
+            self.avg_pool = P.AvgPool(kernel_size=self.kernel_size,
+                                      strides=self.stride,
+                                      pad_mode=self.pad_mode)
+            self.shape = F.shape
+            self.reduce_mean = P.ReduceMean(keep_dims=True)
+            self.slice = P.Slice()
+            self.expand = P.ExpandDims()
+            self.squeeze = P.Squeeze(2)
 
     def construct(self, x):
-        x = F.depend(x, _shape_check(self.shape(x), self.cls_name))
-        batch, channel, width = self.shape(x)
-        if width == self.kernel_size[1]:
-            x = self.reduce_mean(x, 2)
-        elif width - self.kernel_size[1] < self.stride[1]:
-            x = self.slice(x, (0, 0, 0), (batch, channel, self.kernel_size[1]))
-            x = self.reduce_mean(x, 2)
-        else:
-            x = self.expand(x, 2)
+        expand_batch = False
+        if x.ndim == 2:
+            x = x.unsqueeze(0)
+            expand_batch = True
+        if self.is_expand_3d:
+            x = x.unsqueeze(2).unsqueeze(3)
             x = self.avg_pool(x)
-            x = self.squeeze(x)
+            x = x.squeeze(3).squeeze(2)
+        else:
+            _shape_check(self.shape(x), self.cls_name)
+            batch, channel, width = self.shape(x)
+            if width == self.kernel_size[1]:
+                x = self.reduce_mean(x, 2)
+            elif width - self.kernel_size[1] < self.stride[1]:
+                x = self.slice(x, (0, 0, 0), (batch, channel, self.kernel_size[1]))
+                x = self.reduce_mean(x, 2)
+            else:
+                x = self.expand(x, 2)
+                x = self.avg_pool(x)
+                x = self.squeeze(x)
+        if expand_batch:
+            x = x.squeeze(0)
         return x
 
 
-@constexpr
+@_primexpr
 def _adaptive_shape_check(in_shape, output_size, prim_name):
     """Check shape."""
     msg_prefix = "For {}, the".format(prim_name)
@@ -796,18 +1215,18 @@ class AdaptiveAvgPool1d(Cell):
         output_size (int): the target output size :math:`L_{out}`.
 
     Inputs:
-        - **x** (Tensor) - Tensor of shape :math:`(N, C_{in}, L_{in})`, with float16 or float32 data type.
+        - **input** (Tensor) - Tensor of shape :math:`(N, C_{in}, L_{in})`, with float16 or float32 data type.
 
     Outputs:
-        Tensor of shape :math:`(N, C_{in}, L_{out})`, has the same type as `x`.
+        Tensor of shape :math:`(N, C_{in}, L_{out})`, has the same type as `input`.
 
     Raises:
         TypeError: If `output_size` is not an int.
-        TypeError: If `x` is neither float16 nor float32.
+        TypeError: If `input` is neither float16 nor float32.
         ValueError: If `output_size` is less than 1.
-        ValueError: If length of shape of `x` is not equal to 3.
-        ValueError: If the last dimension of `x` is smaller than `output_size`.
-        ValueError: If the last dimension of `x` is not divisible by `output_size`.
+        ValueError: If length of shape of `input` is not equal to 3.
+        ValueError: If the last dimension of `input` is smaller than `output_size`.
+        ValueError: If the last dimension of `input` is not divisible by `output_size`.
 
 
     Supported Platforms:
@@ -818,8 +1237,8 @@ class AdaptiveAvgPool1d(Cell):
         >>> from mindspore import Tensor, nn
         >>> import numpy as np
         >>> pool = nn.AdaptiveAvgPool1d(output_size=2)
-        >>> x = Tensor(np.random.randint(0, 10, [1, 3, 6]), mindspore.float32)
-        >>> output = pool(x)
+        >>> input = Tensor(np.random.randint(0, 10, [1, 3, 6]), mindspore.float32)
+        >>> output = pool(input)
         >>> result = output.shape
         >>> print(result)
         (1, 3, 2)
@@ -829,30 +1248,30 @@ class AdaptiveAvgPool1d(Cell):
         """Initialize AdaptiveAvgPool1d."""
         super(AdaptiveAvgPool1d, self).__init__()
         validator.check_value_type('output_size', output_size, [int], self.cls_name)
-        validator.check_int(output_size, 1, Rel.GE, "output_size", self.cls_name)
+        validator.check_int(output_size, 1, validator.GE, "output_size", self.cls_name)
         self.shape = F.shape
         self.expand = P.ExpandDims()
         self.squeeze = P.Squeeze(2)
         self.output_size = output_size
         self.dtype = P.DType()
 
-    def construct(self, x):
-        _adaptive_shape_check(self.shape(x), self.output_size, self.cls_name)
-        _adaptive_dtype_check(self.dtype(x), self.cls_name)
+    def construct(self, input):
+        _adaptive_shape_check(self.shape(input), self.output_size, self.cls_name)
+        _adaptive_dtype_check(self.dtype(input), self.cls_name)
 
-        _, _, width = self.shape(x)
+        _, _, width = self.shape(input)
         stride = width // self.output_size
         kernel_size = width - (self.output_size - 1) * stride
 
         stride = (1, width // self.output_size)
         kernel_size = (1, kernel_size)
 
-        x = self.expand(x, 2)
+        input = self.expand(input, 2)
         avg_pool = P.AvgPool(kernel_size=kernel_size, strides=stride)
-        x = avg_pool(x)
-        x = self.squeeze(x)
+        input = avg_pool(input)
+        input = self.squeeze(input)
 
-        return x
+        return input
 
 
 class AdaptiveAvgPool2d(Cell):
@@ -880,7 +1299,7 @@ class AdaptiveAvgPool2d(Cell):
             If it is None, it means the output size is the same as the input size.
 
     Inputs:
-        - **x** (Tensor) - The input of AdaptiveAvgPool2d, which is a 3D or 4D tensor,
+        - **input** (Tensor) - The input of AdaptiveAvgPool2d, which is a 3D or 4D tensor,
           with float16, float32 or float64 data type.
 
     Outputs:
@@ -888,9 +1307,9 @@ class AdaptiveAvgPool2d(Cell):
 
     Raises:
         ValueError: If `output_size` is a tuple and the length of `output_size` is not 2.
-        TypeError: If `x` is not a Tensor.
-        TypeError: If dtype of `x` is not float16, float32 or float64.
-        ValueError: If the dimension of `x` is less than or equal to the dimension of `output_size`.
+        TypeError: If `input` is not a Tensor.
+        TypeError: If dtype of `input` is not float16, float32 or float64.
+        ValueError: If the dimension of `input` is less than or equal to the dimension of `output_size`.
 
     Supported Platforms:
         ``GPU``
@@ -911,8 +1330,8 @@ class AdaptiveAvgPool2d(Cell):
         super(AdaptiveAvgPool2d, self).__init__()
         self.adaptive_avgpool2d = P.AdaptiveAvgPool2D(output_size)
 
-    def construct(self, x):
-        return self.adaptive_avgpool2d(x)
+    def construct(self, input):
+        return self.adaptive_avgpool2d(input)
 
 
 class AdaptiveAvgPool3d(Cell):
@@ -921,14 +1340,14 @@ class AdaptiveAvgPool3d(Cell):
     That is, for any input size, the size of the specified output is :math:`(D, H, W)`.
     The number of output features is equal to the number of input planes.
 
-    Suppose the last 3 dimension size of x is :math:`(inD, inH, inW)`, then the last 3 dimension size of output is
+    Suppose the last 3 dimension size of input is :math:`(inD, inH, inW)`, then the last 3 dimension size of output is
     :math:`(outD, outH, outW)`.
 
     .. math::
         \begin{array}{ll} \\
             \forall \quad od \in [0,outD-1], oh \in [0,outH-1], ow \in [0,outW-1]\\
             output[od,oh,ow] = \\
-            \qquad mean(x[istartD:iendD+1,istartH:iendH+1,istartW:iendW+1])\\
+            \qquad mean(input[istartD:iendD+1,istartH:iendH+1,istartW:iendW+1])\\
             where,\\
             \qquad istartD= \left\lceil \frac{od * inD}{outD} \right\rceil \\
             \qquad iendD=\left\lfloor \frac{(od+1)* inD}{outD} \right\rfloor \\
@@ -940,24 +1359,24 @@ class AdaptiveAvgPool3d(Cell):
 
     Args:
         output_size (Union[int, tuple]): The target output size. `ouput_size` can be a tuple :math:`(D, H, W)`,
-            or an int D for :math:`(D, D, D)`. :math:`(D)`, :math:`(H)` and :math:`(W)` can be int or None
+            or an int D for :math:`(D, D, D)`. :math:`D`, :math:`H` and :math:`W` can be int or None
             which means the output size is the same as that of the input.
 
     Inputs:
-        - **x** (Tensor) - The input of AdaptiveAvgPool3d, which is a 5D or 4D Tensor,
+        - **input** (Tensor) - The input of AdaptiveAvgPool3d, which is a 5D or 4D Tensor,
           with float16, float32 or float64 data type.
 
     Outputs:
-        Tensor, with the same type as the `x`.
+        Tensor, with the same type as the `input`.
 
     Raises:
-        TypeError: If `x` is not a Tensor.
-        TypeError: If dtype of `x` is not float16, float32 or float64.
-        ValueError: If the dimension of `x` is not 4D or 5D.
+        TypeError: If `input` is not a Tensor.
+        TypeError: If dtype of `input` is not float16, float32 or float64.
+        ValueError: If the dimension of `input` is not 4D or 5D.
         ValueError: If `output_size` value is not positive.
 
     Supported Platforms:
-        ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> # case 1: output_size=(3, 3, 4)
@@ -991,8 +1410,8 @@ class AdaptiveAvgPool3d(Cell):
         super(AdaptiveAvgPool3d, self).__init__()
         self.adaptive_avg_pool3d = AdaptiveAvgPool3D(output_size)
 
-    def construct(self, x):
-        return self.adaptive_avg_pool3d(x)
+    def construct(self, input):
+        return self.adaptive_avg_pool3d(input)
 
 
 class AdaptiveMaxPool1d(Cell):
@@ -1043,7 +1462,7 @@ class AdaptiveMaxPool1d(Cell):
     def __init__(self, output_size):
         """Initialize AdaptiveMaxPool1d."""
         super(AdaptiveMaxPool1d, self).__init__()
-        validator.check_int(output_size, 1, Rel.GE, "output_size", self.cls_name)
+        validator.check_int(output_size, 1, validator.GE, "output_size", self.cls_name)
         validator.check_value_type('output_size', output_size, [int], self.cls_name)
         self.expand = P.ExpandDims()
         self.squeeze = P.Squeeze(2)
@@ -1092,43 +1511,41 @@ class AdaptiveMaxPool2d(Cell):
         \end{align}
 
     Note:
-        Ascend platform only supports float16 type for input_x.
+        Ascend platform only supports float16 type for input.
 
     Args:
-        output_size (Union[int, tuple]): The target output size is H x W.
-            ouput_size can be a tuple, or a single H for H x H, and H and W can be int or None
-            which means the output size is the same as the input.
-
+        output_size (Union[int, tuple]): The target output size. `ouput_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.
             Default: False.
 
     Inputs:
-        - **input_x** (Tensor) - The input of AdaptiveMaxPool2d, which is a 3D or 4D tensor,
+        - **input** (Tensor) - The input of AdaptiveMaxPool2d, which is a 3D or 4D tensor,
           with float16, float32 or float64 data type.
 
     Outputs:
-        Tensor, with the same type as the `input_x`.
-
-        Shape of the output is `input_x_shape[:len(input_x_shape) - len(out_shape)] + out_shape`.
+        Tensor, with the same type as the `input`.
+        Shape of the output is `input_shape[:len(input_shape) - len(out_shape)] + out_shape`.
 
     Raises:
         TypeError: If `output_size` is not int or tuple.
-        TypeError: If `input_x` is not a tensor.
+        TypeError: If `input` is not a tensor.
         TypeError: If `return_indices` is not a bool.
-        TypeError: If dtype of `input_x` is not float16, float32 or float64.
+        TypeError: If dtype of `input` is not float16, float32 or float64.
         ValueError: If `output_size` is a tuple and the length of `output_size` is not 2.
-        ValueError: If the dimension of `input_x` is not NCHW or CHW.
+        ValueError: If the dimension of `input` is not NCHW or CHW.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> # case 1: output_size=(None, 2)
-        >>> input_x = Tensor(np.array([[[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]],
+        >>> input = Tensor(np.array([[[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]],
         ...                             [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]],
         ...                             [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]]]), mindspore.float32)
         >>> adaptive_max_pool_2d = nn.AdaptiveMaxPool2d((None, 2))
-        >>> output = adaptive_max_pool_2d(input_x)
+        >>> output = adaptive_max_pool_2d(input)
         >>> print(output)
         [[[[2. 3.]
            [5. 6.]
@@ -1141,7 +1558,7 @@ class AdaptiveMaxPool2d(Cell):
            [8. 9.]]]]
         >>> # case 2: output_size=2
         >>> adaptive_max_pool_2d = nn.AdaptiveMaxPool2d(2)
-        >>> output = adaptive_max_pool_2d(input_x)
+        >>> output = adaptive_max_pool_2d(input)
         >>> print(output)
         [[[[5. 6.]
            [8. 9.]]
@@ -1151,7 +1568,7 @@ class AdaptiveMaxPool2d(Cell):
            [8. 9.]]]]
         >>> # case 3: output_size=(1, 2)
         >>> adaptive_max_pool_2d = nn.AdaptiveMaxPool2d((1, 2))
-        >>> output = adaptive_max_pool_2d(input_x)
+        >>> output = adaptive_max_pool_2d(input)
         >>> print(output)
         [[[[8. 9.]]
           [[8. 9.]]
@@ -1161,51 +1578,51 @@ class AdaptiveMaxPool2d(Cell):
     def __init__(self, output_size, return_indices=False):
         """Initialize AdaptiveMaxPool2d."""
         super(AdaptiveMaxPool2d, self).__init__()
-        self.adaptive_max_pool2d = AdaptiveMaxPool2D(output_size, return_indices)
+        validator.check_value_type('return_indices', return_indices, [bool], self.cls_name)
+        self.adaptive_max_pool2d = AdaptiveMaxPool2D(output_size)
+        self.return_indices = return_indices
 
-    def construct(self, input_x):
-        return self.adaptive_max_pool2d(input_x)
+    def construct(self, input):
+        output = self.adaptive_max_pool2d(input)
+        if self.return_indices:
+            return output
+        return output[0]
 
 
 class AdaptiveMaxPool3d(Cell):
     r"""
-    Applies a 3D adaptive max pooling over an input signal composed of several input planes.
-
-    The output is of size :math:`(D, H, W)`, for any input size.
-    The number of output features is equal to the number of input planes.
+    Calculates the 3D adaptive max pooling for an input Tensor.
+    That is, for any input size, the size of the specified output is :math:`(D, H, W)`.
 
     Args:
-        output_size (Union[int, tuple]): The target output size is :math:`(D, H, W)`.
-            `ouput_size` can be a tuple with 3 elements, or a single D for :math:`(D, D, D)`. :math:`D`,
-            :math:`H` and :math:`W` can be int or None which means the output size is the same as that of
-            the input.
-        return_indices (bool): If `return_indices` is True, the indices of max value would be output.
-            Default: False.
+        output_size (Union[int, tuple]): The specified output size, which is a positive integer that represents depth,
+            height and width, or a tuple of three positive integers that represent depth, height and width respectively.
+            If it is None, the output size and input size of the corresponding dimension are the same.
+        return_indices (bool, optional): If `return_indices` is True, the indices of max value would be output.
+            Otherwise, the indices will not be returned. Default: False.
 
     Inputs:
-        - **x** (Tensor) - Tensor, has shape of :math:`(C, D, H, W)` or :math:`(N, C, D, H, W)` . The suppoerted dtypes
-          are int8, int16, int32, int64, uint8, uint16, uint32, uint64, float16, float32 and float64 data type.
+        - **input** (Tensor) - Tensor, has shape of :math:`(C, D, H, W)` or :math:`(N, C, D, H, W)`.
 
     Outputs:
-        - **y** (Tensor) - Tensor, has the same number of dims and data type as the `x` .
+        - **y** (Tensor) - Tensor, has the same number of dims and data type as the `input` .
         - **argmax** (Tensor) - Tensor, the indices of the maximum values along with the outputs, has the same shape as
           `y` and a dtype of int32. Return this only when `return_indices` is True.
 
     Raises:
-        TypeError: If `x` is not a Tensor.
-        ValueError: If the dimensions number of `x` is not 4 or 5.
-        TypeError: If dtype of `x` is not int8, int16, int32, int64, uint8, uint16, uint32, uint64,
-                   float16, float32 or float64.
+        TypeError: If `input` is not a Tensor.
+        ValueError: If the dimensions number of `input` is not 4 or 5.
+        TypeError: If dtype of `input` is not int, uint or float.
         ValueError: If `output_size` is neither an int nor a tuple with shape (3,).
 
     Supported Platforms:
         ``GPU`` ``CPU``
 
     Examples:
-        >>> x = Tensor(np.arange(0,36).reshape((1, 3, 3, 4)).astype(np.float32))
+        >>> input = Tensor(np.arange(0,36).reshape((1, 3, 3, 4)).astype(np.float32))
         >>> output_size = (1, 1, 2)
         >>> net = nn.AdaptiveMaxPool3d(output_size, True)
-        >>> output = net(x)
+        >>> output = net(input)
         >>> print(output[0].asnumpy())
         [[[[33. 35.]]]]
         >>> print(output[1].asnumpy())
@@ -1219,8 +1636,8 @@ class AdaptiveMaxPool3d(Cell):
         self.return_indices = return_indices
         self.adaptive_max_pool3d = AdaptiveMaxPool3D()
 
-    def construct(self, x):
-        output = self.adaptive_max_pool3d(x, self.output_size)
+    def construct(self, input):
+        output = self.adaptive_max_pool3d(input, self.output_size)
         if self.return_indices:
             return output
         return output[0]
@@ -1228,12 +1645,11 @@ class AdaptiveMaxPool3d(Cell):
 
 class FractionalMaxPool2d(Cell):
     r"""
-    Applies a 2D fractional max pooling to an input signal composed of multiple input planes.
-    The max-pooling operation is applied in kH × kW regions by a stochastic step size determined by
-    the target output size. For any input size, the size of the specified output is H x W. The number
-    of output features is equal to the number of input planes.
+    Applies the 2D FractionalMaxPool operatin over input. The output Tensor shape can be determined by either
+    `output_size` or `output_ratio`, and the step size is determined by `_random_samples`.
+    `output_size` or `output_ratio` cannot be used or set to None at the same time.
 
-    Fractional MaxPooling is described in the paper `Fractional Max-Pooling <https://arxiv.org/pdf/1412.6071>`_.
+    Refer to the paper `Fractional MaxPooling by Ben Graham <https://arxiv.org/abs/1412.6071>`_  for more details.
 
     Args:
         kernel_size (Union[int, tuple[int]]): The size of kernel used to take the maximum value,
@@ -1241,43 +1657,38 @@ class FractionalMaxPool2d(Cell):
             of two int numbers that represent height and width respectively.
             The value must be a positive integer.
         output_size (Union[int, tuple[int]], optional): The Shape of the target `output_size`,
-            is an int number that represents height and width, or a tuple
-            of two int numbers that represent height and width respectively.
-            The value must be a positive integer.
-            Default: None.
+            is a positive int that represents height and width, or a tuple of two positive integers that represent
+            height and width respectively. The value must be a positive integer. If None, the shape of the target will
+            be determined by `output_ratio`. Default: None.
         output_ratio (Union[float, tuple[float]], optional): The ratio of target output shape to input shape.
             Specifying the size of the output tensor by using a ratio of the input size.
-            Data type : float16, float32, double, and value is between (0, 1).
-            Default: None.
-        return_indices (bool, optional): If `return_indices` is True, the indices of max value would be output.
-            Default: False.
-        _random_samples (Tensor, optional): The random step of FractionalMaxPool2d, which is a 3D tensor.
-            Tensor of data type : float16, float32, double, and value is between (0, 1).
-            Supported shape :math:`(N, C, 2)`.
-            Default: None.
+            Data type : float16, float32, float64, and value is between (0, 1). If None, the shape of the target will be
+            determined by `output_size`. Default: None.
+        return_indices (bool, optional): Whether to return the indices of max value. Default: False.
+        _random_samples (Tensor, optional): The random step of FractionalMaxPool2d, a Tensor of shape :math:`(N, C, 2)`
+            whose elements are within the range of :math:`(0, 1)`. Supported data type : float16, float32, float64.
+            If None, no random step will be set. Default: None.
 
     Inputs:
-        - **input_x** (Tensor) - Tensor of shape :math:`(N, C, H_{in}, W_{in})`,
+        - **input** (Tensor) - Tensor of shape :math:`(N, C, H_{in}, W_{in})`,
           with float16, float32, float64, int32, int64 data type.
 
     Outputs:
-        - **y** (Tensor) - Has the same type as the `input_x`.
-          Has the shape :math:`(N, C, H, W)`.
-
+        - **y** (Tensor) - Has the same type as the `input`. Has the shape :math:`(N, C, H, W)`.
         - **argmax** (Tensor) - The indices along with the outputs, which is a Tensor, with the same shape as the
-          `y` and int64 data type. It will output only when `return_indices` is True.
+          `y` and int64 data type. It will be returned only when `return_indices` is True.
 
     Raises:
-        TypeError: If data type of `input_x` is not one of the following: float16, float32, float64, int32, int64.
+        TypeError: If data type of `input` is not one of the following: float16, float32, float64, int32, int64.
         TypeError: If data type of `_random_samples` is not one of the following: float16, float32, float64.
         ValueError: If `kernel_size` is not a number and `kernel_size` is not a tuple of length 2.
         ValueError: If `output_size` is not a number and `output_size` is not a tuple of length 2.
         ValueError: If the sum of `kernel_size` , `output_size` and -1 is larger than the corresponding
-                    dimension of `input_x`.
+                    dimension of `input`.
         ValueError: If the dimension of `_random_samples` is not 3.
         ValueError: if `output_size` and `output_ratio` are None at the same time.
-        ValueError: If the first dimension size of `input_x` and `_random_samples` is not equal.
-        ValueError: If the second dimension size of `input_x` and `_random_samples` is not equal.
+        ValueError: If the first dimension size of `input` and `_random_samples` is not equal.
+        ValueError: If the second dimension size of `input` and `_random_samples` is not equal.
         ValueError: If the third dimension size of `_random_samples` is not 2.
 
     Supported Platforms:
@@ -1289,7 +1700,7 @@ class FractionalMaxPool2d(Cell):
         >>> from mindspore import nn
         >>> from mindspore import Tensor
         >>> import mindspore.common.dtype as mstype
-        >>> input_x = Tensor(np.array([0.3220, 0.9545, 0.7879, 0.0975, 0.3698,
+        >>> input = Tensor(np.array([0.3220, 0.9545, 0.7879, 0.0975, 0.3698,
         ...                            0.5135, 0.5740, 0.3435, 0.1895, 0.8764,
         ...                            0.9581, 0.4760, 0.9014, 0.8522, 0.3664,
         ...                            0.4980, 0.9673, 0.9879, 0.6988, 0.9022,
@@ -1297,7 +1708,7 @@ class FractionalMaxPool2d(Cell):
         >>> _random_samples = Tensor(np.array([[[0.8, 0.8]]]), mstype.float32)
         >>> net = nn.FractionalMaxPool2d(kernel_size=2, output_size=(2, 2), _random_samples=_random_samples,
         ...                              return_indices=True)
-        >>> y, argmax = net(input_x)
+        >>> y, argmax = net(input)
         >>> y
         [[[[0.9545 0.8764]
            [0.9673 0.9852]]]]
@@ -1306,7 +1717,7 @@ class FractionalMaxPool2d(Cell):
            [16 24]]]]
         >>> net = nn.FractionalMaxPool2d(kernel_size=2, output_ratio=(0.5, 0.5), _random_samples=_random_samples,
         ...                              return_indices=True)
-        >>> y, argmax = net(input_x)
+        >>> y, argmax = net(input)
         >>> print(y)
         [[[[0.9545 0.8764]
            [0.9673 0.9852]]]]
@@ -1324,16 +1735,16 @@ class FractionalMaxPool2d(Cell):
         self.return_indices = return_indices
         self._random_samples = _random_samples
 
-    def construct(self, x):
-        return ops.fractional_max_pool2d(x, self.kernel_size, self.output_size, self.output_ratio, self.return_indices,
-                                         self._random_samples)
+    def construct(self, input):
+        return ops.fractional_max_pool2d(input, self.kernel_size, self.output_size, self.output_ratio,
+                                         self.return_indices, self._random_samples)
 
 
 class FractionalMaxPool3d(Cell):
     r"""
-    This operator applies a 3D fractional max pooling over an input signal composed of several input planes.
-    The max-pooling operation is applied in kD x kH x kW regions by a stochastic step size determined
-    by the target output size.The number of output features is equal to the number of input planes.
+    Applies the 3D FractionalMaxPool operatin over `input`. The output Tensor shape can be determined by either
+    `output_size` or `output_ratio`, and the step size is determined by `_random_samples`.
+    `output_size` or `output_ratio` cannot be used or set to None at the same time.
 
     Refer to the paper `Fractional MaxPooling by Ben Graham <https://arxiv.org/abs/1412.6071>`_  for more details.
 
@@ -1341,28 +1752,25 @@ class FractionalMaxPool3d(Cell):
     D the feature depth, H is the feature height, and W is the feature width.
 
     Args:
-        kernel_size (Union[int, tuple[int]]): The size of kernel used to take the maximum value,
-            is an int number 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.
-        output_size (Union[int, tuple[int]], optional): The Shape of the target `output_size`,
-            is an int number that represents depth, height and width, or a tuple
-            of three int numbers that represent depth, height and width respectively.
-            The value must be a positive integer.
-            Default: None.
+        kernel_size (Union[int, tuple[int]]): The size of kernel used to take the maximum value, is a positive int
+            that represents depth, height and width of the kernel, or a tuple of three positive integers that represent
+            depth, height and width respectively.
+        output_size (Union[int, tuple[int]], optional): The shape of the target `output_size`,
+            is an int number that represents depth, height and width, or a tuple of three positive integers that
+            represents depth, height and width respectively. If None, the shape of the target will be determined by
+            `output_ratio`. Default: None.
         output_ratio (Union[float, tuple[float]], optional): The ratio of target output shape to input shape.
             Specifying the size of the output tensor by using a ratio of the input size.
-            Data type : float16, float32, double, and value is between (0, 1).
-            Default: None.
-        return_indices (bool, optional): If `return_indices` is True, the indices of max value would be output.
-            Default: False.
-        _random_samples (Tensor, optional): The random step of FractionalMaxPool3d, which is a 3D tensor.
-            Tensor of data type : float16, float32, double, and value is between (0, 1).
-            Supported shape :math:`(N, C, 3)`
+            Data type : float16, float32, float64, and value is between (0, 1). If None, the shape of the target will be
+            determined by `output_size`.Default: None.
+        return_indices (bool, optional): Whether to return the indices of max value. Default: False.
+        _random_samples (Tensor, optional): The random step of FractionalMaxPool2d, a Tensor of shape :math:`(N, C, 3)`
+            whose elements are within the range of :math:`(0, 1)`. Supported data type : float16, float32, float64.
+            If None, no random step will be set. Default: None.
 
     Inputs:
-        - **input_x** (Tensor) - The input of FractionalMaxPool3d, which is a 4D or 5D tensor.
-          Tensor of data type : float16, float32, double, int32, int64.
+        - **input** (Tensor) - The input of FractionalMaxPool3d, which is a 4D or 5D tensor.
+          Tensor of data type : float16, float32, float64, int32, int64.
           Supported shape :math:`(N, C, D_{in}, H_{in}, W_{in})` .
 
     Outputs:
@@ -1374,17 +1782,17 @@ class FractionalMaxPool3d(Cell):
           `y` and int32 data type. It will output only when `return_indices` is True.
 
     Raises:
-        TypeError: If `input_x` is not a 4D or 5D tensor.
+        TypeError: If `input` is not a 4D or 5D tensor.
         TypeError: If `_random_samples` is not a 3D tensor.
-        TypeError: If data type of `imput_x` is not float16, float32, double, int32, int64.
-        TypeError: If dtype of `_random_samples` is not float16, float32, double.
+        TypeError: If data type of `imput_x` is not float16, float32, float64, int32, int64.
+        TypeError: If dtype of `_random_samples` is not float16, float32, float64.
         TypeError: If dtype of `argmax` is not int32, int64.
         ValueError: If `output_size` is a tuple and if `output_size` length is not 3.
         ValueError: If `kernel_size` is a tuple and if `kernel_size` length is not 3.
         ValueError: If numbers in `output_size` or `kernel_size` is not positive.
         ValueError: if `output_size` and `output_ratio` are None at the same time.
-        ValueError: If the first dimension size of `input_x` and `_random_samples` is not equal.
-        ValueError: If the second dimension size of `input_x` and `_random_samples` is not equal.
+        ValueError: If the first dimension size of `input` and `_random_samples` is not equal.
+        ValueError: If the second dimension size of `input` and `_random_samples` is not equal.
         ValueError: If the third dimension size of `_random_samples` is not 3.
 
     Supported Platforms:
@@ -1398,14 +1806,14 @@ class FractionalMaxPool3d(Cell):
         >>> x = Tensor(np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16])
         ...            .reshape([1, 1, 2, 2, 4]), mstype.float32)
         >>> _random_samples = Tensor(np.array([0.7, 0.7, 0.7]).reshape([1, 1, 3]), mstype.float32)
-        >>> net = nn.FractionalMaxPool3d(kernel_size=(1.0, 1.0, 1.0), output_size=(1, 1, 3),
+        >>> net = nn.FractionalMaxPool3d(kernel_size=(1, 1, 1), output_size=(1, 1, 3),
         ...                              _random_samples=_random_samples, return_indices=True)
         >>> output, argmax = net(x)
         >>> print(output)
         [[[[[13. 14. 16.]]]]]
         >>> print(argmax)
         [[[[[12 13 15]]]]]
-        >>> net = nn.FractionalMaxPool3d(kernel_size=(1.0, 1.0, 1.0), output_ratio=(0.5, 0.5, 0.5),
+        >>> net = nn.FractionalMaxPool3d(kernel_size=(1, 1, 1), output_ratio=(0.5, 0.5, 0.5),
         ...                              _random_samples=_random_samples, return_indices=True)
         >>> output, argmax = net(x)
         >>> print(output)
@@ -1423,21 +1831,19 @@ class FractionalMaxPool3d(Cell):
         self.return_indices = return_indices
         self._random_samples = _random_samples
 
-    def construct(self, x):
-        return ops.fractional_max_pool3d(x, self.kernel_size, self.output_size, self.output_ratio, self.return_indices,
-                                         self._random_samples)
+    def construct(self, input):
+        return ops.fractional_max_pool3d(input, self.kernel_size, self.output_size, self.output_ratio,
+                                         self.return_indices, self._random_samples)
 
 
 class MaxUnpool1d(Cell):
     r"""
-    Computes a partial inverse of MaxPool1d.
+    Computes the inverse of :class:`mindspore.nn.MaxPool1d`.
 
-    MaxPool1d is not fully invertible, since the non-maximal values are lost.
+    MaxUnpool1d keeps the maximal value and set all position of non-maximal values to zero. Typically the input
+    is of shape :math:`(N, C, H_{in})` or :math:`(C, H_{in})`, and the output is of shape
+    :math:`(N, C, H_{out})` or :math:`(C, H_{out})`. The operation is as follows.
 
-    MaxUnpool1d takes in as input the output of MaxPool1d including the indices of the maximal values
-    and computes a partial inverse in which all non-maximal values are set to zero. Typically the input
-    is of shape :math:`(N, C, H_{in})` or :math:`(C, H_{in})`, and the output is of shape :math:`(N, C, H_{out}`
-    or :math:`(C, H_{out}`. The operation is as follows.
 
     .. math::
         \begin{array}{ll} \\
@@ -1447,7 +1853,7 @@ class MaxUnpool1d(Cell):
     Args:
         kernel_size (Union[int, tuple[int]]): The size of kernel used to take the maximum value.
         stride (Union[int, tuple[int]]): The distance of kernel moving,
-            If stride is 0, (0) or None, then stride equal to kernel_size. Default: None.
+            If stride is None, then stride equal to kernel_size. Default: None.
         padding (Union[int, tuple[int]]): The pad value to be filled. Default: 0.
 
     Inputs:
@@ -1459,8 +1865,8 @@ class MaxUnpool1d(Cell):
           Data type must be in int32 or int64.
         - **output_size** (tuple[int], optional) - The output size. Default: None.
           If output_size == (), then the shape of output computed by kernel_size, stride and padding.
-          If output_size != (), then output_size must be :math:`(N, C, H)` or
-          :math:`(C, H)` and output_size must belong to
+          If output_size != (), then output_size must be :math:`(N, C, H)` , :math:`(C, H)` or
+          :math:`(H)` and output_size must belong to
           :math:`[(N, C, H_{out} - stride[0]), (N, C, H_{out} + stride[0])]`.
 
     Outputs:
@@ -1488,11 +1894,12 @@ class MaxUnpool1d(Cell):
         >>> print(output.asnumpy())
         [[0. 2. 0. 4. 0. 6. 0. 8.]]
     """
+
     def __init__(self, kernel_size, stride=None, padding=0):
         """Initialize MaxUnpool1d."""
         super(MaxUnpool1d, self).__init__()
-        if not stride:
-            stride = 0
+        if stride is None:
+            stride = kernel_size
         self.kernel_size = kernel_size
         self.stride = stride
         self.padding = padding
@@ -1510,12 +1917,9 @@ class MaxUnpool1d(Cell):
 
 class MaxUnpool2d(Cell):
     r"""
-    Computes a partial inverse of MaxPool2d.
-
-    MaxPool2d is not fully invertible, since the non-maximal values are lost.
+    Computes the inverse of :class:`mindspore.nn.MaxPool2d`.
 
-    MaxUnpool2d takes in as input the output of MaxPool2d including the indices of the maximal values
-    and computes a partial inverse in which all non-maximal values are set to zero. Typically the input
+    MaxUnpool2d keeps the maximal value and set all position of non-maximal values to zero. Typically the input
     is of shape :math:`(N, C, H_{in}, W_{in})` or :math:`(C, H_{in}, W_{in})`, and the output is of
     shape :math:`(N, C, H_{out}, W_{out})` or :math:`(C, H_{out}, W_{out})`. The operation is as follows.
 
@@ -1532,7 +1936,7 @@ class MaxUnpool2d(Cell):
         stride (Union[int, tuple[int]]): The distance of kernel moving, an int number that represents
             the height and width of movement are both stride, or a tuple of two int numbers that
             represent height and width of movement respectively.
-            If stride is 0, (0, 0) or None, then stride equal to kernel_size. Default: None.
+            If stride is None, then stride equal to kernel_size. Default: None.
         padding (Union[int, tuple[int]]): The pad value to be filled. Default: 0. If `padding` is an integer,
             the paddings of height and width are the same, equal to padding. If `padding` is a tuple of two
             integers, the padding of height and width equal to padding[0] and padding[1] correspondingly.
@@ -1546,9 +1950,9 @@ class MaxUnpool2d(Cell):
           Data type must be in int32 or int64.
         - **output_size** (tuple[int], optional) - The output size. Default: None.
           If output_size == (), then the shape of output computed by kernel_size, stride and padding.
-          If output_size != (), then output_size must be :math:`(N, C, H, W)` and output_size must belong to
-          :math:`[(N, C, H_{out} - stride[0], W_{out} - stride[1]),
-          (N, C, H_{out} + stride[0], W_{out} + stride[1])]`.
+          If output_size != (), then output_size must be :math:`(N, C, H, W)`, :math:`(C, H, W)` or
+          :math:`(H, W)` and output_size must belong to
+          :math:`[(N, C, H_{out} - stride[0], W_{out} - stride[1]), (N, C, H_{out} + stride[0], W_{out} + stride[1])]`.
 
     Outputs:
         Tensor, with shape :math:`(N, C, H_{out}, W_{out})` or :math:`(C, H_{out}, W_{out})`,
@@ -1577,11 +1981,12 @@ class MaxUnpool2d(Cell):
         [[[[0. 1.]
            [8. 9.]]]]
     """
+
     def __init__(self, kernel_size, stride=None, padding=0):
         """Initialize MaxUnpool2d."""
         super(MaxUnpool2d, self).__init__()
-        if not stride:
-            stride = 0
+        if stride is None:
+            stride = kernel_size
         self.kernel_size = kernel_size
         self.stride = stride
         self.padding = padding
@@ -1599,12 +2004,9 @@ class MaxUnpool2d(Cell):
 
 class MaxUnpool3d(Cell):
     r"""
-    Computes a partial inverse of MaxPool3d.
-
-    MaxPool3d is not fully invertible, since the non-maximal values are lost.
+    Computes the inverse of :class:`mindspore.nn.MaxPool3d`.
 
-    MaxUnpool3d takes in as input the output of MaxPool3d including the indices of the maximal
-    values and computes a partial inverse in which all non-maximal values are set to zero.
+    MaxUnpool3d keeps the maximal value and set all position of non-maximal values to zero.
     Typically the input is of shape :math:`(N, C, D_{in}, H_{in}, W_{in})` or :math:`(C, D_{in}, H_{in}, W_{in})`,
     and the output is of shape :math:`(N, C, D_{out}, H_{out}, W_{out})` or :math:`(C, D_{out}, H_{out}, W_{out})`.
     The operation is as follows.
@@ -1623,7 +2025,7 @@ class MaxUnpool3d(Cell):
         stride (Union[int, tuple[int]]): The distance of kernel moving, an int number that represents
             the depth, height and width of movement are both stride, or a tuple of three int numbers that
             represent depth, height and width of movement respectively.
-            If stride is 0, (0, 0, 0) or None, then stride equal to kernel_size. Default: None.
+            If stride is None, then stride equal to kernel_size. Default: None.
         padding (Union[int, tuple[int]]): The pad value to be filled. Default: 0. If `padding` is an integer,
             the paddings of depth, height and width are the same, equal to padding. If `padding` is a tuple of three
             integers, the padding of depth, height and width equal to padding[0], padding[1] and padding[2]
@@ -1638,8 +2040,8 @@ class MaxUnpool3d(Cell):
           Data type must be in int32 or int64.
         - **output_size** (tuple[int], optional) - The output size. Default: None.
           If output_size == (), then the shape of output computed by kernel_size, stride and padding.
-          If output_size != (), then output_size must be :math:`(N, C, D, H, W)` or :math:`(C, D, H, W)` and
-          output_size must belong to
+          If output_size != (), then output_size must be :math:`(N, C, D, H, W)` , :math:`(C, D, H, W)` or
+          :math:`(D, H, W)` and output_size must belong to
           :math:`[(N, C, D_{out} - stride[0], H_{out} - stride[1], W_{out} - stride[2]),
           (N, C, D_{out} + stride[0], H_{out} + stride[1], W_{out} + stride[2])]`.
 
@@ -1670,10 +2072,11 @@ class MaxUnpool3d(Cell):
         [[[[[0. 1.]
             [8. 9.]]]]]
     """
+
     def __init__(self, kernel_size, stride=None, padding=0):
         super(MaxUnpool3d, self).__init__()
-        if not stride:
-            stride = 0
+        if stride is None:
+            stride = kernel_size
         self.kernel_size = kernel_size
         self.stride = stride
         self.padding = padding