mindspore 2.0.0rc1__cp38-none-any.whl → 2.2.0__cp38-none-any.whl

mindspore/nn/layer/pooling.py

@@ -96,16 +96,16 @@ class LPPool1d(Cell):
         f(X) = \sqrt[p]{\sum_{x \in X} x^{p}}
 
     Args:
-        norm_type (Union[int, float]): Type of normalization, represents p in the formula, can not be 0.
+        norm_type (Union[int, float]): Type of normalization, represents :math:`p` in the formula, can not be 0.
 
             - 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
-            the width of movement is stride, if the value is None, the default value `kernel_size` is used;
-        ceil_mode (bool): Whether to use ceil or floor to calculate output shape. Default: False.
+        stride (int): The distance of kernel moving, an int number that represents the width of movement is stride,
+            if the value is None, the default value `kernel_size` is used. Default: ``None`` .
+        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}, L_{in})` or :math:`(C_{in}, L_{in})`.
@@ -132,11 +132,9 @@ class LPPool1d(Cell):
 
     Examples:
         >>> import mindspore as ms
-        >>> import mindspore.nn as nn
-        >>> from mindspore import Tensor
         >>> import numpy as np
-        >>> a = Tensor(np.arange(2 * 3 * 4).reshape((2, 3, 4)), dtype=ms.float32)
-        >>> net = nn.LPPool1d(norm_type=1, kernel_size=3, stride=1)
+        >>> a = ms.Tensor(np.arange(2 * 3 * 4).reshape((2, 3, 4)), dtype=ms.float32)
+        >>> net = ms.nn.LPPool1d(norm_type=1, kernel_size=3, stride=1)
         >>> out = net(a)
         >>> print(out)
         [[[ 3.  6.]
@@ -170,7 +168,7 @@ class LPPool2d(Cell):
         f(X) = \sqrt[p]{\sum_{x \in X} x^{p}}
 
     Args:
-        norm_type(Union[int, float]) - Type of normalization, represents p in the formula, can not be 0.
+        norm_type(Union[int, float]) - Type of normalization, represents :math:`p` in the formula, can not be 0.
 
             - if p = 1, the result is the sum of the elements within the pooling kernel(proportional to average
               pooling).
@@ -182,8 +180,8 @@ class LPPool2d(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 the value is None,
-            the default value `kernel_size` is used;
-        ceil_mode(bool): Whether to use ceil or floor to calculate output shape. Default: False.
+            the default value `kernel_size` is used. Default: ``None`` .
+        ceil_mode(bool): Whether to use ceil or floor to calculate output shape. Default: ``False`` .
 
     Inputs:
         - **x** (Tensor) - Tensor of shape :math:`(N, C, H_{in}, W_{in})`.
@@ -213,11 +211,9 @@ class LPPool2d(Cell):
 
     Examples:
         >>> import mindspore as ms
-        >>> import mindspore.nn as nn
-        >>> from mindspore import Tensor
         >>> import numpy as np
-        >>> a = Tensor(np.arange(2 * 3 * 4 * 5).reshape((2, 3, 4, 5)), dtype=ms.float32)
-        >>> net = nn.LPPool2d(norm_type=1, kernel_size=3, stride=1)
+        >>> a = ms.Tensor(np.arange(2 * 3 * 4 * 5).reshape((2, 3, 4, 5)), dtype=ms.float32)
+        >>> net = ms.nn.LPPool2d(norm_type=1, kernel_size=3, stride=1)
         >>> out = net(a)
         >>> print(out)
         [[[[  54.   63.   72.]
@@ -295,24 +291,29 @@ class MaxPool3d(_PoolNd):
         kernel_size (Union[int, tuple[int]]): The size of kernel used to take the maximum value,
             is an int number or a single element tuple that represents depth, height and width of the kernel, or a tuple
             of three int numbers that represent depth, height and width respectively.
-            The value must be a positive integer. Default: 1.
+            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.
-            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.
+            Default: ``1`` .
+        pad_mode (str, optional): Specifies the padding mode with a padding value of 0. It can be set to:
+            ``"same"`` , ``"valid"`` or ``"pad"`` . Default: ``"valid"`` .
+
+            - ``"same"``: Pad the input around its depth/height/width dimension so that the shape of input and output
+              are the same when `stride` is set to ``1``.
+              The amount of padding to is calculated by the operator internally.  If the amount is even,
+              it isuniformly distributed around the input, if it is odd, the excess amount goes
+              to the front/right/bottom side.
+              If this mode is set, `padding` must be 0.
+            - ``"valid"``: No padding is applied to the input, and the output returns the maximum
+              possible depth, height and width. Extra pixels that could not complete a full stride will
+              be discarded. If this mode is set, `padding` must be 0.
+            - ``"pad"``: Pad the input with a specified amount. In this mode, the amount of padding
+              in the depth, height and width dimension is determined by the `padding` parameter.
+              If this mode is set, `padding` must be greater than or equal to 0.
 
-        padding (Union(int, tuple[int], list[int])): Pooling padding value. Default: 0.
+        padding (Union(int, tuple[int], list[int])): 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
@@ -320,10 +321,10 @@ class MaxPool3d(_PoolNd):
             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.
+            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
@@ -341,7 +342,7 @@ class MaxPool3d(_PoolNd):
           :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:
+        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
@@ -360,9 +361,9 @@ class MaxPool3d(_PoolNd):
         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 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
+        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'.
+        ValueError: If `padding` is non-zero when `pad_mode` is not ``"pad"``.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -373,13 +374,13 @@ class MaxPool3d(_PoolNd):
         >>> import numpy as np
         >>> 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)
+        >>> 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)
+        >>> pool2 = nn.MaxPool3d(kernel_size=2, stride=1, pad_mode="pad", padding=1, dilation=3, return_indices=False)
         >>> output2 = pool2(x)
         >>> print(output2.shape)
         (5, 3, 3, 5, 6)
@@ -437,34 +438,39 @@ class MaxPool2d(_PoolNd):
         kernel_size (Union[int, tuple[int]]): The size of kernel used to take the max value,
             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.
+            Default: ``1`` .
         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", "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.
+            represent height and width of movement respectively. Default: ``1`` .
+        pad_mode (str, optional): Specifies the padding mode with a padding value of 0. It can be set to:
+            ``"same"`` , ``"valid"`` or ``"pad"`` . Default: ``"valid"`` .
+
+            - ``"same"``: Pad the input around its edges so that the shape of input and output
+              are the same when `stride` is set to ``1``.
+              The amount of padding to is calculated by the operator internally, If the amount is even, it is
+              uniformly distributed around the input, if it is odd, the excess amount goes to the right/bottom side.
+              If this mode is set, `padding` must be 0.
+            - ``"valid"``: No padding is applied to the input, and the output returns the maximum
+              possible height and width. Extra pixels that could not complete a full stride will
+              be discarded. If this mode is set, `padding` must be 0.
+            - ``"pad"``: Pad the input with a specified amount. In this mode, the amount of padding
+              in the height and width directions is determined by the `padding` parameter.
+              If this mode is set, `padding` must be greater than or equal to 0.
 
-        padding (Union(int, tuple[int], list[int])): 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.
+        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'.
+            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})` or :math:`(C_{in},H_{in},W_{in})`.
@@ -492,30 +498,32 @@ class MaxPool2d(_PoolNd):
 
     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 `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 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 `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'.
+        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``
 
     Examples:
-        >>> pool = nn.MaxPool2d(kernel_size=3, stride=1)
-        >>> x = Tensor(np.random.randint(0, 10, [1, 2, 4, 4]), mindspore.float32)
+        >>> import mindspore as ms
+        >>> import numpy as np
+        >>> pool = ms.nn.MaxPool2d(kernel_size=3, stride=1)
+        >>> x = ms.Tensor(np.random.randint(0, 10, [1, 2, 4, 4]), ms.float32)
         >>> 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)
+        >>> x = ms.Tensor(np_x, ms.float32)
+        >>> pool2 = ms.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)
@@ -549,7 +557,7 @@ class MaxPool2d(_PoolNd):
         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' "
+                raise ValueError(f"For MaxPool2d, 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,
@@ -594,31 +602,33 @@ class MaxPool1d(_PoolNd):
         \text{input}(N_i, C_j, s_0 \times l + n)
 
     Args:
-        kernel_size (int): The size of kernel used to take the max value, Default: 1.
+        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", "valid" or "pad", not case sensitive.
-            Default: "valid".
-
-            - same: Adopts the way of completion. 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.
-
-            - 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.
+            the width of movement is stride, Default: ``1`` .
+        pad_mode (str, optional): Specifies the padding mode with a padding value of 0. It can be set to:
+            ``"same"`` , ``"valid"`` or ``"pad"`` . Default: ``"valid"`` .
+
+            - ``"same"``: Pad the input at the begin and end so that the shape of input and output
+              are the same when `stride` is set to ``1``.
+              The amount of padding to is calculated by the operator internally. If the amount is even, it is
+              uniformly distributed around the input, if it is odd, the excess padding is goes to the right side.
+              If this mode is set, `padding` must be 0.
+            - ``"valid"``: No padding is applied to the input, and the output returns the maximum
+              possible length. Extra pixels that could not complete a full stride will
+              be discarded. If this mode is set, `padding` must be 0.
+            - ``"pad"``: Pad the input with a specified amount. In this mode, the amount of padding
+              at the begin and end is determined by the `padding` parameter.
+              If this mode is set, `padding` must be greater than or equal to 0.
 
         padding (Union(int, tuple[int], list[int])): 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.
+            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_{in}, L_{in})` or :math:`(C_{in}, L_{in})`.
@@ -642,30 +652,33 @@ class MaxPool1d(_PoolNd):
 
     Raises:
         TypeError: If `kernel_size` or `strides` is not an int.
-        ValueError: If `pad_mode` is not 'valid', 'same' or 'pad', case-insensitive.
-        ValueError: If `data_format` is neither 'NCHW' nor 'NHWC'.
+        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 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 `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'.
+        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 numpy as np
         >>> mpool1 = nn.MaxPool1d(kernel_size=3, stride=1)
-        >>> x = Tensor(np.random.randint(0, 10, [1, 2, 4]), mindspore.float32)
+        >>> x = ms.Tensor(np.random.randint(0, 10, [1, 2, 4]), ms.float32)
         >>> 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)
+        >>> x = ms.Tensor(np_x, ms.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)
@@ -780,25 +793,29 @@ class AvgPool3d(_PoolNd):
     Args:
         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.
+            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`.
+            `kernel_size` is used. Default: ``1`` .
+        pad_mode (str, optional): Specifies the padding mode with a padding value of 0. It can be set to:
+            ``"same"`` , ``"valid"`` or ``"pad"`` . Default: ``"valid"`` .
+
+            - ``"same"``: Pad the input around its depth/height/width dimension so that the shape of input and output
+              are the same when `stride` is set to ``1``.
+              The amount of padding to is calculated by the operator internally.  If the amount is even,
+              it isuniformly distributed around the input, if it is odd, the excess amount goes
+              to the front/right/bottom side.
+              If this mode is set, `padding` must be 0.
+            - ``"valid"``: No padding is applied to the input, and the output returns the maximum
+              possible depth, height and width. Extra pixels that could not complete a full stride will
+              be discarded. If this mode is set, `padding` must be 0.
+            - ``"pad"``: Pad the input with a specified amount. In this mode, the amount of padding
+              in the depth, height and width dimension is determined by the `padding` parameter.
               If this mode is set, `padding` must be greater than or equal to 0.
 
-        padding (Union(int, tuple[int], list[int]), optional): Pooling padding value, only 'pad' mode can be set to
-            non-zero. Default: 0. Only the following paddings are supported:
+        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.
@@ -806,15 +823,18 @@ class AvgPool3d(_PoolNd):
             - `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.
+        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.
+            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
           :math:`(C, D_{in}, H_{in}, W_{in})`.
-          Currently support float16 and float32 data type.
+          Currently support float16, float32 and float64 data type.
 
     Outputs:
         Tensor, with shape :math:`(N, C, D_{out}, H_{out}, W_{out})` or
@@ -846,22 +866,20 @@ class AvgPool3d(_PoolNd):
         ValueError: If element of `padding` is less than 0.
         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'.
+        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
-        >>> pool = nn.AvgPool3d(kernel_size=3, stride=1)
-        >>> x = ops.randn(1, 2, 4, 4, 5).astype(ms.float32)
+        >>> pool = ms.nn.AvgPool3d(kernel_size=3, stride=1)
+        >>> x = ms.ops.randn(1, 2, 4, 4, 5).astype(ms.float32)
         >>> output = pool(x)
         >>> print(output.shape)
         (1, 2, 2, 2, 3)
-        >>> x1 = 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)
+        >>> x1 = ms.ops.randn(6, 5, 7, 7, 5).astype(ms.float32)
+        >>> pool2 = ms.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)
@@ -905,33 +923,37 @@ class AvgPool2d(_PoolNd):
         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 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.
+            Default: ``1`` .
         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) - Specifies the padding method of pooling, optional values are "same", "valid" or "pad",
-            case insensitive. Default: "valid".
-
-            - same: The 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. 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.
+            represent height and width of movement respectively. Default: ``1`` .
+        pad_mode (str, optional): Specifies the padding mode with a padding value of 0. It can be set to:
+            ``"same"`` , ``"valid"`` or ``"pad"`` . Default: ``"valid"`` .
+
+            - ``"same"``: Pad the input around its edges so that the shape of input and output
+              are the same when `stride` is set to ``1``.
+              The amount of padding to is calculated by the operator internally, If the amount is even, it is
+              uniformly distributed around the input, if it is odd, the excess amount goes to the right/bottom side.
+              If this mode is set, `padding` must be 0.
+            - ``"valid"``: No padding is applied to the input, and the output returns the maximum
+              possible height and width. Extra pixels that could not complete a full stride will
+              be discarded. If this mode is set, `padding` must be 0.
+            - ``"pad"``: Pad the input with a specified amount. In this mode, the amount of padding
+              in the height and width directions is determined by the `padding` parameter.
+              If this mode is set, `padding` must be greater than or equal to 0.
 
-        padding (Union(int, tuple[int], list[int])): Pooling padding value, only 'pad' mode can be set to non-zero.
-            Default: 0. `padding` can only be an integer or a tuple/list containing one or two integers.
+        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.
+        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'.
+            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})` or :math:`(C_{in}, H_{in}, W_{in})`.
@@ -951,31 +973,29 @@ class AvgPool2d(_PoolNd):
 
     Raises:
         TypeError: If `kernel_size` or `strides` is neither int nor tuple.
-        ValueError: If `pad_mode` is not 'valid' ,'same' or 'pad' with not case sensitive.
-        ValueError: If `data_format` is neither 'NCHW' nor 'NHWC'.
+        ValueError: If `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'.
+            or `pad_mode` is ``"pad"`` when `data_format` is 'NHWC'.
         ValueError: If `kernel_size` or `strides` is less than 1.
         ValueError: If length of `padding` tuple/list is not 1 or 2.
         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'.
+        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)
+        >>> pool = ms.nn.AvgPool2d(kernel_size=3, stride=1)
         >>> 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)
+        >>> x = ms.ops.randn(6, 6, 8, 8)
+        >>> pool2 = ms.nn.AvgPool2d(4, stride=1, pad_mode="pad", padding=2, divisor_override=5)
         >>> output2 = pool2(x)
         >>> print(output2.shape)
         (6, 6, 9, 9)
@@ -1057,25 +1077,29 @@ class AvgPool1d(_PoolNd):
         \text{input}(N_i, C_j, s_0 \times l + n)
 
     Args:
-        kernel_size (int): The size of kernel window used to take the average value, Default: 1.
+        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) - Specifies the padding method of pooling, optional values are "same", "valid" or "pad",
-            case insensitive. Default: "valid".
-
-            - same: The 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: 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.
+            the width of movement is strides, Default: ``1`` .
+        pad_mode (str, optional): Specifies the padding mode with a padding value of 0. It can be set to:
+            ``"same"`` , ``"valid"`` or ``"pad"`` . Default: ``"valid"`` .
+
+            - ``"same"``: Pad the input at the begin and end so that the shape of input and output
+              are the same when `stride` is set to ``1``.
+              The amount of padding to is calculated by the operator internally. If the amount is even, it is
+              uniformly distributed around the input, if it is odd, the excess padding is goes to the right side.
+              If this mode is set, `padding` must be 0.
+            - ``"valid"``: No padding is applied to the input, and the output returns the maximum
+              possible length. Extra pixels that could not complete a full stride will
+              be discarded. If this mode is set, `padding` must be 0.
+            - ``"pad"``: Pad the input with a specified amount. In this mode, the amount of padding
+              at the begin and end is determined by the `padding` parameter.
+              If this mode is set, `padding` must be greater than or equal to 0.
 
-        padding (Union(int, tuple[int], list[int])): Pooling padding value, only 'pad' mode can be set to non-zero.
-            Default: 0. padding can only be an integer or a tuple/list containing a single integer, in which case
+        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.
+        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})` or :math:`(C_{in}, L_{in})`.
@@ -1091,28 +1115,26 @@ class AvgPool1d(_PoolNd):
 
     Raises:
         TypeError: If `kernel_size` or `stride` is not an int.
-        ValueError: If `pad_mode` is not 'valid' ,'same' or 'pad' 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 `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'.
+        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)
+        >>> pool = ms.nn.AvgPool1d(kernel_size=6, stride=1)
         >>> 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)
+        >>> pool2 = ms.nn.AvgPool1d(4, stride=1, ceil_mode=True, pad_mode="pad", padding=2)
+        >>> x1 = ms.ops.randn(6, 6, 8)
         >>> output = pool2(x1)
         >>> print(output.shape)
         (6, 6, 9)
@@ -1179,23 +1201,23 @@ class AvgPool1d(_PoolNd):
 @_primexpr
 def _adaptive_shape_check(in_shape, output_size, prim_name):
     """Check shape."""
-    msg_prefix = "For {}, the".format(prim_name)
+    msg_prefix = f"For {prim_name}, the"
     if len(in_shape) != 3:
-        raise ValueError("{} input must has 3 dim, but got {}.".format(msg_prefix, len(in_shape)))
+        raise ValueError(f"{msg_prefix} input must has 3 dim, but got {len(in_shape)}.")
     if in_shape[2] < output_size:
-        raise ValueError("{} input's last dimension must be greater or equal to "
-                         "output size {}, but got {}.".format(msg_prefix, output_size, in_shape[2]))
+        raise ValueError(f"{msg_prefix} input's last dimension must be greater or equal to "
+                         f"output size {output_size}, but got {in_shape[2]}.")
     if in_shape[2] % output_size != 0:
-        raise ValueError("{} input's last dimension must be divisible by "
-                         "output size {}, but got {}.".format(msg_prefix, output_size, in_shape[2]))
+        raise ValueError(f"{msg_prefix} input's last dimension must be divisible by "
+                         f"output size {output_size}, but got {in_shape[2]}.")
 
 
 @constexpr
 def _adaptive_dtype_check(x_dtype, prim_name):
     """Check dtype."""
     if x_dtype not in [mstype.float16, mstype.float32]:
-        raise TypeError("For {}, the x_dtype must be float16 or float32, "
-                        "but got {}.".format(prim_name, x_dtype))
+        raise TypeError(f"For {prim_name}, the x_dtype must be float16 or float32, "
+                        f"but got {x_dtype}.")
 
 
 class AdaptiveAvgPool1d(Cell):
@@ -1233,11 +1255,10 @@ class AdaptiveAvgPool1d(Cell):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> import mindspore
-        >>> from mindspore import Tensor, nn
+        >>> import mindspore as ms
         >>> import numpy as np
-        >>> pool = nn.AdaptiveAvgPool1d(output_size=2)
-        >>> input = Tensor(np.random.randint(0, 10, [1, 3, 6]), mindspore.float32)
+        >>> pool = ms.nn.AdaptiveAvgPool1d(output_size=2)
+        >>> input = ms.Tensor(np.random.randint(0, 10, [1, 3, 6]), ms.float32)
         >>> output = pool(input)
         >>> result = output.shape
         >>> print(result)
@@ -1295,7 +1316,7 @@ class AdaptiveAvgPool2d(Cell):
 
     Args:
         output_size (Union[int, tuple]): The target output size is H x W.
-            `ouput_size` can be a tuple consisted of int type H and W, or a single H for H x H, or None.
+            `output_size` can be a tuple consisted of int type H and W, or a single H for H x H, or None.
             If it is None, it means the output size is the same as the input size.
 
     Inputs:
@@ -1312,13 +1333,15 @@ class AdaptiveAvgPool2d(Cell):
         ValueError: If the dimension of `input` is less than or equal to the dimension of `output_size`.
 
     Supported Platforms:
-        ``GPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> pool = nn.AdaptiveAvgPool2d(2)
-        >>> input_x = Tensor(np.array([[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]],
+        >>> import mindspore as ms
+        >>> import numpy as np
+        >>> pool = ms.nn.AdaptiveAvgPool2d(2)
+        >>> input_x = ms.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)
+        ...                            [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]]), ms.float32)
         >>> output = pool(input_x)
         >>> result = output.shape
         >>> print(result)
@@ -1358,7 +1381,7 @@ class AdaptiveAvgPool3d(Cell):
         \end{array}
 
     Args:
-        output_size (Union[int, tuple]): The target output size. `ouput_size` can be a tuple :math:`(D, H, W)`,
+        output_size (Union[int, tuple]): The target output size. `output_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
             which means the output size is the same as that of the input.
 
@@ -1379,27 +1402,29 @@ class AdaptiveAvgPool3d(Cell):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore as ms
+        >>> import numpy as np
         >>> # case 1: output_size=(3, 3, 4)
         >>> output_size=(3, 3, 4)
         >>> input_x_val = np.random.randn(4, 3, 5, 6, 7)
-        >>> input_x = Tensor(input_x_val, mindspore.float32)
-        >>> net = nn.AdaptiveAvgPool3d(output_size)
+        >>> input_x = ms.Tensor(input_x_val, ms.float32)
+        >>> net = ms.nn.AdaptiveAvgPool3d(output_size)
         >>> output = net(input_x)
         >>> print(output.shape)
         (4, 3, 3, 3, 4)
         >>> # case 2: output_size=4
         >>> output_size=5
         >>> input_x_val = np.random.randn(2, 3, 8, 6, 12)
-        >>> input_x = Tensor(input_x_val, mindspore.float32)
-        >>> net = nn.AdaptiveAvgPool3d(output_size)
+        >>> input_x = ms.Tensor(input_x_val, ms.float32)
+        >>> net = ms.nn.AdaptiveAvgPool3d(output_size)
         >>> output = net(input_x)
         >>> print(output.shape)
         (2, 3, 5, 5, 5)
         >>> # case 3: output_size=(None, 4, 5)
         >>> output_size=(None, 4, 5)
         >>> input_x_val = np.random.randn(4, 1, 9, 10, 8)
-        >>> input_x = Tensor(input_x_val, mindspore.float32)
-        >>> net = nn.AdaptiveAvgPool3d(output_size)
+        >>> input_x = ms.Tensor(input_x_val, ms.float32)
+        >>> net = ms.nn.AdaptiveAvgPool3d(output_size)
         >>> output = net(input_x)
         >>> print(output.shape)
         (4, 1, 9, 4, 5)
@@ -1448,11 +1473,10 @@ class AdaptiveMaxPool1d(Cell):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> import mindspore
-        >>> from mindspore import Tensor, nn
+        >>> import mindspore as ms
         >>> import numpy as np
-        >>> pool = nn.AdaptiveMaxPool1d(output_size=3)
-        >>> x = Tensor(np.random.randint(0, 10, [1, 3, 6]), mindspore.float32)
+        >>> pool = ms.nn.AdaptiveMaxPool1d(output_size=3)
+        >>> x = ms.Tensor(np.random.randint(0, 10, [1, 3, 6]), ms.float32)
         >>> output = pool(x)
         >>> result = output.shape
         >>> print(result)
@@ -1514,11 +1538,11 @@ class AdaptiveMaxPool2d(Cell):
         Ascend platform only supports float16 type for input.
 
     Args:
-        output_size (Union[int, tuple]): The target output size. `ouput_size` can be a tuple :math:`(H, W)`,
+        output_size (Union[int, tuple]): The target output size. `output_size` can be a tuple :math:`(H, W)`,
             or an int H for :math:`(H, H)`. :math:`H` and :math:`W` can be int or None.
             If it is None, it means the output size is the same as the input size.
-        return_indices (bool): If `return_indices` is True, the indices of max value would be output.
-            Default: False.
+        return_indices (bool): If `return_indices` is ``True`` , the indices of max value would be output.
+            Default: ``False`` .
 
     Inputs:
         - **input** (Tensor) - The input of AdaptiveMaxPool2d, which is a 3D or 4D tensor,
@@ -1526,7 +1550,7 @@ class AdaptiveMaxPool2d(Cell):
 
     Outputs:
         Tensor, with the same type as the `input`.
-        Shape of the output is `input_shape[:len(input_shape) - len(out_shape)] + out_shape`.
+        Shape of the output is :math:`input\_shape[:len(input\_shape) - len(out\_shape)] + out\_shape`.
 
     Raises:
         TypeError: If `output_size` is not int or tuple.
@@ -1540,11 +1564,13 @@ class AdaptiveMaxPool2d(Cell):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> import mindspore as ms
+        >>> import numpy as np
         >>> # case 1: output_size=(None, 2)
-        >>> input = Tensor(np.array([[[[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]],
+        >>> input = ms.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))
+        ...                             [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]]]), ms.float32)
+        >>> adaptive_max_pool_2d = ms.nn.AdaptiveMaxPool2d((None, 2))
         >>> output = adaptive_max_pool_2d(input)
         >>> print(output)
         [[[[2. 3.]
@@ -1557,7 +1583,7 @@ class AdaptiveMaxPool2d(Cell):
            [5. 6.]
            [8. 9.]]]]
         >>> # case 2: output_size=2
-        >>> adaptive_max_pool_2d = nn.AdaptiveMaxPool2d(2)
+        >>> adaptive_max_pool_2d = ms.nn.AdaptiveMaxPool2d(2)
         >>> output = adaptive_max_pool_2d(input)
         >>> print(output)
         [[[[5. 6.]
@@ -1567,7 +1593,7 @@ class AdaptiveMaxPool2d(Cell):
           [[5. 6.]
            [8. 9.]]]]
         >>> # case 3: output_size=(1, 2)
-        >>> adaptive_max_pool_2d = nn.AdaptiveMaxPool2d((1, 2))
+        >>> adaptive_max_pool_2d = ms.nn.AdaptiveMaxPool2d((1, 2))
         >>> output = adaptive_max_pool_2d(input)
         >>> print(output)
         [[[[8. 9.]]
@@ -1598,8 +1624,8 @@ class AdaptiveMaxPool3d(Cell):
         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.
+        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:
         - **input** (Tensor) - Tensor, has shape of :math:`(C, D, H, W)` or :math:`(N, C, D, H, W)`.
@@ -1607,21 +1633,23 @@ class AdaptiveMaxPool3d(Cell):
     Outputs:
         - **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.
+          `y` and a dtype of int32. Return this only when `return_indices` is ``True`` .
 
     Raises:
         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,).
+        ValueError: If `output_size` is neither an int nor a tuple with shape :math:`(3,)`.
 
     Supported Platforms:
         ``GPU`` ``CPU``
 
     Examples:
-        >>> input = Tensor(np.arange(0,36).reshape((1, 3, 3, 4)).astype(np.float32))
+        >>> import mindspore as ms
+        >>> import numpy as np
+        >>> input = ms.Tensor(np.arange(0,36).reshape((1, 3, 3, 4)).astype(np.float32))
         >>> output_size = (1, 1, 2)
-        >>> net = nn.AdaptiveMaxPool3d(output_size, True)
+        >>> net = ms.nn.AdaptiveMaxPool3d(output_size, True)
         >>> output = net(input)
         >>> print(output[0].asnumpy())
         [[[[33. 35.]]]]
@@ -1646,8 +1674,9 @@ class AdaptiveMaxPool3d(Cell):
 class FractionalMaxPool2d(Cell):
     r"""
     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.
+    `output_size` or `output_ratio`, and the step size is determined by `_random_samples`. `output_size` will take
+    effect when `output_size` and `output_ratio` are set at the same time.
+    And `output_size` and `output_ratio` can not be ``None`` at the same time.
 
     Refer to the paper `Fractional MaxPooling by Ben Graham <https://arxiv.org/abs/1412.6071>`_  for more details.
 
@@ -1659,22 +1688,27 @@ class FractionalMaxPool2d(Cell):
         output_size (Union[int, tuple[int]], optional): The Shape of the target `output_size`,
             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.
+            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, 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.
+            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, which is a 3D tensor.
+            Tensor of data type: float16, float32, double, and value is between [0, 1).
+            Supported shape :math:`(N, C, 2)` or :math:`(1, C, 2)`.
+            Default: ``None``, the values of `_random_samples`
+            will be randomly distributed using uniform distribution over an interval [0,1).
 
     Inputs:
-        - **input** (Tensor) - Tensor of shape :math:`(N, C, H_{in}, W_{in})`,
+        - **input** (Tensor) - Tensor of shape :math:`(N, C, H_{in}, W_{in})` or :math:`(C, H_{in}, W_{in})`,
           with float16, float32, float64, int32, int64 data type.
 
     Outputs:
-        - **y** (Tensor) - Has the same type as the `input`. Has the shape :math:`(N, C, H, W)`.
+        - **y** (Tensor) - Has the same type as the `input`.
+          Has the shape :math:`(N, C, H_{out}, W_{out})` or :math:`(C, H_{out}, W_{out})` ,
+          where :math:`(H_{out}, W_{out})` = `output_size`
+          or :math:`(H_{out}, W_{out})` = `output_ratio` * :math:`(H_{in}, W_{in})`.
         - **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 be returned only when `return_indices` is True.
 
@@ -1697,16 +1731,14 @@ class FractionalMaxPool2d(Cell):
     Examples:
         >>> # the kernel_size is an int number and the output_size is a tuple.
         >>> import numpy as np
-        >>> from mindspore import nn
-        >>> from mindspore import Tensor
-        >>> import mindspore.common.dtype as mstype
-        >>> input = Tensor(np.array([0.3220, 0.9545, 0.7879, 0.0975, 0.3698,
+        >>> import mindspore as ms
+        >>> input = ms.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,
-        ...                            0.9304, 0.1558, 0.0153, 0.1559, 0.9852]).reshape([1, 1, 5, 5]), mstype.float32)
-        >>> _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,
+        ...                            0.9304, 0.1558, 0.0153, 0.1559, 0.9852]).reshape([1, 1, 5, 5]), ms.float32)
+        >>> _random_samples = ms.Tensor(np.array([[[0.8, 0.8]]]), ms.float32)
+        >>> net = ms.nn.FractionalMaxPool2d(kernel_size=2, output_size=(2, 2), _random_samples=_random_samples,
         ...                              return_indices=True)
         >>> y, argmax = net(input)
         >>> y
@@ -1715,7 +1747,7 @@ class FractionalMaxPool2d(Cell):
         >>> argmax
         [[[[ 1  9]
            [16 24]]]]
-        >>> net = nn.FractionalMaxPool2d(kernel_size=2, output_ratio=(0.5, 0.5), _random_samples=_random_samples,
+        >>> net = ms.nn.FractionalMaxPool2d(kernel_size=2, output_ratio=(0.5, 0.5), _random_samples=_random_samples,
         ...                              return_indices=True)
         >>> y, argmax = net(input)
         >>> print(y)
@@ -1743,8 +1775,9 @@ class FractionalMaxPool2d(Cell):
 class FractionalMaxPool3d(Cell):
     r"""
     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.
+    `output_size` or `output_ratio`, and the step size is determined by `_random_samples`. `output_size` will take
+    effect when `output_size` and `output_ratio` are set at the same time.
+    And `output_size` and `output_ratio` can not be ``None`` at the same time.
 
     Refer to the paper `Fractional MaxPooling by Ben Graham <https://arxiv.org/abs/1412.6071>`_  for more details.
 
@@ -1757,26 +1790,29 @@ class FractionalMaxPool3d(Cell):
             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.
+            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, 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.
+            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 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)` or :math:`(1, C, 3)` . Default: ``None``, the values of `_random_samples`
+            will be randomly distributed using uniform distribution over an interval [0,1).
 
     Inputs:
         - **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})` .
+          Tensor of data type : float16, float32, float64.
+          Supported shape :math:`(N, C, D_{in}, H_{in}, W_{in})` or :math:`(C, D_{in}, H_{in}, W_{in})`.
 
     Outputs:
         - **y** (Tensor) - A tensor, the output of FractionalMaxPool3d.
-          Has the same data type with `imput_x`.
-          Tensor of shape :math:`(N, C, D, H, W)` .
+          Has the same data type with `input`.
+          Has the shape :math:`(N, C, D_{out}, H_{out}, W_{out})` or :math:`(C, D_{out}, H_{out}, W_{out})` ,
+          where :math:`(D_{out}, H_{out}, W_{out})` = `output_size`
+          or :math:`(D_{out}, H_{out}, W_{out})` = `output_ratio` * :math:`(D_{in}, H_{in}, W_{in})` .
 
         - **argmax** (Tensor) - The indices along with the outputs, which is a Tensor, with the same shape as the
           `y` and int32 data type. It will output only when `return_indices` is True.
@@ -1784,9 +1820,10 @@ class FractionalMaxPool3d(Cell):
     Raises:
         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, float64, int32, int64.
+        TypeError: If data type of `imput_x` is not float16, float32, float64.
         TypeError: If dtype of `_random_samples` is not float16, float32, float64.
         TypeError: If dtype of `argmax` is not int32, int64.
+        TypeError: if _random_samples to have the different dtypes as input.
         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.
@@ -1800,20 +1837,18 @@ class FractionalMaxPool3d(Cell):
 
     Examples:
         >>> import numpy as np
-        >>> from mindspore import nn
-        >>> from mindspore import Tensor
-        >>> import mindspore.common.dtype as mstype
-        >>> 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, 1, 1), output_size=(1, 1, 3),
+        >>> import mindspore as ms
+        >>> x = ms.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]), ms.float32)
+        >>> _random_samples = ms.Tensor(np.array([0.7, 0.7, 0.7]).reshape([1, 1, 3]), ms.float32)
+        >>> net = ms.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, 1, 1), output_ratio=(0.5, 0.5, 0.5),
+        >>> net = ms.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)
@@ -1847,14 +1882,14 @@ class MaxUnpool1d(Cell):
 
     .. math::
         \begin{array}{ll} \\
-        H_{out} = (H{in} - 1) \times stride[0] - 2 \times padding[0] + kernel\_size[0] \\
+        H_{out} = (H_{in} - 1) \times stride[0] - 2 \times padding[0] + kernel\_size[0] \\
         \end{array}
 
     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 None, then stride equal to kernel_size. Default: None.
-        padding (Union[int, tuple[int]]): The pad value to be filled. Default: 0.
+            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:
         - **x** (Tensor) - The input Tensor to invert.
@@ -1863,9 +1898,9 @@ class MaxUnpool1d(Cell):
           Tensor of shape must be same with input 'x'.
           Values of indices must belong to :math:`[0, H_{in} - 1]`.
           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)` , :math:`(C, H)` or
+        - **output_size** (tuple[int], optional) - The output size. Default: ``None`` .
+          If output_size is ``None``, then the shape of output computed by kernel_size, stride and padding.
+          If output_size is not ``None``, 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])]`.
 
@@ -1887,9 +1922,11 @@ class MaxUnpool1d(Cell):
         ``GPU`` ``CPU``
 
     Examples:
-        >>> x = Tensor(np.array([[2, 4, 6, 8]]).astype(np.float32))
-        >>> indices = Tensor(np.array([[1, 3, 5, 7]]).astype(np.int64))
-        >>> maxunpool1d = nn.MaxUnpool1d(kernel_size =2, stride=2, padding=0)
+        >>> import mindspore as ms
+        >>> import numpy as np
+        >>> x = ms.Tensor(np.array([[2, 4, 6, 8]]).astype(np.float32))
+        >>> indices = ms.Tensor(np.array([[1, 3, 5, 7]]).astype(np.int64))
+        >>> maxunpool1d = ms.nn.MaxUnpool1d(kernel_size =2, stride=2, padding=0)
         >>> output = maxunpool1d(x, indices)
         >>> print(output.asnumpy())
         [[0. 2. 0. 4. 0. 6. 0. 8.]]
@@ -1910,6 +1947,8 @@ class MaxUnpool1d(Cell):
         else:
             if not isinstance(output_size, tuple):
                 raise ValueError(f"For MaxUnpool1d, output_size must be tuple, but type {type(output_size)}.")
+            if not output_size:
+                raise ValueError(f"For MaxUnpool1d, the length of output_size must be positive, but got 0.")
         out = ops.max_unpool1d(x, indices, self.kernel_size, stride=self.stride, padding=self.padding,
                                output_size=output_size)
         return out
@@ -1925,8 +1964,8 @@ class MaxUnpool2d(Cell):
 
     .. math::
         \begin{array}{ll} \\
-        H_{out} = (H{in} - 1) \times stride[0] - 2 \times padding[0] + kernel\_size[0] \\
-        W_{out} = (W{in} - 1) \times stride[1] - 2 \times padding[1] + kernel\_size[1] \\
+        H_{out} = (H_{in} - 1) \times stride[0] - 2 \times padding[0] + kernel\_size[0] \\
+        W_{out} = (W_{in} - 1) \times stride[1] - 2 \times padding[1] + kernel\_size[1] \\
         \end{array}
 
     Args:
@@ -1936,8 +1975,8 @@ 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 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,
+            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.
 
@@ -1948,9 +1987,9 @@ class MaxUnpool2d(Cell):
           Tensor of shape must be same with input 'x'.
           Values of indices must belong to :math:`[0, H_{in} \times W_{in} - 1]`.
           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)`, :math:`(C, H, W)` or
+        - **output_size** (tuple[int], optional) - The output size. Default: ``None`` .
+          If output_size is ``None``, then the shape of output computed by kernel_size, stride and padding.
+          If output_size is not ``None``, 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])]`.
 
@@ -1973,9 +2012,11 @@ class MaxUnpool2d(Cell):
         ``GPU`` ``CPU``
 
     Examples:
-        >>> x = Tensor(np.array([[[[0, 1], [8, 9]]]]).astype(np.float32))
-        >>> indices = Tensor(np.array([[[[0, 1], [2, 3]]]]).astype(np.int64))
-        >>> maxunpool2d = nn.MaxUnpool2d(kernel_size=1, stride=1, padding=0)
+        >>> import mindspore as ms
+        >>> import numpy as np
+        >>> x = ms.Tensor(np.array([[[[0, 1], [8, 9]]]]).astype(np.float32))
+        >>> indices = ms.Tensor(np.array([[[[0, 1], [2, 3]]]]).astype(np.int64))
+        >>> maxunpool2d = ms.nn.MaxUnpool2d(kernel_size=1, stride=1, padding=0)
         >>> output = maxunpool2d(x, indices)
         >>> print(output.asnumpy())
         [[[[0. 1.]
@@ -1997,6 +2038,8 @@ class MaxUnpool2d(Cell):
         else:
             if not isinstance(output_size, tuple):
                 raise ValueError(f"For MaxUnpool2d, output_size must be tuple, but type {type(output_size)}.")
+            if not output_size:
+                raise ValueError(f"For MaxUnpool2d, the length of output_size must be positive, but got 0.")
         out = ops.max_unpool2d(x, indices, self.kernel_size, stride=self.stride, padding=self.padding,
                                output_size=output_size)
         return out
@@ -2013,9 +2056,9 @@ class MaxUnpool3d(Cell):
 
     .. math::
         \begin{array}{ll} \\
-        D_{out} = (D{in} - 1) \times stride[0] - 2 \times padding[0] + kernel\_size[0] \\
-        H_{out} = (H{in} - 1) \times stride[1] - 2 \times padding[1] + kernel\_size[1] \\
-        W_{out} = (W{in} - 1) \times stride[2] - 2 \times padding[2] + kernel\_size[2] \\
+        D_{out} = (D_{in} - 1) \times stride[0] - 2 \times padding[0] + kernel\_size[0] \\
+        H_{out} = (H_{in} - 1) \times stride[1] - 2 \times padding[1] + kernel\_size[1] \\
+        W_{out} = (W_{in} - 1) \times stride[2] - 2 \times padding[2] + kernel\_size[2] \\
         \end{array}
 
     Args:
@@ -2025,8 +2068,8 @@ 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 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,
+            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]
             correspondingly.
@@ -2038,9 +2081,9 @@ class MaxUnpool3d(Cell):
           Tensor of shape must be same with input 'x'.
           Values of indices must belong to :math:`[0, D_{in} \times H_{in} \times W_{in} - 1]`.
           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)` , :math:`(C, D, H, W)` or
+        - **output_size** (tuple[int], optional) - The output size. Default: ``None`` .
+          If output_size is ``None``, then the shape of output computed by kernel_size, stride and padding.
+          If output_size is not ``None``, 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])]`.
@@ -2064,9 +2107,11 @@ class MaxUnpool3d(Cell):
         ``GPU`` ``CPU``
 
     Examples:
-        >>> x = Tensor(np.array([[[[[0, 1], [8, 9]]]]]).astype(np.float32))
-        >>> indices= Tensor(np.array([[[[[0, 1], [2, 3]]]]]).astype(np.int64))
-        >>> maxunpool3d = nn.MaxUnpool3d(kernel_size=1, stride=1, padding=0)
+        >>> import mindspore as ms
+        >>> import numpy as np
+        >>> x = ms.Tensor(np.array([[[[[0, 1], [8, 9]]]]]).astype(np.float32))
+        >>> indices= ms.Tensor(np.array([[[[[0, 1], [2, 3]]]]]).astype(np.int64))
+        >>> maxunpool3d = ms.nn.MaxUnpool3d(kernel_size=1, stride=1, padding=0)
         >>> output = maxunpool3d(x, indices)
         >>> print(output.asnumpy())
         [[[[[0. 1.]
@@ -2087,6 +2132,8 @@ class MaxUnpool3d(Cell):
         else:
             if not isinstance(output_size, tuple):
                 raise ValueError(f"For MaxUnpool3d, output_size must be tuple, but type {type(output_size)}.")
+            if not output_size:
+                raise ValueError(f"For MaxUnpool3d, the length of output_size must be positive, but got 0.")
         out = ops.max_unpool3d(x, indices, self.kernel_size, stride=self.stride, padding=self.padding,
                                output_size=output_size)
         return out