mindspore 2.3.0__cp39-none-any.whl → 2.3.0rc2__cp39-none-any.whl

mindspore/ops/function/nn_func.py

@@ -39,15 +39,16 @@ from mindspore.ops.operations.nn_ops import FractionalMaxPoolWithFixedKsize, Fra
 from mindspore.ops.operations.nn_ops import PadV3
 from mindspore.ops.operations.nn_ops import ChannelShuffle
 from mindspore.ops.operations.nn_ops import TripletMarginLoss
+from mindspore.ops.operations.nn_ops import LayerNormExt
 from mindspore.ops.operations._sequence_ops import TupleToTensor, TensorToTuple, ListToTensor
 from mindspore.common.api import _function_forbid_reuse
 from mindspore.ops.auto_generate import log_softmax, dense, prelu, celu, relu, fast_gelu, silu, elu, sigmoid, relu6
-from mindspore.ops.auto_generate import group_norm_op, rms_norm, layer_norm_ext_op, batch_norm_ext_op
-from mindspore.ops.auto_generate import (reflection_pad_1d_op, reflection_pad_2d_op, reflection_pad_3d_op, # pylint: disable=W0611
+from mindspore.ops.auto_generate.gen_ops_prim import GroupNorm
+from mindspore.ops.auto_generate import (reflection_pad_1d_op, reflection_pad_2d_op, reflection_pad_3d_op,
                                          replication_pad_1d_op, replication_pad_2d_op, replication_pad_3d_op,
-                                         constant_pad_nd_op, dropout_ext_op, reverse_v2_impl)
+                                         constant_pad_nd_op, dropout_ext_op)
 from mindspore.ops.auto_generate.gen_ops_prim import embedding_op, Convolution
-from mindspore.common.generator import default_generator
+from mindspore.nn.generator import default_generator
 
 abs_ = P.Abs()
 add_ = P.Add()
@@ -104,7 +105,6 @@ check_int_const = validator.check_is_int
 check_non_negative_float_const = validator.check_non_negative_float
 check_string_const = constexpr(validator.check_string)
 
-generator_step_ = Tensor(1, mstype.int64)
 
 def adaptive_avg_pool2d(input, output_size):
     r"""
@@ -540,23 +540,22 @@ def avg_pool2d_ext(input, kernel_size, stride=None, padding=0, ceil_mode=False,
             count_include_pad (bool): If True, include the zero-padding in the averaging calculation.
                 Default: ``True`` .
             divisor_override (int): If specified, it will be used as divisor in the averaging calculation,
-                otherwise size of pooling region will be used. Default: ``None``.
+                otherwise `kernel_size` will be used. Default: ``None``.
 
         Returns:
             Tensor, with shape :math:`(N, C, H_{out}, W_{out})`.
 
-            .. math::
-                \begin{array}{ll} \\
-                    H_{out} = \frac{H_{in} + 2 \times padding[0] - kernel_size[0]}{stride[0]} + 1 \\
-                    W_{out} = \frac{W_{in} + 2 \times padding[1] - kernel_size[1]}{stride[1]} + 1
-                \end{array}
+        .. math::
+
+            H_{out} = \frac{H_{in} + 2 \times padding[0] - kernel_size[0]}{stride[0]} + 1
+            W_{out} = \frac{W_{in} + 2 \times padding[1] - kernel_size[1]}{stride[1]} + 1
 
         Raises:
             TypeError: If `input` is not a Tensor.
             TypeError: If `kernel_size` or `stride` is neither int nor tuple.
             TypeError: If `ceil_mode` or `count_include_pad` is not a bool.
-            TypeError: If `divisor_override` is not an int or None.
-            ValueError: If the dimension of `input` is not equal to `4` or `3`.
+            TypeError: If `divisor_override` is not an int.
+            ValueError: If length of shape of `input` is not equal to `4` or `3`.
             ValueError: If `kernel_size` or `stride` is less than 1.
             ValueError: If `kernel_size` or `stride` is a tuple whose length is not equal to `2` or `1`.
             ValueError: If `padding` is neither a int nor a tuple whose length is equal to `2` or `1`.
@@ -568,9 +567,9 @@ def avg_pool2d_ext(input, kernel_size, stride=None, padding=0, ceil_mode=False,
         Examples:
             >>> import mindspore
             >>> import numpy as np
-            >>> from mindspore import Tensor, ops
+            >>> from mindspore import Tensor, mint
             >>> x = Tensor(np.arange(1 * 3 * 3 * 4).reshape(1, 3, 3, 4), mindspore.float32)
-            >>> output = ops.function.nn_func.avg_pool2d_ext(x, kernel_size=2, stride=1)
+            >>> output = mint.avg_pool2d(x, kernel_size=2, stride=1)
             >>> print(output)
             [[[[ 2.5   3.5   4.5]
             [ 6.5   7.5   8.5]]
@@ -1222,12 +1221,12 @@ def max_unpool3d(x, indices, kernel_size, stride=None, padding=0, output_size=No
     return out
 
 
-def binary_cross_entropy_with_logits(input, target, weight=None, pos_weight=None, reduction='mean'):
+def binary_cross_entropy_with_logits(logits, label, weight=None, pos_weight=None, reduction='mean'):
     r"""
-    Adds sigmoid activation function to input `input` as logits, and uses the given logits to compute binary cross
-    entropy between the `input` and the `target`.
+    Adds sigmoid activation function to input `logits`, and uses the given logits to compute binary cross entropy
+    between the logits and the label.
 
-    Sets input `input` as :math:`X`, input target as :math:`Y`, input weight as :math:`W`, output as :math:`L`. Then,
+    Sets input logits as :math:`X`, input label as :math:`Y`, input weight as :math:`W`, output as :math:`L`. Then,
 
     .. math::
 
@@ -1268,14 +1267,14 @@ def binary_cross_entropy_with_logits(input, target, weight=None, pos_weight=None
     :math:`P_c>1` increases the recall, :math:`P_c<1` increases the precision.
 
     Args:
-        input (Tensor): Input `input`. Data type must be float16 or float32.
-        target (Tensor): Ground truth label, has the same shape as `input`.
+        logits (Tensor): Input logits. Data type must be float16 or float32.
+        label (Tensor): Ground truth label, has the same shape as `logits`.
           Data type must be float16 or float32.
         weight (Tensor, optional): A rescaling weight applied to the loss of each batch element. It can be
-          broadcast to a tensor with shape of `input`. Data type must be float16 or float32.
+          broadcast to a tensor with shape of `logits`. Data type must be float16 or float32.
           Default: ``None``, `weight` is a Tensor whose value is ``1``.
         pos_weight (Tensor, optional): A weight of positive examples. Must be a vector with length equal to the
-          number of classes. It can be broadcast to a tensor with shape of `input`.
+          number of classes. It can be broadcast to a tensor with shape of `logits`.
           Data type must be float16 or float32. Default: ``None``, `pos_weight` is a Tensor whose value is ``1``.
         reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
             ``'sum'`` . Default: ``'mean'`` .
@@ -1285,14 +1284,14 @@ def binary_cross_entropy_with_logits(input, target, weight=None, pos_weight=None
             - ``'sum'``: the output elements will be summed.
 
     Returns:
-        Tensor or Scalar, if `reduction` is ``'none'``, it's a tensor with the same shape and type as input `input`.
+        Tensor or Scalar, if `reduction` is ``'none'``, it's a tensor with the same shape and type as input `logits`.
         Otherwise, the output is a scalar.
 
     Raises:
-        TypeError: If input `input`, `target`, `weight`, `pos_weight` is not Tensor.
-        TypeError: If data type of input `input`, `target`, `weight`, `pos_weight` is neither float16 nor float32.
+        TypeError: If input `logits`, `label`, `weight`, `pos_weight` is not Tensor.
+        TypeError: If data type of input `logits`, `label`, `weight`, `pos_weight` is neither float16 nor float32.
         TypeError: If data type of input `reduction` is not string.
-        ValueError: If `weight` or `pos_weight` can not be broadcast to a tensor with shape of `input`.
+        ValueError: If `weight` or `pos_weight` can not be broadcast to a tensor with shape of `logits`.
         ValueError: If `reduction` is not one of ``'none'``, ``'mean'`` or ``'sum'``.
 
     Supported Platforms:
@@ -1302,17 +1301,21 @@ def binary_cross_entropy_with_logits(input, target, weight=None, pos_weight=None
         >>> import mindspore
         >>> import numpy as np
         >>> from mindspore import Tensor, ops
-        >>> input = Tensor(np.array([[-0.8, 1.2, 0.7], [-0.1, -0.4, 0.7]]), mindspore.float32)
-        >>> target = Tensor(np.array([[0.3, 0.8, 1.2], [-0.6, 0.1, 2.2]]), mindspore.float32)
+        >>> logits = Tensor(np.array([[-0.8, 1.2, 0.7], [-0.1, -0.4, 0.7]]), mindspore.float32)
+        >>> label = Tensor(np.array([[0.3, 0.8, 1.2], [-0.6, 0.1, 2.2]]), mindspore.float32)
         >>> weight = Tensor(np.array([1.0, 1.0, 1.0]), mindspore.float32)
         >>> pos_weight = Tensor(np.array([1.0, 1.0, 1.0]), mindspore.float32)
-        >>> output = ops.binary_cross_entropy_with_logits(input, target, weight, pos_weight)
+        >>> output = ops.binary_cross_entropy_with_logits(logits, label, weight, pos_weight)
         >>> print(output)
         0.3463612
     """
 
+    if weight is None:
+        weight = ops.ones_like(logits)
+    if pos_weight is None:
+        pos_weight = ops.ones_like(logits)
     bce_with_logits_loss_op = _get_cache_prim(NN_OPS.BCEWithLogitsLoss)(reduction)
-    return bce_with_logits_loss_op(input, target, weight, pos_weight)
+    return bce_with_logits_loss_op(logits, label, weight, pos_weight)
 
 
 @_function_forbid_reuse
@@ -1362,25 +1365,27 @@ def dropout(input, p=0.5, training=True, seed=None):
 
 
 @_function_forbid_reuse
-def dropout_ext(input, p=0.5, training=True):
+def dropout_ext(input, p=0.5, training=True, seed=None):
     r"""
     During training, randomly zeroes some of the elements of the input tensor
     with probability `p` from a Bernoulli distribution. It plays the role of reducing neuron correlation and
     avoid overfitting. And the return will be multiplied by :math:`\frac{1}{1-p}` during training.
-    During the reasoning, this operation returns the same Tensor as the `input`.
+    During the reasoning, this operation returns the same Tensor as the `x`.
 
     Args:
-        input (Tensor): The input Tensor of shape :math:`(*, N)`.
-        p (float): The dropping rate of input neurons, between 0 and 1, e.g. `p` = 0.1,
-            means dropping out 10% of input neurons. Default: ``0.5`` .
-        training (bool): Apply dropout if it is ``True`` , if it is ``False`` , the input is returned directly,
-            and `p` is invalid. Default: ``True``.
+        input (Tensor): The input Tensor of shape :math:`(*, N)`, with data type of float16, float32 or float64.
+        p (float, optional): The dropping rate, between 0 and 1, e.g. p = 0.1,
+            means dropping out 10% of input units. Default: ``0.5`` .
+        training (bool): Apply dropout_ext if is True. Default: ``True``.
+        seed (int, optional): Seed is used as entropy source for Random number engines generating pseudo-random numbers.
+            Default: ``None`` , which will be treated as ``0`` .
 
     Returns:
         - **output** (Tensor) - Zeroed tensor, with the same shape and data type as `input`.
 
     Raises:
         TypeError: If `p` is not a float.
+        TypeError: If dtype of `input` is not float16, float32 or float64.
         TypeError: If `input` is not a Tensor.
 
     Supported Platforms:
@@ -1390,14 +1395,15 @@ def dropout_ext(input, p=0.5, training=True):
         >>> import mindspore
         >>> from mindspore import Tensor, ops
         >>> input = Tensor(((20, 16), (50, 50)), mindspore.float32)
-        >>> output = ops.function.nn_func.dropout_ext(input, p=0.5)
+        >>> output = ops.dropout_ext(input, p=0.5)
         >>> print(output.shape)
         (2, 2)
     """
     check_bool_const(training, "training", "dropout_ext")
     if training is False:
         return input
-    seed, offset = default_generator._step(generator_step_)  # pylint: disable=protected-access
+    generator = default_generator()
+    seed, offset = generator(1)
     out, _ = dropout_ext_op(input, p, seed, offset)
     return out
 
@@ -2041,10 +2047,10 @@ def flip(input, dims):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> import mindspore
-        >>> from mindspore import ops
+        >>> import mindspore as ms
+        >>> import mindspore.ops as ops
         >>> import numpy as np
-        >>> input = mindspore.Tensor(np.arange(1, 9).reshape((2, 2, 2)))
+        >>> input = ms.Tensor(np.arange(1, 9).reshape((2, 2, 2)))
         >>> output = ops.flip(input, (0, 2))
         >>> print(output)
         [[[6 5]
@@ -2052,7 +2058,7 @@ def flip(input, dims):
          [[2 1]
           [4 3]]]
     """
-    res = reverse_v2_impl(input, dims)
+    res = _get_cache_prim(ops.ReverseV2)(axis=dims)(input)
     return res
 
 
@@ -2074,7 +2080,7 @@ def flipud(input):
 
     Examples:
         >>> import mindspore as ms
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> import numpy as np
         >>> input = ms.Tensor(np.arange(1, 9).reshape((2, 2, 2)))
         >>> output = ops.flipud(input)
@@ -2105,7 +2111,7 @@ def fliplr(input):
 
     Examples:
         >>> import mindspore as ms
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> import numpy as np
         >>> input = ms.Tensor(np.arange(1, 9).reshape((2, 2, 2)))
         >>> output = ops.fliplr(input)
@@ -2134,7 +2140,7 @@ def is_floating_point(input):
 
     Examples:
         >>> import mindspore as ms
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> from mindspore import Tensor
         >>> x = ms.Tensor([1, 2, 3], ms.float32)
         >>> y = ms.Tensor([1, 2, 3], ms.int64)
@@ -2582,9 +2588,8 @@ def interpolate(input,
                 "For 'interpolate', it is incorrect to set 'recompute_scale_factor' to True"
                 " after specifying an explicit 'size'.")
         if F.isconstant(shape) and F.isconstant(scale_factor):
-            tuple_len = min(len(shape) - 2, len(scale_factor))
-            size = tuple([floor(shape[i + 2] * scale_factor[i])
-                          for i in range(tuple_len)])
+            size = tuple([floor(shape[i + 2] * scale_factor[i]) for i in
+                          range(min(len(shape) - 2), len(scale_factor))])
         else:
             size = _interpolate_scale_factor_convert_size(shape, scale_factor)
         scale_factor = None
@@ -2634,9 +2639,8 @@ def _interpolate_ext_scale_factor_convert_size(input, scale_factor):
     shape = F.shape(input)
     size = None
     if F.isconstant(shape) and F.isconstant(scale_factor):
-        tuple_len = min(len(shape) - 2, len(scale_factor))
-        size = tuple([floor(shape[i + 2] * scale_factor[i])
-                      for i in range(tuple_len)])
+        size = tuple([floor(shape[i + 2] * scale_factor[i]) for i in
+                      range(min(len(shape) - 2), len(scale_factor))])
     else:
         x = tuple_to_tensor_(shape[2:], mstype.int64)
         y = tuple_to_tensor_(scale_factor, mstype.float32)
@@ -3038,54 +3042,6 @@ def softmax(input, axis=-1, *, dtype=None):
     return softmax_(input)
 
 
-def softmax_ext(input, dim=None, dtype=None):
-    r"""
-    Applies the Softmax operation to the input tensor on the specified axis.
-    Suppose a slice in the given axis :math:`dim`, then for each element :math:`input_i`,
-    the Softmax function is shown as follows:
-
-    .. math::
-        \text{output}(input_i) = \frac{\exp(input_i)}{\sum_{j = 0}^{N-1}\exp(input_j)},
-
-    where :math:`N` is the length of the tensor.
-
-    Args:
-        input (Tensor): Tensor of shape :math:`(N, *)`, where :math:`*` means, any number of
-            additional dimensions.
-        dim (int, optional): The dim to perform the Softmax operation. Default: ``None`` .
-
-    Keyword Args:
-        dtype (:class:`mindspore.dtype`, optional): When set, `input` will be converted to the specified type,
-            `dtype`, before execution, and dtype of returned Tensor will also be `dtype`. Default: ``None`` .
-
-    Returns:
-        Tensor, with the same type and shape as the `input`.
-
-    Raises:
-        TypeError: If `dim` is not an int.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> input = Tensor(np.array([1, 2, 3, 4, 5]), mindspore.float32)
-        >>> output = ops.function.nn_func.softmax_ext(input)
-        >>> print(output)
-        [0.01165623 0.03168492 0.08612854 0.23412167 0.6364086 ]
-    """
-    dim = -1 if dim is None else dim
-    if not isinstance(dim, int):
-        type_dim = type(dim).__name__
-        raise TypeError(f" the type of 'dim' must be 'int', but got '{dim}' with type '{type_dim}'.")
-    if dtype is not None:
-        input = ops.cast(input, dtype)
-    softmax_ = _get_cache_prim(P.Softmax)(dim)
-    return softmax_(input)
-
-
 def softmin(x, axis=-1, *, dtype=None):
     r"""
     Applies the Softmin operation to the input tensor on the specified axis.
@@ -3239,6 +3195,51 @@ def softplus(input, beta=1, threshold=20): # pylint:disable=redefined-outer-name
     return ops.select(input * beta > threshold, input, op_output)
 
 
+def softplus_ext(input, beta=1, threshold=20): # pylint:disable=redefined-outer-name
+    r"""
+    Applies softplus function to `input` element-wise.
+
+    The softplus function is shown as follows, x is the element of `input` :
+
+    .. math::
+
+        \text{output} = \frac{1}{beta}\log(1 + \exp(\text{beta * x}))
+
+    When :math:`input * beta > threshold`, the implementation converts to the linear function
+    to ensure numerical stability.
+
+    Args:
+        input (Tensor) - Tensor of any dimension.
+            Supported dtypes:
+
+            - Ascend: float16, float32, bfloat16
+
+        beta (number, optional) - The :math:`\beta` value in softplus function. Default: ``1`` .
+        threshold (number, optional) - When :math:`input * beta > threshold`, converting softplus to a linear function.
+            Default: ``20`` .
+
+    Returns:
+        Tensor, with the same type and shape as the `input` .
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If the dtype of `input` is not float16, float32, bfloat16.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, mint
+        >>> input = Tensor(np.array([0.1, 0.2, 30, 25]), mindspore.float32)
+        >>> output = mint.softplus(input)
+        >>> print(output)
+        [0.74439657 0.7981388 30. 25.]
+    """
+    return _get_cache_prim(ops.auto_generate.SoftplusExt)()(input, beta, threshold)
+
+
 def selu(input_x):
     r"""
     Activation function SeLU (Scaled exponential Linear Unit).
@@ -3576,10 +3577,7 @@ def pdist(input, p=2.0):
 
 def _circular_pad(input_x, padding):
     """circular pad"""
-    if isinstance(padding, tuple):
-        padding = tuple_to_tensor_(padding, mstype.int64)
-    elif isinstance(padding, list):
-        padding = list_to_tensor_(padding, mstype.int64)
+    padding = scalar_to_tensor_(padding, const_arg=True)
     is_expand = False
     if padding.shape[0] // 2 + 1 == input_x.ndim:
         input_x = input_x.expand_dims(0)
@@ -3590,85 +3588,24 @@ def _circular_pad(input_x, padding):
     return out
 
 
-def _reflection_pad(input, pad):
-    """reflection pad"""
-    out = input
-    if len(pad) == 2:
-        out = reflection_pad_1d_op(input, pad)
-    elif len(pad) == 4:
-        out = reflection_pad_2d_op(input, pad)
-    else:
-        out = reflection_pad_3d_op(input, pad)
-    return out
-
-
-def _replication_pad(input, pad):
-    """replication pad"""
-    out = input
-    if len(pad) == 2:
-        out = replication_pad_1d_op(input, pad)
-    elif len(pad) == 4:
-        out = replication_pad_2d_op(input, pad)
-    else:
-        out = replication_pad_3d_op(input, pad)
-    return out
-
-
-def pad_ext(input, pad, mode='constant', value=0.0):
+def pad_ext(input, pad, mode='constant', value=None):
     r"""
     Pads the input tensor according to the pad.
 
-    .. warning::
-        `circular` mode has poor performance and is not recommended.
-
     Args:
         input (Tensor): Tensor of shape :math:`(N, *)`, where :math:`*` means, any number of additional dimensions.
-        pad (Union[tuple[int], list[int], Tensor]): Filling position of pad.
-            :math:`\left\lfloor\frac{\text{len(pad)}}{2}\right\rfloor` dimensions
-            of `input` will be padded.
-
-            Example: to pad only the last dimension of the input tensor, then
-            :attr:`pad` has the form
-            :math:`(\text{padding_left}, \text{padding_right})`;
-
-            Example: to pad the last 2 dimensions of the input tensor, then use
-            :math:`(\text{padding_left}, \text{padding_right}, \text{padding_top}, \text{padding_bottom})`;
-
-            Example: to pad the last 3 dimensions, use
-            :math:`(\text{padding_left}, \text{padding_right}, \text{padding_top}, \text{padding_bottom},
-            \text{padding_front}, \text{padding_back})` and so on.
-
+        pad (tuple[int]): Filling position of pad.
         mode (str, optional): Pad filling mode, ``'constant'`` , ``'reflect'`` , ``'replicate'``  or ``'circular'`` .
             Default: ``'constant'`` .
-
-            For ``'constant'`` mode, please refer to :class:`mindspore.nn.ConstantPad1d` as an example to understand
-            this filling pattern and extend the padding pattern to n dimensions.
-
-            For ``'reflect'`` mode, please refer to :class:`mindspore.nn.ReflectionPad1d` as an example to understand
-            this filling pattern.
-            The reflect mode is used to pad the last three dimensions of 4D or 5D input, the last two dimensions of 3D
-            or 4D input, or the last dimension of 2D or 3D input.
-
-            For ``'replicate'`` mode, please refer to :class:`mindspore.nn.ReplicationPad1d` as an example to understand
-            this filling pattern.
-            The replicate mode is used to pad the last three dimensions of 4D or 5D input, the last two dimensions of 3D
-            or 4D input, or the last dimension of 2D or 3D input.
-
-            For ``'circular'`` mode, the pixels from one edge of the image are wrapped around to the opposite edge,
-            such that the pixel on the right edge of the image is replaced with the pixel on the left edge,
-            and the pixel on the bottom edge is replaced with the pixel on the top edge.
-            The circular mode is used to pad the last three dimensions of 4D or 5D input, the last two dimensions of 3D
-            or 4D input, or the last dimension of 2D or 3D input.
-
         value (Union[int, float, None], optional): Valid only in ``'constant'`` mode.
-            Set the padding value in ``'constant'`` mode. If the value is None, 0 is used as the default padding value.
-            Default: ``0.0`` .
+            Set the pad value in ``'constant'`` mode. If the value is None, 0 is used as the default pad value.
+            Default: ``None`` .
 
     Returns:
-        Tensor, the tensor after padding.
+        Tensor, the tensor after pad.
 
     Raises:
-        TypeError: If `pad` is not an int of tuple or int of list.
+        TypeError: If `pad` is not an int of tuple.
         TypeError: If `input` is not a Tensor.
         ValueError: If length of `pad` is not even.
         ValueError: If length of `pad` is greater than 6.
@@ -3678,10 +3615,11 @@ def pad_ext(input, pad, mode='constant', value=0.0):
         ``Ascend``
 
     Examples:
-        >>> from mindspore import ops
+        >>> import mindspore as ms
+        >>> from mindspore.mint.nn.functional import pad
         >>> import numpy as np
         >>> x = ms.Tensor(np.arange(1 * 2 * 2 * 2).reshape((1, 2, 2, 2)), dtype=ms.float64)
-        >>> output = ops.function.nn_func.pad_ext(x, [1, 0, 0, 1], mode='constant', value=6.0)
+        >>> output = pad(x, [1, 0, 0, 1], mode='constant', value=6.0)
         >>> print(output)
         [[[[6. 0. 1.]
            [6. 2. 3.]
@@ -3689,6 +3627,14 @@ def pad_ext(input, pad, mode='constant', value=0.0):
           [[6. 4. 5.]
            [6. 6. 7.]
            [6. 6. 6.]]]]
+        >>> output1 = ops.pad(x, (1, 0, 0, 1), mode='reflect')
+        >>> print(output1)
+        [[[[1. 0. 1.]
+           [3. 2. 3.]
+           [1. 0. 1.]]
+          [[5. 4. 5.]
+           [7. 6. 7.]
+           [5. 4. 5.]]]]
     """
     if not isinstance(input, Tensor):
         raise TypeError(f"For 'pad', the type of 'input' must be Tensor, but got {type(input)}.")
@@ -3698,17 +3644,30 @@ def pad_ext(input, pad, mode='constant', value=0.0):
     if mode == "constant":
         value = 0 if value is None else value
         out = constant_pad_nd_op(input, pad, value)
+    elif mode == "circular":
+        out = _circular_pad(input, pad)
     else:
-        if value != 0.0:
-            raise ValueError(f"Padding mode {mode} doesn\'t take in value argument.")
-        if mode == "circular":
-            out = _circular_pad(input, pad)
-        elif mode == "reflect":
-            out = _reflection_pad(input, pad)
-        elif mode == "replicate":
-            out = _replication_pad(input, pad)
+        if len(pad) == 2:
+            if mode == "reflect":
+                out = reflection_pad_1d_op(input, pad)
+            elif mode == "replicate":
+                out = replication_pad_1d_op(input, pad)
+            else:
+                raise ValueError(f"Pad filling mode must be 'constant' 'circular' 'reflect' or 'replicate'.")
+        elif len(pad) == 4:
+            if mode == "reflect":
+                out = reflection_pad_2d_op(input, pad)
+            elif mode == "replicate":
+                out = replication_pad_2d_op(input, pad)
+            else:
+                raise ValueError(f"Pad filling mode must be 'constant' 'circular' 'reflect' or 'replicate'.")
         else:
-            raise ValueError(f"Pad filling mode must be 'constant' 'circular' 'reflect' or 'replicate'.")
+            if mode == "reflect":
+                out = reflection_pad_3d_op(input, pad)
+            elif mode == "replicate":
+                out = replication_pad_3d_op(input, pad)
+            else:
+                raise ValueError(f"Pad filling mode must be 'constant' 'circular' 'reflect' or 'replicate'.")
     return out
 
 
@@ -3790,7 +3749,7 @@ def pad(input_x, padding, mode='constant', value=None):
 
     Examples:
         >>> import mindspore as ms
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> import numpy as np
         >>> x = ms.Tensor(np.arange(1 * 2 * 2 * 2).reshape((1, 2, 2, 2)), dtype=ms.float64)
         >>> output = ops.pad(x, [1, 0, 0, 1], mode='constant', value=6.0)
@@ -5267,7 +5226,7 @@ def hinge_embedding_loss(inputs, targets, margin=1.0, reduction='mean'):
     Examples:
         >>> import numpy as np
         >>> import mindspore.common.dtype as mstype
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> from mindspore import Tensor
         >>> arr1 = np.array([0.9, -1.2, 2, 0.8, 3.9, 2, 1, 0, -1]).reshape((3, 3))
         >>> arr2 = np.array([1, 1, -1, 1, -1, 1, -1, 1, 1]).reshape((3, 3))
@@ -6102,23 +6061,18 @@ def adaptive_avg_pool1d(input, output_size):
 
 
 def layer_norm(input, normalized_shape, weight=None, bias=None, eps=1e-5):
-    r"""Applies the Layer Normalization on the mini-batch input.
+    r"""Applies the Layer Normalization to the input tensor.
 
-    Layer normalization is widely used in recurrent neural networks. Apply normalization to the mini-batch
-    input of a single training case. LayerNorm is described in the paper
+    This operator will normalize the input tensor on given axis. LayerNorm is described in the paper
     `Layer Normalization <https://arxiv.org/abs/1607.06450>`_.
 
-    Unlike batch normalization, layer normalization performs the exact same calculations at training and
-    test time. Applies to all channels and pixels, even batch_size=1. The formula is as follows:
-
     .. math::
-        y = \frac{x - \mathrm{E}[x]}{\sqrt{\mathrm{Var}[x] + \epsilon}} * \gamma + \beta
+        y = \frac{x - mean}{\sqrt{variance + \epsilon}} * \gamma + \beta
 
-    where :math:`\gamma` is the weight value learned through training, :math:`\beta` is the bias value
-    learned through training.
+    where :math:`\gamma` is weight, :math:`\beta` is bias, :math:`\epsilon` is eps.
 
     Args:
-        input (Tensor): The shape of input is `(N, *)`, where `*` represents any additional dimension.
+        input (Tensor): Tensor of shape :math:`(N, \ldots)`. The input of LayerNorm.
         normalized_shape (Union(int, tuple[int], list[int])): The normalized shape of `input` for LayerNorm.
           `normalized_shape` equal to `input_shape[begin_norm_axis:]`, where `begin_norm_axis` represents the axis
           where normalization begins.
@@ -6130,7 +6084,7 @@ def layer_norm(input, normalized_shape, weight=None, bias=None, eps=1e-5):
           Default: ``1e-5`` .
 
     Returns:
-        Tensor. The normalized tensor, has the same type and shape as the `input`.
+        - **output** (Tensor) - The normalized input, has the same type and shape as the `input`.
 
     Raises:
         TypeError: If `input` is not a Tensor.
@@ -6158,6 +6112,7 @@ def layer_norm(input, normalized_shape, weight=None, bias=None, eps=1e-5):
         weight = ops.ones(normalized_shape, dtype=input.dtype)
     if bias is None:
         bias = ops.zeros(normalized_shape, dtype=input.dtype)
+    layer_norm_ext_op = LayerNormExt()
     return layer_norm_ext_op(input, normalized_shape, weight, bias, eps)[0]
 
 
@@ -6178,7 +6133,7 @@ def group_norm(input, num_groups, weight=None, bias=None, eps=1e-5):
     where :math:`\gamma` is `weight`, :math:`\beta` is `bias`, :math:`\epsilon` is `eps`.
 
     Args:
-        input (Tensor): The input feature with shape :math:`(N, C, *)` where :math:`*` means, any number of
+        input (Tensor) : The input feature with shape :math:`(N, C, *)` where :math:`*` means, any number of
             additional dimensions.
         num_groups (int): The number of groups to be divided along the channel dimension.
         weight (Tensor, optional): The shape :math:`(C,)`, Default: ``None``, has the same data type with `input`.
@@ -6200,9 +6155,9 @@ def group_norm(input, num_groups, weight=None, bias=None, eps=1e-5):
     Examples:
         >>> import mindspore as ms
         >>> import numpy as np
-        >>> from mindspore import ops
+        >>> from mindspore.ops import group_norm
         >>> x = ms.Tensor(np.ones([1, 2, 4, 4], np.float32))
-        >>> output = ops.group_norm(x, 2)
+        >>> output = group_norm(x, 2)
         >>> print(output)
         [[[[0. 0. 0. 0.]
            [0. 0. 0. 0.]
@@ -6213,78 +6168,9 @@ def group_norm(input, num_groups, weight=None, bias=None, eps=1e-5):
            [0. 0. 0. 0.]
            [0. 0. 0. 0.]]]]
     """
-    if weight is None:
-        weight = ops.ones([input.shape[1]], dtype=input.dtype)
-    if bias is None:
-        bias = ops.zeros([input.shape[1]], dtype=input.dtype)
+    group_norm_op = GroupNorm()
     return group_norm_op(input, num_groups, weight, bias, eps)[0]
 
-
-def batch_norm_ext(input, running_mean, running_var, weight=None, bias=None, training=False, momentum=0.1, eps=1e-5):
-    r"""
-    Batch Normalization for input data and updated parameters.
-
-    Batch Normalization is widely used in convolutional neural networks. This operation
-    applies Batch Normalization over inputs to avoid internal covariate shift as described
-    in the paper `Batch Normalization: Accelerating Deep Network Training by Reducing Internal
-    Covariate Shift <https://arxiv.org/abs/1502.03167>`_. It rescales and recenters the
-    features using a mini-batch of data and the learned parameters can be described
-    in the following formula,
-
-    .. math::
-
-        y = \frac{x - mean}{\sqrt{variance + \epsilon}} * \gamma + \beta
-
-    where :math:`\gamma` is `weight`, :math:`\beta` is `bias`, :math:`\epsilon` is `eps`, :math:`mean` is the
-    mean of :math:`x`, :math:`variance` is the variance of :math:`x`.
-
-    Args:
-        input (Tensor): Tensor of shape :math:`(N, C, *)`, with bfloat16, float16 or float32 data type.
-            For Atlas training products, the shape must be 2-4 dimensions currently.
-        running_mean (Tensor): The shape :math:`(C,)`, with bfloat, float16 or float32 data type.
-        running_var (Tensor): The shape :math:`(C,)`, with bfloat, float16 or float32 data type.
-        weight (Tensor, optional): The shape :math:`(C,)`, with bfloat, float16 or float32 data type, Default: ``None``.
-            Initialized to ``1`` when `weight` is None.
-        bias (Tensor, optional): The shape :math:`(C,)`, with bfloat, float16 or float32 data type. Default: ``None``.
-            Initialized to ``0`` when `weight` is None.
-        training (bool, optional): If `training` is `True`, `mean` and `variance` are computed during training.
-            If `training` is `False`, they're loaded from checkpoint during inference. Default: ``False`` .
-        momentum (float, optional): The hyper parameter to compute moving average for `running_mean` and `running_var`
-            (e.g. :math:`new\_running\_mean = (1 - momentum) * running\_mean + momentum * current\_mean`).
-            Default: ``0.1`` .
-        eps (float, optional): A small value added for numerical stability. Default: ``1e-5``.
-
-    Returns:
-        Tensor, has the same type and shape as `input`. The shape is :math:`(N, C, *)`.
-
-    Raises:
-        TypeError: If `training` is not a bool.
-        TypeError: If dtype of `eps` or `momentum` is not float.
-        TypeError: If `input`, `weight`, `bias`, `running_mean` or `running_var` is not a Tensor.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import mindspore
-        >>> from mindspore import Tensor, ops
-        >>> input_x = Tensor([[1.0, 2.0], [3.0, 4.0]], mindspore.float32)
-        >>> running_mean = Tensor([0.5, 1.5], mindspore.float32)
-        >>> running_var = Tensor([0.1, 0.2], mindspore.float32)
-        >>> weight = Tensor([2.0, 2.0], mindspore.float32)
-        >>> bias = Tensor([-1.0, -1.0], mindspore.float32)
-        >>> output = ops.function.nn_func.batch_norm_ext(input_x, running_mean, running_var, weight, bias)
-        >>> print(output)
-        [[ 2.1621194  1.2360122]
-         [14.810596  10.180061 ]]
-    """
-    if weight is None:
-        weight = ops.ones([input.shape[1]], dtype=input.dtype)
-    if bias is None:
-        bias = ops.zeros([input.shape[1]], dtype=input.dtype)
-    output = batch_norm_ext_op(input, weight, bias, running_mean, running_var, training, momentum, eps)
-    return output[0]
-
 def batch_norm(input_x, running_mean, running_var, weight, bias, training=False, momentum=0.1, eps=1e-5):
     r"""
     Batch Normalization for input data and updated parameters.
@@ -6422,7 +6308,6 @@ def binary_cross_entropy(logits, labels, weight=None, reduction='mean'):
     Args:
         logits (Tensor): The predictive value whose data type must be float16 or float32.
         labels (Tensor): The target value which has the same shape and data type as `logits`.
-            And the data type is float16 or float32.
         weight (Tensor, optional): A rescaling weight applied to the loss of each batch element.
             Its shape must be able to broadcast to that of `logits` and `labels`.
             And it must have the same shape and data type as `logits`. Default: ``None`` . If set to ``None`` ,
@@ -7045,6 +6930,8 @@ def gelu(input, approximate='none'):
     .. math::
         GELU(x_i) = 0.5 * x_i * (1 + \tanh(\sqrt(2 / \pi) * (x_i + 0.044715 * x_i^3)))
 
+    For the related GELU graph, refer to `GELU <https://en.wikipedia.org/wiki/Activation_function#/media/File:Activation_gelu.png>`_ .
+
     GELU Activation Function Graph:
 
     .. image:: ../images/GELU.png
@@ -7072,7 +6959,7 @@ def gelu(input, approximate='none'):
         >>> x = Tensor([1.0, 2.0, 3.0], mindspore.float32)
         >>> result = ops.gelu(x)
         >>> print(result)
-        [0.8413447 1.9544997 2.9959505]
+        [0.841192 1.9545976 2.9963627]
     """
     if approximate not in ['none', 'tanh']:
         raise ValueError("For ops.gelu, approximate value should be either 'none' or 'tanh'.")
@@ -7185,7 +7072,7 @@ def lp_pool1d(x, norm_type, kernel_size, stride=None, ceil_mode=False):
 
     Examples:
         >>> import mindspore as ms
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> from mindspore import Tensor
         >>> import numpy as np
         >>> x = Tensor(np.arange(2 * 3 * 4).reshape((2, 3, 4)), dtype=ms.float32)
@@ -7270,7 +7157,7 @@ def lp_pool2d(x, norm_type, kernel_size, stride=None, ceil_mode=False):
 
     Examples:
         >>> import mindspore as ms
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> from mindspore import Tensor
         >>> import numpy as np
         >>> x = Tensor(np.arange(2 * 3 * 4 * 5).reshape((2, 3, 4, 5)), dtype=ms.float32)
@@ -7396,7 +7283,7 @@ def msort(input):
 
     Examples:
         >>> import mindspore as ms
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> import numpy as np
         >>> input = ms.Tensor(np.array([[8, 2, 1], [5, 9, 3], [4, 6, 7]]), ms.float16)
         >>> output = ops.msort(input)
@@ -8128,6 +8015,7 @@ __all__ = [
     'softmin',
     'pdist',
     'pad',
+    'pad_ext',
     'prelu',
     'mirror_pad',
     'cross_entropy',
@@ -8170,6 +8058,6 @@ __all__ = [
     'channel_shuffle',
     'hardsigmoid',
     'group_norm',
-    'rms_norm',
+    'dropout_ext',
 ]
 __all__.sort()