mindspore 2.1.0__cp38-none-any.whl → 2.2.11__cp38-none-any.whl

mindspore/nn/layer/pooling.py

@@ -96,7 +96,7 @@ 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).
@@ -168,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).
@@ -297,16 +297,21 @@ class MaxPool3d(_PoolNd):
             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.
+        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` can only be an integer or a tuple/list containing one or three integers.
@@ -337,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
@@ -356,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``
@@ -369,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,16 +442,20 @@ class MaxPool2d(_PoolNd):
         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.
+        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
@@ -489,17 +498,17 @@ 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``
@@ -514,7 +523,7 @@ class MaxPool2d(_PoolNd):
         (1, 2, 2, 2)
         >>> np_x = np.random.randint(0, 10, [5, 3, 4, 5])
         >>> 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)
+        >>> 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)
@@ -596,18 +605,20 @@ class MaxPool1d(_PoolNd):
         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.
+        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
@@ -641,16 +652,16 @@ 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``
@@ -667,7 +678,7 @@ class MaxPool1d(_PoolNd):
         (1, 2, 2)
         >>> np_x = np.random.randint(0, 10, [5, 3, 4])
         >>> 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)
+        >>> 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)
@@ -787,19 +798,23 @@ class AvgPool3d(_PoolNd):
             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`.
+        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
+        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
@@ -851,7 +866,7 @@ 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``
@@ -864,7 +879,7 @@ class AvgPool3d(_PoolNd):
         >>> print(output.shape)
         (1, 2, 2, 2, 3)
         >>> 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)
+        >>> 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)
@@ -912,19 +927,22 @@ class AvgPool2d(_PoolNd):
         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.
+        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.
+        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
@@ -955,15 +973,15 @@ 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``
@@ -977,7 +995,7 @@ class AvgPool2d(_PoolNd):
         >>> print(output.shape)
         (1, 2, 2, 2)
         >>> x = ms.ops.randn(6, 6, 8, 8)
-        >>> pool2 = ms.nn.AvgPool2d(4, stride=1, pad_mode='pad', padding=2, divisor_override=5)
+        >>> 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)
@@ -1062,18 +1080,22 @@ class AvgPool1d(_PoolNd):
         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`` .
+        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.
+        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`` .
@@ -1093,11 +1115,11 @@ 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``
@@ -1111,7 +1133,7 @@ class AvgPool1d(_PoolNd):
         >>> result = output.shape
         >>> print(result)
         (1, 3, 1)
-        >>> pool2 = ms.nn.AvgPool1d(4, stride=1, ceil_mode=True, pad_mode='pad', padding=2)
+        >>> 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)
@@ -1528,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.
@@ -1860,7 +1882,7 @@ 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:
@@ -1877,8 +1899,8 @@ class MaxUnpool1d(Cell):
           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 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
+          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])]`.
 
@@ -1942,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:
@@ -1966,8 +1988,8 @@ class MaxUnpool2d(Cell):
           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 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
+          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])]`.
 
@@ -2034,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:
@@ -2060,8 +2082,8 @@ class MaxUnpool3d(Cell):
           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 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
+          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])]`.

mindspore/nn/layer/rnn_cells.py

@@ -83,7 +83,7 @@ def _check_lstmcell_init(func):
 
 
 def _rnn_tanh_cell(inputs, hidden, w_ih, w_hh, b_ih, b_hh):
-    '''RNN cell function with tanh activation'''
+    """RNN cell function with tanh activation"""
     if b_ih is None:
         igates = P.MatMul(False, True)(inputs, w_ih)
         hgates = P.MatMul(False, True)(hidden, w_hh)
@@ -94,7 +94,7 @@ def _rnn_tanh_cell(inputs, hidden, w_ih, w_hh, b_ih, b_hh):
 
 
 def _rnn_relu_cell(inputs, hidden, w_ih, w_hh, b_ih, b_hh):
-    '''RNN cell function with relu activation'''
+    """RNN cell function with relu activation"""
     if b_ih is None:
         igates = P.MatMul(False, True)(inputs, w_ih)
         hgates = P.MatMul(False, True)(hidden, w_hh)
@@ -105,7 +105,7 @@ def _rnn_relu_cell(inputs, hidden, w_ih, w_hh, b_ih, b_hh):
 
 
 def _lstm_cell(inputs, hidden, w_ih, w_hh, b_ih, b_hh):
-    '''LSTM cell function'''
+    """LSTM cell function"""
     hx, cx = hidden
     if b_ih is None:
         gates = P.MatMul(False, True)(inputs, w_ih) + P.MatMul(False, True)(hx, w_hh)
@@ -125,7 +125,7 @@ def _lstm_cell(inputs, hidden, w_ih, w_hh, b_ih, b_hh):
 
 
 def _gru_cell(inputs, hidden, w_ih, w_hh, b_ih, b_hh):
-    '''GRU cell function'''
+    """GRU cell function"""
     if b_ih is None:
         gi = P.MatMul(False, True)(inputs, w_ih)
         gh = P.MatMul(False, True)(hidden, w_hh)
@@ -144,8 +144,9 @@ def _gru_cell(inputs, hidden, w_ih, w_hh, b_ih, b_hh):
 
 
 class RNNCellBase(Cell):
-    '''Basic class for RNN Cells'''
-    def __init__(self, input_size: int, hidden_size: int, has_bias: bool, num_chunks: int):
+    """Basic class for RNN Cells"""
+    def __init__(self, input_size: int, hidden_size: int, has_bias: bool, num_chunks: int,
+                 dtype=mstype.float32):
         super().__init__()
         validator.check_value_type("has_bias", has_bias, [bool], self.cls_name)
         validator.check_positive_int(hidden_size, "hidden_size", self.cls_name)
@@ -153,20 +154,20 @@ class RNNCellBase(Cell):
         self.input_size = input_size
         self.hidden_size = hidden_size
         self.has_bias = has_bias
-        self.weight_ih = Parameter(Tensor(np.random.randn(num_chunks * hidden_size, input_size).astype(np.float32)))
-        self.weight_hh = Parameter(Tensor(np.random.randn(num_chunks * hidden_size, hidden_size).astype(np.float32)))
+        self.weight_ih = Parameter(Tensor(np.random.randn(num_chunks * hidden_size, input_size), dtype=dtype))
+        self.weight_hh = Parameter(Tensor(np.random.randn(num_chunks * hidden_size, hidden_size), dtype=dtype))
         if has_bias:
-            self.bias_ih = Parameter(Tensor(np.random.randn(num_chunks * hidden_size).astype(np.float32)))
-            self.bias_hh = Parameter(Tensor(np.random.randn(num_chunks * hidden_size).astype(np.float32)))
+            self.bias_ih = Parameter(Tensor(np.random.randn(num_chunks * hidden_size), dtype=dtype))
+            self.bias_hh = Parameter(Tensor(np.random.randn(num_chunks * hidden_size), dtype=dtype))
         else:
             self.bias_ih = None
             self.bias_hh = None
-        self.reset_parameters()
+        self.reset_parameters(dtype=dtype)
 
-    def reset_parameters(self):
+    def reset_parameters(self, dtype=mstype.float32):
         stdv = 1 / math.sqrt(self.hidden_size)
         for weight in self.get_parameters():
-            weight.set_data(initializer(Uniform(stdv), weight.shape))
+            weight.set_data(initializer(Uniform(stdv), weight.shape, dtype))
 
 
 class RNNCell(RNNCellBase):
@@ -187,11 +188,11 @@ class RNNCell(RNNCellBase):
         has_bias (bool): Whether the cell has bias `b_ih` and `b_hh`. Default: ``True`` .
         nonlinearity (str): The non-linearity to use. Can be either ``"tanh"`` or ``"relu"`` .
             Default: ``"tanh"`` .
+        dtype (:class:`mindspore.dtype`): Dtype of Parameters. Default: ``mstype.float32`` .
 
     Inputs:
         - **x** (Tensor) - Tensor of shape :math:`(batch\_size, input\_size)` .
         - **hx** (Tensor) - Tensor of data type mindspore.float32 and shape :math:`(batch\_size, hidden\_size)` .
-          Data type of `hx` must be the same as `x`.
 
     Outputs:
         - **hx'** (Tensor) - Tensor of shape :math:`(batch\_size, hidden\_size)` .
@@ -219,8 +220,9 @@ class RNNCell(RNNCellBase):
     """
     _non_linearity = ['tanh', 'relu']
 
-    def __init__(self, input_size: int, hidden_size: int, has_bias: bool = True, nonlinearity: str = "tanh"):
-        super().__init__(input_size, hidden_size, has_bias, num_chunks=1)
+    def __init__(self, input_size: int, hidden_size: int, has_bias: bool = True, nonlinearity: str = "tanh",
+                 dtype=mstype.float32):
+        super().__init__(input_size, hidden_size, has_bias, num_chunks=1, dtype=dtype)
         validator.check_value_type("nonlinearity", nonlinearity, [str], self.cls_name)
         validator.check_string(nonlinearity, self._non_linearity, "nonlinearity", self.cls_name)
         self.nonlinearity = nonlinearity
@@ -270,11 +272,12 @@ class LSTMCell(RNNCellBase):
         input_size (int): Number of features of input.
         hidden_size (int):  Number of features of hidden layer.
         has_bias (bool): Whether the cell has bias `b_ih` and `b_hh`. Default: ``True`` .
+        dtype (:class:`mindspore.dtype`): Dtype of Parameters. Default: ``mstype.float32`` .
 
     Inputs:
         - **x** (Tensor) - Tensor of shape :math:`(batch\_size, input\_size)` .
         - **hx** (tuple) - A tuple of two Tensors (h_0, c_0) both of data type mindspore.float32
-          and shape :math:`(batch\_size, hidden\_size)` . The data type of `hx` must be the same as `x`.
+          and shape :math:`(batch\_size, hidden\_size)` .
 
     Outputs:
         - **hx'** (Tensor) - A tuple of two Tensors (h', c') both of data shape :math:`(batch\_size, hidden\_size)` .
@@ -301,8 +304,9 @@ class LSTMCell(RNNCellBase):
         (3, 16)
     """
     @_check_lstmcell_init
-    def __init__(self, input_size: int, hidden_size: int, has_bias: bool = True):
-        super().__init__(input_size, hidden_size, has_bias, num_chunks=4)
+    def __init__(self, input_size: int, hidden_size: int, has_bias: bool = True,
+                 dtype=mstype.float32):
+        super().__init__(input_size, hidden_size, has_bias, num_chunks=4, dtype=dtype)
         self.support_non_tensor_inputs = True
 
     def construct(self, x, hx):
@@ -352,11 +356,11 @@ class GRUCell(RNNCellBase):
         input_size (int): Number of features of input.
         hidden_size (int):  Number of features of hidden layer.
         has_bias (bool): Whether the cell has bias `b_in` and `b_hn`. Default: ``True`` .
+        dtype (:class:`mindspore.dtype`): Dtype of Parameters. Default: ``mstype.float32`` .
 
     Inputs:
         - **x** (Tensor) - Tensor of shape :math:`(batch\_size, input\_size)` .
         - **hx** (Tensor) - Tensor of data type mindspore.float32 and shape :math:`(batch\_size, hidden\_size)` .
-          Data type of `hx` must be the same as `x`.
 
     Outputs:
         - **hx'** (Tensor) - Tensor of shape :math:`(batch\_size, hidden\_size)` .
@@ -381,8 +385,9 @@ class GRUCell(RNNCellBase):
         >>> print(output[0].shape)
         (3, 16)
     """
-    def __init__(self, input_size: int, hidden_size: int, has_bias: bool = True):
-        super().__init__(input_size, hidden_size, has_bias, num_chunks=3)
+    def __init__(self, input_size: int, hidden_size: int, has_bias: bool = True,
+                 dtype=mstype.float32):
+        super().__init__(input_size, hidden_size, has_bias, num_chunks=3, dtype=dtype)
 
     def construct(self, x, hx):
         _check_is_tensor('x', x, self.cls_name)