mindspore 2.2.14__cp39-cp39-win_amd64.whl → 2.4.0__cp39-cp39-win_amd64.whl

mindspore/nn/layer/normalization.py

@@ -19,9 +19,9 @@ from __future__ import division
 import itertools
 import numbers
 import hashlib
-
+import numpy as np
+import mindspore.ops as ops
 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,8 +36,9 @@ 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',
+__all__ = ['BatchNorm1d', 'BatchNorm2d', 'BatchNorm3d', 'LayerNorm', 'LayerNormExt', 'GroupNorm',
            'SyncBatchNorm', 'InstanceNorm1d', 'InstanceNorm2d', 'InstanceNorm3d']
 
 
@@ -128,15 +129,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 +150,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 +166,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 +207,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 +303,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 +392,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 +471,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 +559,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/docs/en/master/model_train/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/docs/en/master/model_train/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/docs/en/master/model_train/parallel/dynamic_cluster.html>`_ .
 
             This example should be run with multiple devices.
 
@@ -649,16 +659,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 +668,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"""
@@ -766,6 +775,101 @@ class LayerNorm(Cell):
             self.normalized_shape, self.begin_norm_axis, self.begin_params_axis, self.gamma, self.beta)
 
 
+class LayerNormExt(Cell):
+    r"""
+    Applies Layer Normalization over a mini-batch of inputs.
+
+    Layer Normalization is widely used in recurrent neural networks. It applies
+    normalization on a mini-batch of inputs for each single training case as described
+    in the paper `Layer Normalization <https://arxiv.org/pdf/1607.06450.pdf>`_.
+
+    Unlike Batch Normalization, Layer Normalization performs exactly the same computation at training and
+    testing time. It is applied across all channels and pixel but only one batch size.
+    :math:`\gamma` is the scale value learned through training and :math:`\beta` is the shift value.
+    It can be described using the following formula:
+
+    .. math::
+        y = \frac{x - \mathrm{E}[x]}{\sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma + \beta
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        normalized_shape (Union(tuple[int], list[int], int)): The normalized shape of `x` for LayerNorm
+        eps (float): A value added to the denominator for numerical stability(:math:`\epsilon`). Default: ``1e-5`` .
+        elementwise_affine (bool): Whether affine transformation is required. When this parameter is set to ``True``,
+            the weight parameter is initialized to 1 and the offset is initialized to 0. Default: ``True``.
+        bias (bool): If set to ``False``, the layer will not learn an additive bias (only relevant if
+             `elementwise_affine` is ``True``). Default: ``True``.
+        dtype (:class:`mindspore.dtype`): Dtype of Parameters. Default: ``None`` .
+
+    Inputs:
+        - **x** (Tensor) - The shape is :math:`(N, *)`, where :math:`*` is equal to normalized_shape.
+
+    Outputs:
+        Tensor, the normalized and scaled offset tensor, has the same shape and data type as the `x`.
+
+    Raises:
+        TypeError: If `eps` is not a float.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> import numpy as np
+        >>> x = ms.Tensor(np.ones([20, 5, 10, 10]), ms.float32)
+        >>> shape1 = x.shape[1:]
+        >>> m = ms.nn.LayerNormExt(shape1)
+        >>> output = m(x).shape
+        >>> print(output)
+        (20, 5, 10, 10)
+    """
+
+    def __init__(self,
+                 normalized_shape,
+                 eps=1e-5,
+                 elementwise_affine=True,
+                 bias=True,
+                 dtype=None
+                 ):
+        """Initialize LayerNormExt."""
+        super(LayerNormExt, self).__init__()
+        if isinstance(normalized_shape, numbers.Integral):
+            # mypy error: incompatible types in assignment
+            normalized_shape = (normalized_shape,)  # type: ignore[assignment]
+        if not isinstance(normalized_shape, (tuple, list)):
+            raise TypeError(f"For '{self.cls_name}', the type of 'normalized_shape' must be tuple[int] or list[int], "
+                            f"but got {normalized_shape} and the type is {type(normalized_shape)}.")
+        if not normalized_shape:
+            raise ValueError(
+                f"Expected normalized_shape to be at least 1-dimensional, i.e., containing at "
+                f"least one element, but got normalized_shape = {normalized_shape}"
+            )
+        self.normalized_shape = tuple(normalized_shape)
+        self.eps = eps
+        self.elementwise_affine = elementwise_affine
+        ms_dtype = mstype.float32 if dtype is None else dtype
+        if self.elementwise_affine:
+            self.weight = Parameter(Tensor(np.ones(normalized_shape), ms_dtype), name="weight")
+            if bias:
+                self.bias = Parameter(Tensor(np.zeros(normalized_shape), ms_dtype), name="bias")
+            else:
+                self.bias = None
+        else:
+            self.weight = None
+            self.bias = None
+
+    def construct(self, input):
+        y = ops.layer_norm(input, self.normalized_shape, self.weight,
+                           self.bias, self.eps)
+        return y
+
+    def extend_repr(self):
+        return 'normalized_shape={}, eps={}, elementwise_affine={}'.format(
+            self.normalized_shape, self.eps, self.elementwise_affine)
+
+
 class _InstanceNorm(Cell):
     """Instance Normalization base class."""
     @cell_attr_register
@@ -1092,7 +1196,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 +1242,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 +1269,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``
@@ -285,20 +279,6 @@ class ConstantPad1d(_ConstantPadNd):
            [0.5 1.  1.  1.  1.  0.5]]]]
         >>> print(out.shape)
         (1, 2, 3, 6)
-        >>> # padding is negative
-        >>> padding = (-1, 0)
-        >>> value = 0.5
-        >>> pad1d = ms.nn.ConstantPad1d(padding, value)
-        >>> out = pad1d(x)
-        >>> print(out)
-        [[[[1. 1. 1.]
-           [1. 1. 1.]
-           [1. 1. 1.]]
-          [[1. 1. 1.]
-           [1. 1. 1.]
-           [1. 1. 1.]]]]
-        >>> print(out.shape)
-        (1, 2, 3, 3)
     """
 
     def __init__(self, padding, value):
@@ -316,8 +296,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 +311,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``
@@ -335,21 +322,21 @@ class ConstantPad2d(_ConstantPadNd):
         >>> import mindspore as ms
         >>> x = np.ones(shape=(1, 2, 3, 4)).astype(np.float32)
         >>> x = ms.Tensor(x)
-        >>> padding = (-1, 1, 0, 1)
+        >>> padding = (1, 1, 0, 1)
         >>> value = 0.5
         >>> pad2d = ms.nn.ConstantPad2d(padding, value)
         >>> out = pad2d(x)
         >>> print(out)
-        [[[[1.  1.  1.  0.5]
-           [1.  1.  1.  0.5]
-           [1.  1.  1.  0.5]
-           [0.5 0.5 0.5 0.5]]
-          [[1.  1.  1.  0.5]
-           [1.  1.  1.  0.5]
-           [1.  1.  1.  0.5]
-           [0.5 0.5 0.5 0.5]]]]
+        [[[[0.5  1.  1.  1.  1.  0.5]
+           [0.5  1.  1.  1.  1.  0.5]
+           [0.5  1.  1.  1.  1.  0.5]
+           [0.5  0.5 0.5 0.5 0.5 0.5]]
+          [[0.5  1.  1.  1.  1.  0.5]
+           [0.5  1.  1.  1.  1.  0.5]
+           [0.5  1.  1.  1.  1.  0.5]
+           [0.5  0.5 0.5 0.5 0.5 0.5]]]]
         >>> print(out.shape)
-        (1, 2, 4, 4)
+        (1, 2, 4, 6)
     """
 
     def __init__(self, padding, value):
@@ -369,8 +356,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 +371,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``
@@ -388,25 +382,25 @@ class ConstantPad3d(_ConstantPadNd):
         >>> import mindspore as ms
         >>> x = np.ones(shape=(1, 2, 3, 4)).astype(np.float32)
         >>> x = ms.Tensor(x)
-        >>> padding = (-1, 1, 0, 1, 1, 0)
+        >>> padding = (1, 1, 0, 1, 1, 0)
         >>> value = 0.5
         >>> pad3d = ms.nn.ConstantPad3d(padding, value)
         >>> out = pad3d(x)
         >>> print(out)
-        [[[[0.5 0.5 0.5 0.5]
-           [0.5 0.5 0.5 0.5]
-           [0.5 0.5 0.5 0.5]
-           [0.5 0.5 0.5 0.5]]
-          [[1.  1.  1.  0.5]
-           [1.  1.  1.  0.5]
-           [1.  1.  1.  0.5]
-           [0.5 0.5 0.5 0.5]]
-          [[1.  1.  1.  0.5]
-           [1.  1.  1.  0.5]
-           [1.  1.  1.  0.5]
-           [0.5 0.5 0.5 0.5]]]]
+        [[[[0.5 0.5 0.5 0.5 0.5 0.5]
+           [0.5 0.5 0.5 0.5 0.5 0.5]
+           [0.5 0.5 0.5 0.5 0.5 0.5]
+           [0.5 0.5 0.5 0.5 0.5 0.5]]
+          [[0.5 1.  1.  1.  1.  0.5]
+           [0.5 1.  1.  1.  1.  0.5]
+           [0.5 1.  1.  1.  1.  0.5]
+           [0.5 0.5 0.5 0.5 0.5 0.5]]
+          [[0.5 1.  1.  1.  1.  0.5]
+           [0.5 1.  1.  1.  1.  0.5]
+           [0.5 1.  1.  1.  1.  0.5]
+           [0.5 0.5 0.5 0.5 0.5 0.5]]]]
         >>> print(out.shape)
-        (1, 3, 4, 4)
+        (1, 3, 4, 6)
     """
 
     def __init__(self, padding, value):
@@ -620,6 +614,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 +627,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``
@@ -637,20 +638,20 @@ class ZeroPad2d(_ConstantPadNd):
         >>> import mindspore as ms
         >>> x = np.ones(shape=(1, 2, 3, 4)).astype(np.float32)
         >>> x = ms.Tensor(x)
-        >>> padding = (-1, 1, 0, 1)
+        >>> padding = (1, 1, 0, 1)
         >>> pad = ms.nn.ZeroPad2d(padding)
         >>> out = pad(x)
         >>> print(out)
-        [[[[1. 1. 1. 0.]
-           [1. 1. 1. 0.]
-           [1. 1. 1. 0.]
-           [0. 0. 0. 0.]]
-          [[1. 1. 1. 0.]
-           [1. 1. 1. 0.]
-           [1. 1. 1. 0.]
-           [0. 0. 0. 0.]]]]
+        [[[[0. 1. 1. 1. 1. 0.]
+           [0. 1. 1. 1. 1. 0.]
+           [0. 1. 1. 1. 1. 0.]
+           [0. 0. 0. 0. 0. 0.]]
+          [[0. 1. 1. 1. 1. 0.]
+           [0. 1. 1. 1. 1. 0.]
+           [0. 1. 1. 1. 1. 0.]
+           [0. 0. 0. 0. 0. 0.]]]]
         >>> print(out.shape)
-        (1, 2, 4, 4)
+        (1, 2, 4, 6)
     """
 
     def __init__(self, padding):
@@ -679,18 +680,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 +746,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 +810,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 +875,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