mindspore 2.2.11__cp39-cp39-win_amd64.whl → 2.3.0__cp39-cp39-win_amd64.whl

mindspore/nn/layer/normalization.py

@@ -21,7 +21,6 @@ import numbers
 import hashlib
 
 from mindspore.ops import operations as P
-from mindspore.ops import functional as F
 from mindspore.ops.operations import _inner_ops as inner
 from mindspore.common.parameter import Parameter
 from mindspore.common.initializer import initializer, Initializer
@@ -36,6 +35,7 @@ from mindspore.common import dtype as mstype
 from mindspore.parallel._utils import _is_in_auto_parallel_mode
 from mindspore.nn.cell import Cell
 from mindspore import log as logger
+from mindspore.ops import group_norm
 
 __all__ = ['BatchNorm1d', 'BatchNorm2d', 'BatchNorm3d', 'LayerNorm', 'GroupNorm',
            'SyncBatchNorm', 'InstanceNorm1d', 'InstanceNorm2d', 'InstanceNorm3d']
@@ -128,15 +128,19 @@ class _BatchNorm(Cell):
         self.assign_sub_mean = P.AssignSub().shard(data_parallel_strategy)
         self.assign_sub_var = P.AssignSub().shard(data_parallel_strategy)
 
-
     @staticmethod
     @_primexpr
     def _check_input_dim(shape, cls_name):
         raise NotImplementedError
 
-
     def construct(self, x):
         self._check_input_dim(self.shape(x), self.cls_name)
+        x_shape = self.shape(x)
+        reshaped_x = x
+        if len(x_shape) == 2:
+            reshaped_x = self.reshape(x, (x_shape[0], x_shape[1], 1, 1))
+        elif len(x_shape) == 3:
+            reshaped_x = self.reshape(x, (x_shape[0], x_shape[1], x_shape[2], 1))
         if self.use_batch_statistics is None:
             if self.training:
                 return self.bn_train(x,
@@ -145,11 +149,14 @@ class _BatchNorm(Cell):
                                      self.moving_mean,
                                      self.moving_variance)[0]
             if not self.training:
-                return self.bn_infer(x,
-                                     self.gamma,
-                                     self.beta,
-                                     self.moving_mean,
-                                     self.moving_variance)[0]
+                bn_out = self.bn_infer(reshaped_x,
+                                       self.gamma,
+                                       self.beta,
+                                       self.moving_mean,
+                                       self.moving_variance)[0]
+                if len(x_shape) < 4:
+                    bn_out = self.reshape(bn_out, x_shape)
+                return bn_out
 
         if self.use_batch_statistics:
             return self.bn_train(x,
@@ -158,11 +165,14 @@ class _BatchNorm(Cell):
                                  self.moving_mean,
                                  self.moving_variance)[0]
 
-        return self.bn_infer(x,
-                             self.gamma,
-                             self.beta,
-                             self.moving_mean,
-                             self.moving_variance)[0]
+        bn_out = self.bn_infer(reshaped_x,
+                               self.gamma,
+                               self.beta,
+                               self.moving_mean,
+                               self.moving_variance)[0]
+        if len(x_shape) < 4:
+            bn_out = self.reshape(bn_out, x_shape)
+        return bn_out
 
     def extend_repr(self):
         return 'num_features={}, eps={}, momentum={}, gamma={}, beta={}, moving_mean={}, moving_variance={}'.format(
@@ -196,19 +206,19 @@ class BatchNorm1d(_BatchNorm):
             Default: ``True`` .
         gamma_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the :math:`\gamma` weight.
             The values of str refer to the function `mindspore.common.initializer
-            <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.common.initializer.html>`_
+            <https://www.mindspore.cn/docs/en/master/api_python/mindspore.common.initializer.html>`_
             including ``'zeros'`` , ``'ones'`` , etc. Default: ``'ones'`` .
         beta_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the :math:`\beta` weight.
             The values of str refer to the function `mindspore.common.initializer
-            <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.common.initializer.html>`_
+            <https://www.mindspore.cn/docs/en/master/api_python/mindspore.common.initializer.html>`_
             including ``'zeros'`` , ``'ones'``, etc. Default: ``'zeros'`` .
         moving_mean_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the moving mean.
             The values of str refer to the function `mindspore.common.initializer
-            <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.common.initializer.html>`_
+            <https://www.mindspore.cn/docs/en/master/api_python/mindspore.common.initializer.html>`_
             including ``'zeros'`` , ``'ones'`` , etc. Default: ``'zeros'`` .
         moving_var_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the moving variance.
             The values of str refer to the function `mindspore.common.initializer
-            <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.common.initializer.html>`_
+            <https://www.mindspore.cn/docs/en/master/api_python/mindspore.common.initializer.html>`_
             including ``'zeros'`` , ``'ones'`` , etc. Default: ``'ones'`` .
         use_batch_statistics (bool): If ``true`` , use the mean value and variance value of current batch data. If
             ``false`` , use the mean value and variance value of specified value. If ``None`` , the training process
@@ -292,19 +302,19 @@ class BatchNorm2d(_BatchNorm):
             Default: ``True`` .
         gamma_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the :math:`\gamma` weight.
             The values of str refer to the function `mindspore.common.initializer
-            <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.common.initializer.html>`_
+            <https://www.mindspore.cn/docs/en/master/api_python/mindspore.common.initializer.html>`_
             including ``'zeros'`` , ``'ones'`` , etc. Default: ``'ones'`` .
         beta_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the :math:`\beta` weight.
             The values of str refer to the function `mindspore.common.initializer
-            <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.common.initializer.html>`_
+            <https://www.mindspore.cn/docs/en/master/api_python/mindspore.common.initializer.html>`_
             including ``'zeros'`` , ``'ones'`` , etc. Default: ``'zeros'`` .
         moving_mean_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the moving mean.
             The values of str refer to the function `mindspore.common.initializer
-            <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.common.initializer.html>`_
+            <https://www.mindspore.cn/docs/en/master/api_python/mindspore.common.initializer.html>`_
             including ``'zeros'`` , ``'ones'`` , etc. Default: ``'zeros'`` .
         moving_var_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the moving variance.
             The values of str refer to the function `mindspore.common.initializer
-            <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.common.initializer.html>`_
+            <https://www.mindspore.cn/docs/en/master/api_python/mindspore.common.initializer.html>`_
             including ``'zeros'`` , ``'ones'`` , etc. Default: ``'ones'`` .
         use_batch_statistics (bool): Default: ``None`` .
 
@@ -381,19 +391,19 @@ class BatchNorm3d(Cell):
         affine (bool): A bool value. When set to ``True`` , gamma and beta can be learned. Default: ``True`` .
         gamma_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the gamma weight.
             The values of str refer to the function `mindspore.common.initializer
-            <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.common.initializer.html>`_
+            <https://www.mindspore.cn/docs/en/master/api_python/mindspore.common.initializer.html>`_
             including ``'zeros'`` , ``'ones'`` , etc. Default: ``'ones'`` .
         beta_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the beta weight.
             The values of str refer to the function `mindspore.common.initializer
-            <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.common.initializer.html>`_
+            <https://www.mindspore.cn/docs/en/master/api_python/mindspore.common.initializer.html>`_
             including ``'zeros'`` , ``'ones'`` , etc. Default: ``'zeros'`` .
         moving_mean_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the moving mean.
             The values of str refer to the function `mindspore.common.initializer
-            <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.common.initializer.html>`_
+            <https://www.mindspore.cn/docs/en/master/api_python/mindspore.common.initializer.html>`_
             including ``'zeros'`` , ``'ones'`` , etc. Default: ``'zeros'`` .
         moving_var_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the moving variance.
             The values of str refer to the function `mindspore.common.initializer
-            <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore.common.initializer.html>`_
+            <https://www.mindspore.cn/docs/en/master/api_python/mindspore.common.initializer.html>`_
             including ``'zeros'`` , ``'ones'`` , etc. Default: ``'ones'`` .
         use_batch_statistics (bool): If true, use the mean value and variance value of current batch data. If
             ``false``, use the mean value and variance value of specified value. If ``None`` , the training process
@@ -460,7 +470,6 @@ class BatchNorm3d(Cell):
         dim = len(shape)
         _check_dim(dim, 5, cls_name)
 
-
     def construct(self, x):
         x_shape = self.shape(x)
         self._check_input_dim(x_shape, self.cls_name)
@@ -549,14 +558,14 @@ class SyncBatchNorm(_BatchNorm):
 
             For the Ascend devices, users need to prepare the rank table, set rank_id and device_id.
             Please see the `Ascend tutorial
-            <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/rank_table.html>`_
+            <https://www.mindspore.cn/tutorials/experts/en/master/parallel/rank_table.html>`_
             for more details.
 
             For the GPU devices, users need to prepare the host file and mpi, please see the `mpirun Startup
-            <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/mpirun.html>`_ .
+            <https://www.mindspore.cn/tutorials/experts/en/master/parallel/mpirun.html>`_ .
 
             For the CPU device, users need to write a dynamic cluster startup script, please see the `Dynamic Cluster
-            Startup <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/dynamic_cluster.html>`_ .
+            Startup <https://www.mindspore.cn/tutorials/experts/en/master/parallel/dynamic_cluster.html>`_ .
 
             This example should be run with multiple devices.
 
@@ -649,16 +658,6 @@ class SyncBatchNorm(_BatchNorm):
                     self.group_name = group_dict[rank_list_name]
                     logger.info("the group for {} already exists, no need to create".format(rank_list_name))
 
-    @staticmethod
-    @_primexpr
-    def _check_input_dim(shape, cls_name):
-        def _check(dim):
-            if dim not in (2, 4):
-                raise ValueError(f"For '{cls_name}', the must have 2 dims or 4 dims, but got {dim}.")
-        dim = len(shape)
-        _check(dim)
-
-
     def _check_rank_ids(self, process_groups, rank_size):
         seen = set()
         for rid in itertools.chain(*process_groups):
@@ -668,6 +667,15 @@ class SyncBatchNorm(_BatchNorm):
                                  f"but got {process_groups}.")
             seen.add(rid)
 
+    @staticmethod
+    @_primexpr
+    def _check_input_dim(shape, cls_name):
+        def _check(dim):
+            if dim not in (2, 4):
+                raise ValueError(f"For '{cls_name}', the must have 2 dims or 4 dims, but got {dim}.")
+        dim = len(shape)
+        _check(dim)
+
 
 class LayerNorm(Cell):
     r"""
@@ -1092,7 +1100,8 @@ class GroupNorm(Cell):
         dtype (:class:`mindspore.dtype`): Dtype of Parameters. Default: ``mstype.float32`` .
 
     Inputs:
-        - **x** (Tensor) - The input feature with shape :math:`(N, C, H, W)` .
+        - **x** (Tensor) - The input feature with shape :math:`(N, C, *)`, where :math:`*` means, any number of
+          additional dimensions.
 
     Outputs:
         Tensor, the normalized and scaled offset tensor, has the same shape and data type as the `x`.
@@ -1137,34 +1146,13 @@ class GroupNorm(Cell):
         self.affine = validator.check_bool(affine, arg_name="affine", prim_name=self.cls_name)
 
         self.gamma = Parameter(initializer(
-            gamma_init, num_channels, dtype=dtype), name="gamma", requires_grad=affine)
+            gamma_init, self.num_channels, dtype=dtype), name="gamma", requires_grad=affine)
         self.beta = Parameter(initializer(
-            beta_init, num_channels, dtype=dtype), name="beta", requires_grad=affine)
-        self.reduce_mean = P.ReduceMean(keep_dims=True)
-        self.reduce_sum = P.ReduceSum(keep_dims=True)
-        self.shape = F.shape
-        self.reshape = F.reshape
-        self.square = F.square
-        self.sqrt = P.Sqrt()
+            beta_init, self.num_channels, dtype=dtype), name="beta", requires_grad=affine)
 
     def _cal_output(self, x):
         """calculate groupnorm output"""
-        batch, channel, height, width = F.shape(x)
-        self._channel_check(channel, self.num_channels, self.cls_name)
-        x = F.reshape(x, (batch, self.num_groups, -1))
-        mean = self.reduce_mean(x, 2)
-        var = F.div(self.reduce_sum(F.square(F.sub(x, mean)), 2), (channel * height * width / self.num_groups))
-        std = self.sqrt(var + self.eps)
-        x = F.div(F.sub(x, mean), std)
-        x = F.reshape(x, (batch, channel, height, width))
-        output = F.add(x * F.reshape(self.gamma, (-1, 1, 1)), F.reshape(self.beta, (-1, 1, 1)))
-        return output
-
-    @staticmethod
-    @_primexpr
-    def _check_input_dim(shape, cls_name):
-        dim = len(shape)
-        _check_dim(dim, 4, cls_name)
+        return group_norm(x, self.num_groups, self.gamma.to(x.dtype), self.beta.to(x.dtype), self.eps)
 
     @staticmethod
     @_primexpr
@@ -1185,7 +1173,5 @@ class GroupNorm(Cell):
         return 'num_groups={}, num_channels={}'.format(self.num_groups, self.num_channels)
 
     def construct(self, x):
-        self._check_input_dim(F.shape(x), self.cls_name)
-        self._check_dtype(x.dtype, [mstype.float16, mstype.float32], self.cls_name)
         output = self._cal_output(x)
         return output

mindspore/nn/layer/padding.py

@@ -208,24 +208,11 @@ class _ConstantPadNd(Cell):
             raise TypeError(msg)
 
         self.value = value
-        self.padding = _swap_to_ms_padding_order(padding)
-        self._name = name
+        self.padding = padding
 
     def construct(self, x):
         """Construct the pad net."""
-        input_shape = x.shape
-        padding = _check(input_shape, self.padding, self._name)
-        new_padding, start, end = _get_new_padding(padding)
-        mask = ops.OnesLike()(x)
-        output = ops.Pad(new_padding)(x)
-        mask = ops.Pad(new_padding)(mask)
-        ones = ops.OnesLike()(output)
-        value = ops.fill(output.dtype, output.shape, self.value)
-        output = ops.Add()(ops.Mul()(mask, output), ops.Mul()(ops.Sub()(ones, mask), value))
-        slice_op = ops.Slice()
-        begin, size = _get_begin_size(output.shape, start, end)
-        output = slice_op(output, begin, size)
-        return output
+        return ops.pad(x, padding=self.padding, mode='constant', value=self.value)
 
 
 class ConstantPad1d(_ConstantPadNd):
@@ -238,8 +225,13 @@ class ConstantPad1d(_ConstantPadNd):
             If a 2-tuple, uses (padding_0, padding_1) to pad. If the input is `x`, the size of last
             dimension of output is :math:`padding\_0 + x.shape[-1] + padding\_1`. The remaining dimensions
             of the output are consistent with those of the input.
+            Only support non-negative value while running in Ascend.
         value (Union[int, float]): Padding value.
 
+    Inputs:
+        - **x** (Tensor) - shape is :math:`(N, *)`, where :math:`*` means, any number of additional dimensions.
+          It is not supported that the size of dimensions is greater than 5 while running on Ascend.
+
     Returns:
         Tensor, the tensor after padding.
 
@@ -248,6 +240,8 @@ class ConstantPad1d(_ConstantPadNd):
         TypeError: If `value` is not int or float.
         ValueError: If the length of `padding` with tuple type is not equal to 2.
         ValueError: If the output shape after padding is not positive.
+        ValueError: If the rank of 'x' is more than 5 while running in Ascend.
+        ValueError: If `padding` contains negative value while running in Ascend.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -316,8 +310,13 @@ class ConstantPad2d(_ConstantPadNd):
             If the input is `x`, the size of last dimension of output is :math:`padding\_0 + x.shape[-1] + padding\_1`.
             The size of penultimate dimension of output is :math:`padding\_2 + x.shape[-2] + padding\_3`.
             The remaining dimensions of the output are consistent with those of the input.
+            Only support non-negative value while running in Ascend.
         value (Union[int, float]): Padding value.
 
+    Inputs:
+        - **x** (Tensor) - shape is :math:`(N, *)`, where :math:`*` means, any number of additional dimensions.
+          It is not supported that the size of dimensions is greater than 5 while running on Ascend.
+
     Returns:
         Tensor, the tensor after padding.
 
@@ -326,6 +325,8 @@ class ConstantPad2d(_ConstantPadNd):
         TypeError: If `value` is not int or float.
         ValueError: If the length of `padding` is more than 4 or not a multiple of 2.
         ValueError: If the output shape after padding is not positive.
+        ValueError: If the rank of 'x' is more than 5 while running in Ascend.
+        ValueError: If `padding` contains negative value while running in Ascend.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -369,8 +370,13 @@ class ConstantPad3d(_ConstantPadNd):
             The size of penultimate dimension of output is :math:`padding\_2 + x.shape[-2] + padding\_3`.
             The size of 3rd to last dimension of output is :math:`padding\_4 + x.shape[-3] + padding\_5`.
             The remaining dimensions of the output are consistent with those of the input.
+            Only support non-negative value while running in Ascend.
         value (Union[int, float]): Padding value.
 
+    Inputs:
+        - **x** (Tensor) - shape is :math:`(N, *)`, where :math:`*` means, any number of additional dimensions.
+          It is not supported that the size of dimensions is greater than 5 while running on Ascend.
+
     Returns:
         Tensor, the tensor after padding.
 
@@ -379,6 +385,8 @@ class ConstantPad3d(_ConstantPadNd):
         TypeError: If `value` is not int or float.
         ValueError: If the length of `padding` is more than 6 or not a multiple of 2.
         ValueError: If the output shape after padding is not positive.
+        ValueError: If the rank of 'x' is more than 5 while running in Ascend.
+        ValueError: If `padding` contains negative value while running in Ascend.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -620,6 +628,11 @@ class ZeroPad2d(_ConstantPadNd):
             If the input is `x`, the size of last dimension of output is :math:`padding\_0 + x.shape[-1] + padding\_1`.
             The size of penultimate dimension of output is :math:`padding\_2 + x.shape[-2] + padding\_3`.
             The remaining dimensions of the output are consistent with those of the input.
+            Only support non-negative value while running in Ascend.
+
+    Inputs:
+        - **x** (Tensor) - shape is :math:`(N, *)`, where :math:`*` means, any number of additional dimensions.
+          It is not supported that the size of dimensions is greater than 5 while running in Ascend.
 
     Returns:
         Tensor, the tensor after padding.
@@ -628,6 +641,8 @@ class ZeroPad2d(_ConstantPadNd):
         TypeError: If `padding` is not a tuple or int.
         ValueError: If the length of `padding` is more than 4 or not a multiple of 2.
         ValueError: If the output shape after padding is not positive.
+        ValueError: If the rank of 'x' is more than 5 while running in Ascend.
+        ValueError: If `padding` contains negative value while running in Ascend.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -679,18 +694,12 @@ class _ReplicationPadNd(Cell):
         self.padding = padding
         self.padv3 = nn_ops.PadV3(mode="edge")
 
-    @staticmethod
-    @_primexpr
-    def _check_input_dim(shape, cls_name):
-        raise NotImplementedError
-
     @staticmethod
     @constexpr
     def _need_expend_dim(x):
         raise NotImplementedError
 
     def construct(self, x):
-        self._check_input_dim(x.shape, self.name)
         need_expend_dims = self._need_expend_dim(x)
         if need_expend_dims:
             x = x.expand_dims(0)
@@ -751,12 +760,6 @@ class ReplicationPad1d(_ReplicationPadNd):
             padding = (padding, padding)
         super(ReplicationPad1d, self).__init__(padding, name="ReplicationPad1d")
 
-    @staticmethod
-    @_primexpr
-    def _check_input_dim(shape, cls_name):
-        dim = len(shape)
-        _check_dim(dim, 2, 3, cls_name)
-
     def _need_expend_dim(self, x):
         input_shape = x.shape
         return 1 if len(input_shape) == 2 else 0
@@ -821,12 +824,6 @@ class ReplicationPad2d(_ReplicationPadNd):
             padding = (padding, padding, padding, padding)
         super(ReplicationPad2d, self).__init__(padding, name="ReplicationPad2d")
 
-    @staticmethod
-    @_primexpr
-    def _check_input_dim(shape, cls_name):
-        dim = len(shape)
-        _check_dim(dim, 3, 4, cls_name)
-
     def _need_expend_dim(self, x):
         input_shape = x.shape
         return 1 if len(input_shape) == 3 else 0
@@ -892,12 +889,6 @@ class ReplicationPad3d(_ReplicationPadNd):
             padding = (padding, padding, padding, padding, padding, padding)
         super(ReplicationPad3d, self).__init__(padding, name="ReplicationPad3d")
 
-    @staticmethod
-    @_primexpr
-    def _check_input_dim(shape, cls_name):
-        dim = len(shape)
-        _check_dim(dim, 4, 5, cls_name)
-
     def _need_expend_dim(self, x):
         input_shape = x.shape
         return 1 if len(input_shape) == 4 else 0

mindspore/nn/layer/pooling.py

@@ -27,6 +27,7 @@ from mindspore.common import dtype as mstype
 from mindspore.ops.operations.nn_ops import AdaptiveMaxPool2D
 from mindspore.ops.operations.nn_ops import AdaptiveMaxPool3D, AdaptiveAvgPool3D
 from mindspore.nn.cell import Cell
+from mindspore._c_expression import MSContext
 
 __all__ = ['AvgPool3d', 'MaxPool3d', 'AvgPool2d', 'MaxPool2d', 'AvgPool1d', 'MaxPool1d', 'FractionalMaxPool2d',
            'FractionalMaxPool3d', 'AdaptiveAvgPool1d', 'AdaptiveMaxPool1d', 'AdaptiveMaxPool2d', 'AdaptiveMaxPool3d',
@@ -105,7 +106,8 @@ class LPPool1d(Cell):
         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. Default: ``None`` .
-        ceil_mode (bool): Whether to use ceil or floor to calculate output shape. Default: ``False`` .
+        ceil_mode (bool): If ``True``, use ceil to calculate output shape.
+            If ``False``, use ceil 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})`.
@@ -119,7 +121,7 @@ class LPPool1d(Cell):
 
 
     Raises:
-        TypeError: If `x` is not an Tensor.
+        TypeError: If `x` is not a Tensor.
         TypeError: If `kernel_size` or `stride` is not an int.
         TypeError: If `ceil_mode` is not a bool.
         TypeError: If `norm_type` is neither float nor int.
@@ -168,7 +170,7 @@ class LPPool2d(Cell):
         f(X) = \sqrt[p]{\sum_{x \in X} x^{p}}
 
     Args:
-        norm_type(Union[int, float]) - Type of normalization, represents :math:`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).
@@ -179,7 +181,7 @@ class LPPool2d(Cell):
             or a tuple of two int numbers that represent height and width respectively.
         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,
+            represent height and width of movement respectively, 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`` .
 
@@ -197,7 +199,7 @@ class LPPool2d(Cell):
             W_{out} = \left\lfloor\frac{W_{in} - \text{kernel_size}[1]}{\text{stride}[1]} + 1\right\rfloor
 
     Raises:
-        TypeError: If `x` is not an Tensor.
+        TypeError: If `x` is not a Tensor.
         TypeError: If `kernel_size` or `stride` is neither int nor tuple.
         TypeError: If `ceil_mode` is not a bool.
         TypeError: If `norm_type` is neither float nor int.
@@ -324,7 +326,8 @@ class MaxPool3d(_PoolNd):
             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`` .
+        ceil_mode (bool): If ``True``, use ceil to calculate output shape.
+            If ``False``, use ceil to calculate output shape. Default: ``False`` .
 
     Inputs:
         - **x** (Tensor) - Tensor of shape :math:`(N_{in}, C_{in}, D_{in}, H_{in}, W_{in})` or
@@ -620,7 +623,7 @@ class MaxPool1d(_PoolNd):
               at the begin and end is determined by the `padding` parameter.
               If this mode is set, `padding` must be greater than or equal to 0.
 
-        padding (Union(int, tuple[int], list[int])): Padding value for the pooling. Default value is 0.
+        padding (Union(int, tuple[int], list[int])): 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,
@@ -1012,8 +1015,12 @@ class AvgPool2d(_PoolNd):
                  data_format="NCHW"):
         """Initialize AvgPool2d."""
         super(AvgPool2d, self).__init__(kernel_size, stride, pad_mode, data_format)
+        self.ascend_910bc_target = (MSContext.get_instance().get_ascend_soc_version() in ['ascend910b', 'ascend910c'])
         if pad_mode.upper() == 'PAD' or padding != 0 or ceil_mode or not count_include_pad \
                 or divisor_override is not None:
+            if self.ascend_910bc_target:
+                raise ValueError(f"For '{self.cls_name}, the pad_mod 'PAD' is not support in 910B now, "
+                                 f"it will be supported in the future.")
             if self.format == "NHWC":
                 raise ValueError(f"For '{self.cls_name}, the 'NHWC' format are not support when 'pad_mode' is 'pad' or "
                                  f"'padding' is not 0 or 'ceil_mode' is not False or 'count_include_pad' is not True"
@@ -1660,6 +1667,8 @@ class AdaptiveMaxPool3d(Cell):
     def __init__(self, output_size, return_indices=False):
         """Initialize AdaptiveMaxPool3d."""
         super(AdaptiveMaxPool3d, self).__init__()
+        if isinstance(output_size, int):
+            output_size = (output_size, output_size, output_size)
         self.output_size = Tensor(output_size, dtype=mstype.int32)
         self.return_indices = return_indices
         self.adaptive_max_pool3d = AdaptiveMaxPool3D()
@@ -1975,7 +1984,7 @@ class MaxUnpool2d(Cell):
         stride (Union[int, tuple[int]]): The distance of kernel moving, an int number that represents
             the height and width of movement are both stride, or a tuple of two int numbers that
             represent height and width of movement respectively.
-            If stride is None, then stride equal to kernel_size. Default: ``None`` .
+            If stride is ``None``, then stride equal to kernel_size. Default: ``None`` .
         padding (Union[int, tuple[int]]): The pad value to be filled. Default: ``0`` . If `padding` is an integer,
             the paddings of height and width are the same, equal to padding. If `padding` is a tuple of two
             integers, the padding of height and width equal to padding[0] and padding[1] correspondingly.
@@ -2068,7 +2077,7 @@ class MaxUnpool3d(Cell):
         stride (Union[int, tuple[int]]): The distance of kernel moving, an int number that represents
             the depth, height and width of movement are both stride, or a tuple of three int numbers that
             represent depth, height and width of movement respectively.
-            If stride is None, then stride equal to kernel_size. Default: ``None`` .
+            If stride is ``None``, then stride equal to kernel_size. Default: ``None`` .
         padding (Union[int, tuple[int]]): The pad value to be filled. Default: ``0`` . If `padding` is an integer,
             the paddings of depth, height and width are the same, equal to padding. If `padding` is a tuple of three
             integers, the padding of depth, height and width equal to padding[0], padding[1] and padding[2]

mindspore/nn/layer/rnn_cells.py

@@ -25,7 +25,7 @@ from mindspore import log as logger
 from mindspore.common.tensor import Tensor
 from mindspore.common.parameter import Parameter
 from mindspore.common.initializer import initializer, Uniform
-from mindspore.ops.primitive import constexpr, _primexpr
+from mindspore.ops.primitive import constexpr
 from mindspore.nn.cell import Cell
 from mindspore import _checkparam as validator
 
@@ -61,13 +61,6 @@ def _check_tuple_length(param_name, input_data, length, cls_name):
                         f"but got '{len(input_data)}'")
 
 
-@_primexpr
-def _check_batch_size_equal(batch_size_x, batch_size_hx, cls_name):
-    if batch_size_x != batch_size_hx:
-        raise ValueError(f"For '{cls_name}' batch size of x and hx must be equal, but got {batch_size_x} of x "
-                         f"and {batch_size_hx} of hx.")
-
-
 def _check_lstmcell_init(func):
     """Internal function, used to check init args."""
     @wraps(func)
@@ -185,7 +178,7 @@ class RNNCell(RNNCellBase):
     Args:
         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`` .
+        has_bias (bool): Whether the cell has bias :math:`b_{ih}` and :math:`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`` .
@@ -232,7 +225,6 @@ class RNNCell(RNNCellBase):
         _check_is_tensor('hx', hx, self.cls_name)
         _check_input_dtype(x.dtype, "x", [mstype.float32, mstype.float16], self.cls_name)
         _check_input_dtype(hx.dtype, "hx", [mstype.float32, mstype.float16], self.cls_name)
-        _check_batch_size_equal(x.shape[0], hx.shape[0], self.cls_name)
 
         if self.nonlinearity == "tanh":
             ret = _rnn_tanh_cell(x, hx, self.weight_ih, self.weight_hh, self.bias_ih, self.bias_hh)
@@ -271,7 +263,7 @@ class LSTMCell(RNNCellBase):
     Args:
         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`` .
+        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:
@@ -318,8 +310,6 @@ class LSTMCell(RNNCellBase):
         _check_input_dtype(x.dtype, "x", [mstype.float32, mstype.float16], self.cls_name)
         _check_input_dtype(hx[0].dtype, "hx[0]", [mstype.float32, mstype.float16], self.cls_name)
         _check_input_dtype(hx[1].dtype, "hx[1]", [mstype.float32, mstype.float16], self.cls_name)
-        _check_batch_size_equal(x.shape[0], hx[0].shape[0], self.cls_name)
-        _check_batch_size_equal(x.shape[0], hx[1].shape[0], self.cls_name)
         return _lstm_cell(x, hx, self.weight_ih, self.weight_hh, self.bias_ih, self.bias_hh)
 
     def _check_construct_args(self, *inputs, **kwargs):
@@ -346,7 +336,8 @@ class GRUCell(RNNCellBase):
         \end{array}
 
     Here :math:`\sigma` is the sigmoid function, and :math:`*` is the Hadamard product. :math:`W, b`
-    are learnable weights between the output and the input in the formula. For instance,
+    are learnable weights between the output and the input in the formula. :math:`h` is hidden state.
+    :math:`r` is reset gate. :math:`z` is update gate. :math:`n` is n-th layer. For instance,
     :math:`W_{ir}, b_{ir}` are the weight and bias used to transform from input :math:`x` to :math:`r`.
     Details can be found in paper
     `Learning Phrase Representations using RNN Encoder–Decoder for Statistical Machine Translation
@@ -355,7 +346,7 @@ class GRUCell(RNNCellBase):
     Args:
         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`` .
+        has_bias (bool): Whether the cell has bias :math:`b_{in}` and :math:`b_{hn}`. Default: ``True`` .
         dtype (:class:`mindspore.dtype`): Dtype of Parameters. Default: ``mstype.float32`` .
 
     Inputs:
@@ -394,5 +385,4 @@ class GRUCell(RNNCellBase):
         _check_is_tensor('hx', hx, self.cls_name)
         _check_input_dtype(x.dtype, "x", [mstype.float32, mstype.float16], self.cls_name)
         _check_input_dtype(hx.dtype, "hx", [mstype.float32, mstype.float16], self.cls_name)
-        _check_batch_size_equal(x.shape[0], hx.shape[0], self.cls_name)
         return _gru_cell(x, hx, self.weight_ih, self.weight_hh, self.bias_ih, self.bias_hh)