mindspore 2.3.0__cp310-cp310-win_amd64.whl → 2.4.0__cp310-cp310-win_amd64.whl

mindspore/ops/auto_generate/gen_ops_def.py

@@ -54,6 +54,39 @@ def abs(input):
     return abs_op(input)
 
 
+def acos_ext(input):
+    r"""
+    Computes arccosine of input tensors element-wise.
+
+    .. math::
+
+        out_i = \cos^{-1}(input_i)
+
+    Args:
+        input (Tensor): The shape of tensor is
+            :math:`(N,*)`, where :math:`*` means any number of additional dimensions.
+
+    Returns:
+        Tensor, has the same shape as `input`. The dtype of output is float32 when dtype of `input` is in [bool, int8, uint8, int16, int32, int64]. Otherwise output has the same dtype as `input`.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([0.74, 0.04, 0.30, 0.56]), mindspore.float32)
+        >>> output = ops.acos_ext(input)
+        >>> print(output)
+        [0.7377037  1.5307857 1.2661037 0.9764114]
+    """
+    return acos_ext_op(input)
+
+
 def acos(input):
     r"""
     Computes arccosine of input tensors element-wise.
@@ -88,6 +121,42 @@ def acos(input):
     return acos_op(input)
 
 
+def acosh_ext(input):
+    r"""
+    Computes inverse hyperbolic cosine of the inputs element-wise.
+
+    .. math::
+
+        out_i = \cosh^{-1}(input_i)
+
+    .. note::
+        Given an input tensor input, the function computes inverse hyperbolic cosine of every element.
+        Input range is [1, inf].
+
+    Args:
+        input (Tensor): The input tensor of inverse hyperbolic cosine function.
+
+    Returns:
+        Tensor, has the same shape as `input`. The dtype of output is float32 when dtype of `input` is in [bool, int8, uint8, int16, int32, int64]. Otherwise output has the same dtype as `input`.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([1.0, 1.5, 3.0, 100.0]), mindspore.float32)
+        >>> output = ops.acosh_ext(input)
+        >>> print(output)
+        [0.        0.9624236 1.7627472 5.298292 ]
+    """
+    return acosh_ext_op(input)
+
+
 def acosh(input):
     r"""
     Computes inverse hyperbolic cosine of the inputs element-wise.
@@ -96,7 +165,7 @@ def acosh(input):
 
         out_i = \cosh^{-1}(input_i)
 
-    .. warning::
+    .. note::
         Given an input tensor input, the function computes inverse hyperbolic cosine of every element.
         Input range is [1, inf].
 
@@ -124,6 +193,52 @@ def acosh(input):
     return acosh_op(input)
 
 
+def adaptive_avg_pool1d(input, output_size):
+    r"""
+    Performs 1D adaptive average pooling on a multi-plane input signal.
+    That is, for any input size, the size of the specified output is L.
+    The number of output features is equal to the number of input features.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): The input of adaptive_avg_pool1d, which is a 2D or 3D tensor,
+            with float16 or float32 data type.
+        output_size (int): The target output feature size. `output_size` is an integer.
+
+    Returns:
+        Tensor, with the same type as the `input`.
+
+        Shape of the output is `input_shape[:len(input_shape) - 1] + [output_size]`.
+
+    Raises:
+        ValueError: If `output_size` is not integer.
+        TypeError: If `input` is not a Tensor.
+        TypeError: If dtype of `input` is not float16, float32.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, mint
+        >>> input = Tensor([[2,3],[3,4]],dtype=mindspore.float16)
+        >>> output = mint.nn.functional.adaptive_avg_pool1d(input, 3)
+        >>> print(output)
+        [[2.  2.5 3. ]
+         [3.  3.5 4. ]]
+    """
+    return adaptive_avg_pool1d_op(input, output_size)
+
+
+def adaptive_avg_pool2d_grad_ext(grad_output, x):
+    r"""
+    
+    """
+    return adaptive_avg_pool2d_grad_ext_op(grad_output, x)
+
+
 def add_ext(input, other, alpha=1):
     r"""
     Adds scaled other value to input Tensor.
@@ -141,12 +256,12 @@ def add_ext(input, other, alpha=1):
     Args:
         input (Union[Tensor, number.Number, bool]): The first input is a number.Number or
             a bool or a tensor whose data type is
-            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         other (Union[Tensor, number.Number, bool]): The second input, is a number.Number or
             a bool or a tensor whose data type is
-            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         alpha (number.Number): A scaling factor applied to `other`, default 1.
 
     Returns:
@@ -180,6 +295,20 @@ def add_ext(input, other, alpha=1):
     return add_ext_op(input, other, alpha)
 
 
+def add_layer_norm_grad(dy, x1, x2, rstd, mean, gamma, dsumOptional):
+    r"""
+    
+    """
+    return add_layer_norm_grad_op(dy, x1, x2, rstd, mean, gamma, dsumOptional)
+
+
+def add_layernorm_v2(x1, x2, gamma, beta, epsilon=1e-5, additionalOut=False):
+    r"""
+    
+    """
+    return add_layernorm_v2_op(x1, x2, gamma, beta, epsilon, additionalOut)
+
+
 def add(input, other):
     r"""
     Adds other value to input Tensor.
@@ -200,12 +329,12 @@ def add(input, other):
     Args:
         input (Union[Tensor, number.Number, bool]): The first input is a number.Number or
             a bool or a tensor whose data type is
-            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         other (Union[Tensor, number.Number, bool]): The second input, is a number.Number or
             a bool or a tensor whose data type is
-            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
 
     Returns:
         Tensor with a shape that is the same as the broadcasted shape of the input `input` and `other`,
@@ -353,6 +482,72 @@ def argmax_ext(input, dim=None, keepdim=False):
     return argmax_ext_op(input, dim, keepdim)
 
 
+def argmin_ext(input, dim=None, keepdim=False):
+    r"""
+    Return the indices of the minimum values of a tensor across a dimension.
+
+    Args:
+        input (Tensor): Input tensor.
+        dim (Union[int, None], optional): Specify the axis for calculation. If `dim` is ``None`` , the indices of the minimum
+            value within the flattened input will be returned. Default: ``None`` .
+        keepdim (bool, optional): Whether the output tensor retains the specified
+            dimension. Ignored if `dim` is None. Default: ``False`` .
+
+    Returns:
+        Tensor, indices of the minimum values of the input tensor across a dimension.
+
+    Raises:
+        TypeError: If `keepdim` is not bool.
+        ValueError: If `dim` is out of range.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor
+        >>> from mindspore import mint
+        >>> x = Tensor(np.array([[1, 20, 5], [67, 8, 9], [130, 24, 15]]).astype(np.float32))
+        >>> output = mint.argmin(x, dim=-1)
+        >>> print(output)
+        [0 1 2]
+    """
+    return argmin_ext_op(input, dim, keepdim)
+
+
+def asin_ext(input):
+    r"""
+    Computes arcsine of input tensors element-wise.
+
+    .. math::
+
+        out_i = \sin^{-1}(input_i)
+
+    Args:
+        input (Tensor): The shape of tensor is
+            :math:`(N,*)`, where :math:`*` means any number of additional dimensions.
+
+    Returns:
+        Tensor, has the same shape as `input`. The dtype of output is float32 when dtype of `input` is in [bool, int8, uint8, int16, int32, int64]. Otherwise output has the same dtype as `input`.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([0.74, 0.04, 0.30, 0.56]), mindspore.float32)
+        >>> output = ops.asin_ext(input)
+        >>> print(output)
+        [0.8330927  0.04001068  0.30469266  0.59438497 ]
+    """
+    return asin_ext_op(input)
+
+
 def asin(input):
     r"""
     Computes arcsine of input tensors element-wise.
@@ -387,6 +582,38 @@ def asin(input):
     return asin_op(input)
 
 
+def asinh_ext(input):
+    r"""
+    Computes inverse hyperbolic sine of the input element-wise.
+
+    .. math::
+
+        out_i = \sinh^{-1}(input_i)
+
+    Args:
+        input (Tensor): The input tensor of inverse hyperbolic sine function.
+
+    Returns:
+        Tensor, has the same shape as `input`. The dtype of output is float32 when dtype of `input` is in [bool, int8, uint8, int16, int32, int64]. Otherwise output has the same dtype as `input`.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([-5.0, 1.5, 3.0, 100.0]), mindspore.float32)
+        >>> output = ops.asinh_ext(input)
+        >>> print(output)
+        [-2.3124385  1.1947632  1.8184465  5.298342 ]
+    """
+    return asinh_ext_op(input)
+
+
 def asinh(input):
     r"""
     Computes inverse hyperbolic sine of the input element-wise.
@@ -522,7 +749,9 @@ def atan2_ext(input, other):
             its shape is able to broadcast with `input`.
 
     Returns:
-        Tensor, the shape is the same as the one after broadcasting, and the data type is same as `input`.
+        Tensor, the shape is the same as the one after broadcasting.
+        The dtype of output is float32 when dtype of `input` is in
+        [bool, int8, uint8, int16, int32, int64]. Otherwise output has the same dtype as `input`.
 
     Raises:
         TypeError: If `input` or `other` is not a Tensor or scalar.
@@ -586,6 +815,39 @@ def atan2(input, other):
     return atan2_op(input, other)
 
 
+def atan_ext(input):
+    r"""
+    Computes the trigonometric inverse tangent of the input element-wise.
+
+    .. math::
+
+        out_i = \tan^{-1}(input_i)
+
+    Args:
+        input (Tensor): The shape of tensor is
+            :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
+
+    Returns:
+        Tensor, has the same shape as `input`. The dtype of output is float32 when dtype of `input` is in [bool, int8, uint8, int16, int32, int64]. Otherwise output has the same dtype as `input`.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([1.0, 0.0]), mindspore.float32)
+        >>> output = ops.atan_ext(input)
+        >>> print(output)
+        [0.7853982 0.       ]
+    """
+    return atan_ext_op(input)
+
+
 def atan(input):
     r"""
     Computes the trigonometric inverse tangent of the input element-wise.
@@ -635,14 +897,12 @@ def atanh(input):
     Args:
         input (Tensor): The shape of tensor is
             :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
-            The data type should be one of the following types: float16, float32.
 
     Returns:
-        A Tensor, has the same type as the input.
+        Tensor, has the same shape as `input`. The dtype of output is float32 when dtype of `input` is in [bool, int8, uint8, int16, int32, int64]. Otherwise output has the same dtype as `input`.
 
     Raises:
         TypeError: If `input` is not a Tensor.
-        TypeError: If dtype of `input` is not float16 or float32.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -659,6 +919,50 @@ def atanh(input):
     return atanh_op(input)
 
 
+def baddbmm(input, batch1, batch2, beta, alpha):
+    r"""
+    The result is the sum of the input and a batch matrix-matrix product of matrices in batch1 and batch2.
+    The formula is defined as follows:
+
+    .. math::
+        \text{out}_{i} = \beta \text{input}_{i} + \alpha (\text{batch1}_{i} \mathbin{@} \text{batch2}_{i})
+
+    Args:
+        input (Tensor): The input Tensor. When batch1 is a :math:`(C, W, T)` Tensor and batch2 is a
+            :math:`(C, T, H)` Tensor, input must be broadcastable with :math:`(C, W, H)` Tensor.
+        batch1 (Tensor): :math:`batch1` in the above formula. Must be 3-D Tensor, dtype is same as input.
+        batch2 (Tensor): :math:`batch2` in the above formula. Must be 3-D Tensor, dtype is same as input.
+        
+    Keyword Args:
+        beta (Union[float, int], optional): multiplier for input. Default: ``1`` .
+        alpha (Union[float, int], optional): multiplier for :math:`batch1 @ batch2`. Default: ``1`` .
+
+    Returns:
+        Tensor, has the same dtype as input, shape will be :math:`(C, W, H)`.
+
+    Raises:
+        TypeError: If the type of `input`, `batch1`, `batch2` is not Tensor.
+        TypeError: If the types of `input`, `batch1`, `batch2` are different.
+        ValueError: If `batch1` and `batch2` are not 3-D tensors.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.ones([1, 3, 3]).astype(np.float32))
+        >>> batch1 = Tensor(np.ones([1, 3, 4]).astype(np.float32))
+        >>> batch2 = Tensor(np.ones([1, 4, 3]).astype(np.float32))
+        >>> output =  ops.baddbmm_ext(input, batch1, batch2)
+        >>> print(output)
+        [[[5. 5. 5.]
+        [5. 5. 5.]
+        [5. 5. 5.]]]
+    """
+    return baddbmm_op(input, batch1, batch2, beta, alpha)
+
+
 def bmm_ext(input, mat2):
     r"""
     Performs batch matrix-matrix multiplication of two three-dimensional tensors.
@@ -778,7 +1082,7 @@ def broadcast_to(input, shape):
 
 cast_op=Cast()
 
-def cast(input_x, dtype):
+def cast(input, dtype):
     r"""
     Returns a tensor with the new specified data type.
 
@@ -786,17 +1090,16 @@ def cast(input_x, dtype):
         When converting complex numbers to boolean type, the imaginary part of the complex number is not
         taken into account. As long as the real part is non-zero, it returns True; otherwise, it returns False.
 
-    Inputs:
-        - **input_x** (Union[Tensor, Number]) - The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
-          The tensor to be cast.
-        - **type** (dtype.Number) - The valid data type of the output tensor. Only constant value is allowed.
+    Args:
+        input (Union[Tensor, Number]): The shape of tensor is :math:`(x_1, x_2, ..., x_R)`. The tensor to be cast.
+        dtype (dtype.Number): The valid data type of the output tensor. Only constant value is allowed.
 
-    Outputs:
-        Tensor, the shape of tensor is the same as `input_x`, :math:`(x_1, x_2, ..., x_R)`.
+    Returns:
+        Tensor, the shape of tensor is the same as `input`, :math:`(x_1, x_2, ..., x_R)`.
 
     Raises:
-        TypeError: If `input_x` is neither Tensor nor Number.
-        TypeError: If `type` is not a Number.
+        TypeError: If `input` is neither Tensor nor Number.
+        TypeError: If `dtype` is not a Number.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -806,16 +1109,15 @@ def cast(input_x, dtype):
         >>> import numpy as np
         >>> from mindspore import Tensor, ops
         >>> input_np = np.random.randn(2, 3, 4, 5).astype(np.float32)
-        >>> input_x = Tensor(input_np)
-        >>> type_dst = mindspore.int32
-        >>> cast = ops.Cast()
-        >>> output = cast(input_x, type_dst)
+        >>> input = Tensor(input_np)
+        >>> dtype = mindspore.int32
+        >>> output = ops.cast(input, dtype)
         >>> print(output.dtype)
         Int32
         >>> print(output.shape)
         (2, 3, 4, 5)
     """
-    return cast_op(input_x, dtype)
+    return cast_op(input, dtype)
 
 
 def ceil(input):
@@ -1198,6 +1500,13 @@ def contiguous(input):
     return contiguous_op(input)
 
 
+def copy_ext(variable, value):
+    r"""
+    
+    """
+    return copy_ext_op(variable, value)
+
+
 def copy(input):
     r"""
     
@@ -1313,16 +1622,19 @@ def cosh(input):
         out_i = \cosh(input_i)
 
     Args:
-        input (Tensor): The input tensor of hyperbolic cosine function, its data type
-            must be float16, float32, float64, complex64 or complex128.
+        input (Tensor): The input tensor of hyperbolic cosine function.
+            Supported dtypes: 
+
+            - GPU/CPU: float16, float32, float64, complex64 or complex128.
+            - Ascend: bool, int8, uint8, int16, int32, int64, float16, float32, float64, complex64, complex128 or bfloat16.
 
     Returns:
         Tensor, has the same shape as `input`.
 
-    Raises:
-        TypeError: If the dtype of `input` is not one of the following types:
-                       float16, float32, float64, complex64, complex128.
-        TypeError: If `input` is not a Tensor.
+    :raise TypeError: If `input` is not a Tensor.
+    :raise TypeError:
+        * CPU/GPU: If dtype of `input` is not float16, float32 or float64, complex64, complex128.
+        * Ascend: If dtype of `input` is not bool, int8, uint8, int16, int32, int64, float16, float32, float64, complex64, complex128 or bfloat16.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -1367,14 +1679,17 @@ def cummax(input, axis):
         TypeError: If `axis` is not an int.
         ValueError: If `axis` is out the range of `[-input.ndim, input.ndim - 1]`.
 
+    .. note::
+        O2 mode is not supported in Ascend.
+
     Supported Platforms:
-        ``GPU`` ``CPU``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> import mindspore
         >>> import numpy as np
         >>> from mindspore import Tensor
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> x = Tensor(np.array([[3, 4, 6, 10], [1, 6, 7, 9], [4, 3, 8, 7], [1, 3, 7, 9]]).astype(np.float32))
         >>> output = ops.cummax(x, axis=0)
         >>> print(output[0])
@@ -1388,11 +1703,53 @@ def cummax(input, axis):
          [2 1 2 0]
          [2 1 2 0]]
     """
-    cummax_op = _get_cache_prim(Cummax)(axis)
-    return cummax_op(input)
+    return cummax_impl(input, axis)
 
 
-def cumsum_ext(input, dim, dtype=None):
+def cummin_ext(input, dim):
+    r"""
+    Returns a tuple (values, indices) where `values` is the cumulative minimum value of input Tensor `input`
+    along the dimension `dim`, and `indices` is the index location of each minimum value.
+
+    .. math::
+        \begin{array}{ll} \\
+            y_{i} = \min(x_{1}, x_{2}, ... , x_{i})
+        \end{array}
+
+    Args:
+        input (Tensor): The input Tensor, The dimension must be greater than 0.
+        dim (int): Operation dimension. The value of `dim` must be in the range `[-input.ndim, input.ndim - 1]`.
+
+    Returns:
+        tuple [Tensor], tuple of 2 Tensors, containing the cumulative minimum of elements and the index.
+        The shape of each output tensor is the same as that of input `input`.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `input` is a Tensor, but the type is complex or bool.
+        TypeError: If `dim` is not an int.
+        ValueError: If `dim` is out the range of `[-input.ndim, input.ndim - 1]`.
+
+    .. note::
+        O2 mode is not supported in Ascend.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> from mindspore import Tensor, ops
+        >>> import mindspore
+        >>> a = Tensor([-0.2284, -0.6628,  0.0975,  0.2680, -1.3298, -0.4220], mindspore.float32)
+        >>> output = ops.cummin_ext(a, dim=0)
+        >>> print(output[0])
+        [-0.2284 -0.6628 -0.6628 -0.6628 -1.3298 -1.3298]
+        >>> print(output[1])
+        [0 1 1 1 4 4]
+    """
+    return cummin_ext_op(input, dim)
+
+
+def cumsum_ext(input, dim, dtype=None):
     r"""
     Computes the cumulative sum of input Tensor along `dim`.
 
@@ -1731,6 +2088,104 @@ def elu(input_x, alpha=1.0):
     return elu_op(input_x)
 
 
+def embedding_apply_ada_grad(var_handle, lr, grad, keys, global_step, embedding_dim, mask_zero=(0,), padding_key=(0,), padding_key_mask=(1,), completion_key=(0,), completion_key_mask=(1,), _embedding_dim=1, _max_key_num=1):
+    r"""
+    
+    """
+    return embedding_apply_ada_grad_op(var_handle, lr, grad, keys, global_step, embedding_dim, mask_zero, padding_key, padding_key_mask, completion_key, completion_key_mask, _embedding_dim, _max_key_num)
+
+
+def embedding_apply_adam(var_handle, beta1_power, beta2_power, lr, beta1, beta2, epsilon, grad, keys, global_step, embedding_dim, mask_zero=(0,), padding_key=(0,), padding_key_mask=(1,), completion_key=(0,), completion_key_mask=(1,), _embedding_dim=1, _max_key_num=1):
+    r"""
+    
+    """
+    return embedding_apply_adam_op(var_handle, beta1_power, beta2_power, lr, beta1, beta2, epsilon, grad, keys, global_step, embedding_dim, mask_zero, padding_key, padding_key_mask, completion_key, completion_key_mask, _embedding_dim, _max_key_num)
+
+
+def embedding_apply_adam_w(var_handle, beta1_power, beta2_power, lr, weight_decay, beta1, beta2, epsilon, grad, keys, max_grad_norm, global_step, embedding_dim, ams_grad=(0,), mask_zero=(0,), padding_key=(0,), padding_key_mask=(1,), completion_key=(0,), completion_key_mask=(1,), _embedding_dim=1, _max_key_num=1):
+    r"""
+    
+    """
+    return embedding_apply_adam_w_op(var_handle, beta1_power, beta2_power, lr, weight_decay, beta1, beta2, epsilon, grad, keys, max_grad_norm, global_step, embedding_dim, ams_grad, mask_zero, padding_key, padding_key_mask, completion_key, completion_key_mask, _embedding_dim, _max_key_num)
+
+
+def embedding_apply_ftrl(var_handle, lr, lr_power, lambda1, lambda2, grad, keys, global_step, embedding_dim, mask_zero=(0,), padding_key=(0,), padding_key_mask=(1,), completion_key=(0,), completion_key_mask=(1,), _embedding_dim=1, _max_key_num=1):
+    r"""
+    
+    """
+    return embedding_apply_ftrl_op(var_handle, lr, lr_power, lambda1, lambda2, grad, keys, global_step, embedding_dim, mask_zero, padding_key, padding_key_mask, completion_key, completion_key_mask, _embedding_dim, _max_key_num)
+
+
+def embedding_apply_rmsprop(var_handle, lr, rho, momentum, epsilon, grad, keys, global_step, embedding_dim, mask_zero=(0,), padding_key=(0,), padding_key_mask=(1,), completion_key=(0,), completion_key_mask=(1,), _embedding_dim=1, _max_key_num=1):
+    r"""
+    
+    """
+    return embedding_apply_rmsprop_op(var_handle, lr, rho, momentum, epsilon, grad, keys, global_step, embedding_dim, mask_zero, padding_key, padding_key_mask, completion_key, completion_key_mask, _embedding_dim, _max_key_num)
+
+
+def embedding_apply_sgd(var_handle, lr, grad, keys, global_step, embedding_dim, mask_zero=(0,), padding_key=(0,), padding_key_mask=(1,), completion_key=(0,), completion_key_mask=(1,), _embedding_dim=1, _max_key_num=1):
+    r"""
+    
+    """
+    return embedding_apply_sgd_op(var_handle, lr, grad, keys, global_step, embedding_dim, mask_zero, padding_key, padding_key_mask, completion_key, completion_key_mask, _embedding_dim, _max_key_num)
+
+
+def embedding_feature_mapping_export(file_path, table_name, global_step, values, embedding_dim, feature_id, offset_id):
+    r"""
+    
+    """
+    return embedding_feature_mapping_export_op(file_path, table_name, global_step, values, embedding_dim, feature_id, offset_id)
+
+
+def embedding_feature_mapping_file_size(file_path, table_name, global_step, embedding_dim, only_offset_flag=True):
+    r"""
+    
+    """
+    return embedding_feature_mapping_file_size_op(file_path, table_name, global_step, embedding_dim, only_offset_flag)
+
+
+def embedding_feature_mapping_find(table_name, feature_size, num=1):
+    r"""
+    
+    """
+    return embedding_feature_mapping_find_op(table_name, feature_size, num)
+
+
+def embedding_feature_mapping_import(file_path, teble_name, feature_size, global_step, embedding_dim, only_offset_flag=True, num=1):
+    r"""
+    
+    """
+    return embedding_feature_mapping_import_op(file_path, teble_name, feature_size, global_step, embedding_dim, only_offset_flag, num)
+
+
+def embedding_feature_mapping_insert(table_name, num, feature_id, offset_id):
+    r"""
+    
+    """
+    return embedding_feature_mapping_insert_op(table_name, num, feature_id, offset_id)
+
+
+def embedding_feature_mapping_table_size(table_name):
+    r"""
+    
+    """
+    return embedding_feature_mapping_table_size_op(table_name)
+
+
+def embedding_feature_mapping_v2(table_name, feature_id, table_total_size, table_actual_size):
+    r"""
+    
+    """
+    return embedding_feature_mapping_v2_op(table_name, feature_id, table_total_size, table_actual_size)
+
+
+def embedding_table_evict(var_handle, global_step, steps_to_live=0):
+    r"""
+    
+    """
+    return embedding_table_evict_op(var_handle, global_step, steps_to_live)
+
+
 def equal(input, other):
     r"""
     Computes the equivalence between two tensors element-wise.
@@ -1834,15 +2289,19 @@ def erfc(input):
         input (Tensor): The input tensor of the complementary error function, :math:`x` in the above formula. 
             Supported dtypes:
 
-            - Ascend: float16, float32.
+            - Ascend: float16, float32, float64, int64, bool, bfloat16.
             - GPU/CPU: float16, float32, float64.
 
     Returns:
-        Tensor, has the same shape and dtype as `input`.
+        Tensor.
+        The dtype of output is float32 when dtype of `input` is in
+        [bool, int64]. Otherwise output has the same dtype as the `input`.
 
-    Raises:
-        TypeError: If `input` is not a Tensor.
-        TypeError: If dtype of `input` is not float16, float32 or float64.
+    :raise TypeError: If `input` is not a Tensor.
+    :raise TypeError: If dtype of `input` is not the following:
+
+            * Ascend: float16, float32, float64, int64, bool, bfloat16.
+            * GPU/CPU: float16, float32, float64.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -1851,17 +2310,17 @@ def erfc(input):
         >>> import mindspore
         >>> import numpy as np
         >>> from mindspore import Tensor, ops
-        >>> x = Tensor(np.array([-1, 0, 1, 2, 3]), mindspore.float32)
-        >>> output = ops.erfc(x)
+        >>> input = Tensor(np.array([-1, 0, 1, 2, 3]), mindspore.float32)
+        >>> output = ops.erfc(input)
         >>> print(output)
-        [1.8427168e+00 1.0000000e+00 1.5728319e-01 4.6912432e-03 2.2351742e-05]
+        [1.8427008e+00 1.0000000e+00 1.5729921e-01 4.6777348e-03 2.2090497e-05]
     """
     return erfc_op(input)
 
 
 def erfinv(input):
     r"""
-    Returns the result of the inverse error function with `input`, which is defined in the range `(-1, 1)` as:
+    Returns the result of the inverse error function with `input`. It is defined in the range `(-1, 1)` as:
 
     .. math::
 
@@ -2119,7 +2578,7 @@ def fft2(input, s=None, dim=(-2, -1), norm=None):
         dim (tuple[int], optional): The dimension along which to take the one dimensional `fft2`.
             Default: ``(-2, -1)`` , which means transform the last two dimension of `input`.
         norm (str, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
-            Three modes are defined as,
+            Three modes are defined as, where :math: `n = prod(s)`
 
             - ``"backward"`` (no normalization).
             - ``"forward"`` (normalize by :math:`1/n`).
@@ -2138,6 +2597,7 @@ def fft2(input, s=None, dim=(-2, -1), norm=None):
         ValueError: If `dim` is not in the range of "[ `-input.ndim` , `input.ndim` )".
         ValueError: If `dim` has duplicate values.
         ValueError: If `s` is less than 1.
+        ValueError: If `s` and `dim` are given but have different shapes.
         ValueError: If `norm` is none of ``"backward"`` , ``"forward"`` or ``"ortho"`` .
 
     Supported Platforms:
@@ -2147,12 +2607,12 @@ def fft2(input, s=None, dim=(-2, -1), norm=None):
         >>> import mindspore
         >>> from mindspore import Tensor, ops
         >>> input = ops.ones((4, 4))
-        >>> ops.fft2(input, s=(4, 4), dim=(0, 1), norm="backward")
-        Tensor(shape=[4, 4], dtype=Complex64, value=
-        [[16+0j, 0+0j, 0+0j, 0+0j],
-         [0+0j, 0+0j, 0+0j, 0+0j],
-         [0+0j, 0+0j, 0+0j, 0+0j],
-         [0+0j, 0+0j, 0+0j, 0+0j]])
+        >>> out = ops.fft2(input, s=(4, 4), dim=(0, 1), norm="backward")
+        >>> print(out)
+        [[16.+0.j  0.+0.j  0.+0.j  0.+0.j]
+         [ 0.+0.j  0.+0.j  0.+0.j  0.+0.j]
+         [ 0.+0.j  0.+0.j  0.+0.j  0.+0.j]
+         [ 0.+0.j  0.+0.j  0.+0.j  0.+0.j]]
     """
     return fft2_op(input, s, dim, norm)
 
@@ -2205,12 +2665,51 @@ def fft(input, n=None, dim=-1, norm=None):
         >>> import mindspore
         >>> from mindspore import Tensor, ops
         >>> input = Tensor([ 1.6243454, -0.6117564, -0.5281718, -1.0729686])
-        >>> ops.fft(input)
-        Tensor(shape=[4], dtype=Complex64, value= [-0.588551+0j, 2.15252-0.461212j, 2.7809+0j, 2.15252+0.461212j])
+        >>> out = ops.fft(input, n=4, dim=-1, norm="backward")
+        >>> print(out)
+        [-0.5885514+0.j          2.1525173-0.46121222j  2.7808986+0.j
+          2.1525173+0.46121222j]
     """
     return fft_op(input, n, dim, norm)
 
 
+def fftfreq(n, d=1.0, dtype=None):
+    r"""
+    Computes the discrete Fourier Transform sample frequencies for a signal of size `n`.
+    For instance, Given a length `n` and a sample spacing `d` , the returned result `f` is:
+
+    .. math::
+        f = [0, 1, ..., (n - 1) // 2, -(n // 2), ..., -1] / (d * n)
+
+    Note:
+        - `fftfreq` is currently only used in `mindscience` scientific computing scenarios and
+          dose not support other usage scenarios.
+        - `fftfreq` is not supported on Windows platform yet.
+
+    Args:
+        n (int): Window length.
+        d (float, optional): Sample spacing (inverse of the sampling rate). Default: ``1.0`` .
+        dtype (mindspore.dtype, optional): The dtype of the returned frequencies. Default: ``None`` represents float32.
+
+    Returns:
+        Tensor, Array of length ``n`` containing the sample frequencies.
+
+    Raises:
+        ValueError: If `n` is less than 1.
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import ops
+        >>> out = ops.fftfreq(n=4, d=1.0)
+        >>> print(out)
+        [ 0.    0.25 -0.5  -0.25]
+    """
+    return fftfreq_op(n, d, dtype)
+
+
 def fftn(input, s=None, dim=None, norm=None):
     r"""
     Computes the N dimensional discrete Fourier transform of `input`.
@@ -2232,7 +2731,7 @@ def fftn(input, s=None, dim=None, norm=None):
         dim (tuple[int], optional): The dimension along which to take the one dimensional `fftn`.
             Default: ``None`` , which means transform the all dimension of `input`, or the last `len(s)` dimensions if s is given.
         norm (str, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
-            Three modes are defined as,
+            Three modes are defined as, where :math: `n = prod(s)`
 
             - ``"backward"`` (no normalization).
             - ``"forward"`` (normalize by :math:`1/n`).
@@ -2261,12 +2760,12 @@ def fftn(input, s=None, dim=None, norm=None):
         >>> import mindspore
         >>> from mindspore import Tensor, ops
         >>> input = ops.ones((2, 2, 2))
-        >>> ops.fftn(input, s=(2, 2, 2), dim=(0, 1, 2), norm="backward")
-        Tensor(shape=[2, 2, 2], dtype=Complex64, value=
-        [[[8+0j, 0+0j],
-         [0+0j, 0+0j]],
-         [[0+0j, 0+0j],
-         [0+0j, 0+0j]]])
+        >>> out = ops.fftn(input, s=(2, 2, 2), dim=(0, 1, 2), norm="backward")
+        >>> print(out)
+        [[[8.+0.j 0.+0.j]
+          [0.+0.j 0.+0.j]]
+          [[0.+0.j 0.+0.j]
+          [0.+0.j 0.+0.j]]]
     """
     return fftn_op(input, s, dim, norm)
 
@@ -2313,8 +2812,6 @@ def flatten_ext(input, start_dim=0, end_dim=-1):
 
     Args:
         input (Tensor): The input Tensor.
-
-    Keyword Args:
         start_dim (int, optional): The first dimension to flatten. Default: ``0`` .
         end_dim (int, optional): The last dimension to flatten. Default: ``-1`` .
 
@@ -2334,9 +2831,9 @@ def flatten_ext(input, start_dim=0, end_dim=-1):
     Examples:
         >>> import mindspore
         >>> import numpy as np
-        >>> from mindspore import Tensor, mint
+        >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.ones(shape=[1, 2, 3, 4]), mindspore.float32)
-        >>> output = mint.flatten(input_x)
+        >>> output = ops.auto_generate.flatten_ext(input_x)
         >>> print(output.shape)
         (24,)
     """
@@ -2569,7 +3066,7 @@ def gather(input_params, input_indices, axis, batch_dims=0):
            On CPU and GPU, an error is raised if an out of bound indice is found. On Ascend, the results may be
            undefined.
         2. The data type of input_params cannot be
-           `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_ on Ascend
+           `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ on Ascend
            platform currently.
 
     Args:
@@ -2758,11 +3255,11 @@ def greater(input, other):
 
     Args:
         input (Union[Tensor, Number]): The first input is a Number or a tensor whose data type is
-            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_ .
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ .
         other (Union[Tensor, Number]): The second input, which is a Number or a tensor whose data type is
-            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
 
     Returns:
         Tensor, the shape is the same as the one after broadcasting, and the data type is bool.
@@ -2783,42 +3280,14 @@ def greater(input, other):
     return greater_op(input, other)
 
 
-def deepcopy(input_x):
-    r"""
-    Returns a deepcopy of input tensor.
-
-    Args:
-        input_x (Tensor): The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
-
-    Returns:
-        Tensor, a deepcopy of `input_x`.
-
-    Raises:
-        TypeError: If `input_x` is not a Tensor.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> from mindspore import Tensor, ops
-        >>> input = Tensor([[0, 1], [2, 1]], dtype=mindspore.int32)
-        >>> output = ops.deepcopy(input)
-        >>> print(output)
-        [[0 1]
-        [2 1]]
-    """
-    return identity_op(input_x)
-
-
-def ifft2(input, s=None, dim=(-2, -1), norm=None):
+def hfft2(input, s=None, dim=(-2, -1), norm=None):
     r"""
-    Computes the two dimensional inverse discrete Fourier transform of `input`.
+    Calculates the two dimensional discrete Fourier transform of of a Hermitian symmetric `input`.
 
     Note:
-        - `ifft2` is currently only used in `mindscience` scientific computing scenarios and
+        - `hfft2` is currently only used in `mindscience` scientific computing scenarios and
           dose not support other usage scenarios.
-        - `ifft2` is not supported on Windows platform yet.
+        - `hfft2` is not supported on Windows platform yet.
 
     Args:
         input (Tensor): The input tensor.
@@ -2827,20 +3296,21 @@ def ifft2(input, s=None, dim=(-2, -1), norm=None):
             - Ascend/CPU: int16, int32, int64, float16, float32, float64, complex64, complex128.
 
         s (tuple[int], optional): Length of the transformed `dim` of the result.
-            If given, the size of the `dim[i]` axis will be zero-padded or truncated to `s[i]` before calculating `ifft2`.
+            If given, the size of the `dim[i]` axis will be zero-padded or truncated to `s[i]` before calculating `hfft2`.
             Default: ``None`` , which does not need to process `input`.
-        dim (tuple[int], optional): The dimension along which to take the one dimensional `ifft2`.
+        dim (tuple[int], optional): The dimension along which to take the one dimensional `hfft2`.
             Default: ``(-2, -1)`` , which means transform the last two dimension of `input`.
         norm (str, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
-            Three modes are defined as,
+            Three modes are defined as, where :math: `n = prod(s)`
 
             - ``"backward"`` (no normalization).
-            - ``"forward"`` (normalize by :math:`1*n`).
-            - ``"ortho"`` (normalize by :math:`1*\sqrt{n}`).
+            - ``"forward"`` (normalize by :math:`1/n`).
+            - ``"ortho"`` (normalize by :math:`1/\sqrt{n}`).
 
     Returns:
-        Tensor, The result of `ifft2()` function. The default is the same shape as `input`.
-        If `s` is given, the size of the `dim[i]` axis is changed to `s[i]`.
+        Tensor, The result of `hfft2()` function.
+        If `s` is given, result.shape[dim[i]] is s[i], and for the last transformed dim, 
+        result.shape[dim[-1]] is :math:`(s[-1] - 1) * 2`, otherwise :math:`(input.shape[dim[-1]] - 1) * 2`.
         When the input is int16, int32, int64, float16, float32, complex64, the return value type is complex64.
         When the input is float64 or complex128, the return value type is complex128.
 
@@ -2851,6 +3321,7 @@ def ifft2(input, s=None, dim=(-2, -1), norm=None):
         ValueError: If `dim` is not in the range of "[ `-input.ndim` , `input.ndim` )".
         ValueError: If `dim` has duplicate values.
         ValueError: If `s` is less than 1.
+        ValueError: If `s` and `dim` are given but have different shapes.
         ValueError: If `norm` is none of ``"backward"`` , ``"forward"`` or ``"ortho"`` .
 
     Supported Platforms:
@@ -2860,24 +3331,24 @@ def ifft2(input, s=None, dim=(-2, -1), norm=None):
         >>> import mindspore
         >>> from mindspore import Tensor, ops
         >>> input = ops.ones((4, 4))
-        >>> ops.ifft2(input, s=(4, 4), dim=(0, 1), norm="backward")
-        Tensor(shape=[4, 4], dtype=Complex64, value=
-        [[1+0j, 0+0j, 0+0j, 0+0j],
-         [0+0j, 0+0j, 0+0j, 0+0j],
-         [0+0j, 0+0j, 0+0j, 0+0j],
-         [0+0j, 0+0j, 0+0j, 0+0j]])
+        >>> out = ops.hfft2(input, s=(4, 4), dim=(0, 1), norm="backward")
+        >>> print(out)
+        [[16.  0.  0.  0.]
+         [ 0.  0.  0.  0.]
+         [ 0.  0.  0.  0.]
+         [ 0.  0.  0.  0.]]
     """
-    return ifft2_op(input, s, dim, norm)
+    return hfft2_op(input, s, dim, norm)
 
 
-def ifft(input, n=None, dim=-1, norm=None):
+def hfft(input, n=None, dim=-1, norm=None):
     r"""
-    Calculates the inverse of `fft()`.
+    Calculates the one dimensional discrete Fourier transform of of a Hermitian symmetric `input` signal.
 
     Note:
-        - `ifft` is currently only used in `mindscience` scientific computing scenarios and
+        - `hfft` is currently only used in `mindscience` scientific computing scenarios and
           dose not support other usage scenarios.
-        - `ifft` is not supported on Windows platform yet.
+        - `hfft` is not supported on Windows platform yet.
 
     Args:
         input (Tensor): The input tensor.
@@ -2886,19 +3357,22 @@ def ifft(input, n=None, dim=-1, norm=None):
             - Ascend/CPU: int16, int32, int64, float16, float32, float64, complex64, complex128.
 
         n (int, optional): Length of the transformed `dim` of the result.
-            If given, the size of the `dim` axis will be zero-padded or truncated to `n` before calculating `ifft`.
+            If given, the size of the `dim` axis will be zero-padded or truncated to `n` before calculating `hfft`.
             Default: ``None`` , which does not need to process `input`.
-        dim (int, optional): The dimension along which to take the one dimensional `ifft`.
+        dim (int, optional): The dimension along which to take the one dimensional `hfft`.
             Default: ``-1`` , which means transform the last dimension of `input`.
         norm (str, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
             Three modes are defined as,
 
             - ``"backward"`` (no normalization).
-            - ``"forward"`` (normalize by :math:`1*n`).
-            - ``"ortho"`` (normalize by :math:`1*\sqrt{n}`).
+            - ``"forward"`` (normalize by :math:`1/n`).
+            - ``"ortho"`` (normalize by :math:`1/\sqrt{n}`).
 
     Returns:
-        Tensor, The result of `ifft()` function.
+        Tensor, The result of `hfft()` function.
+        If `n` is given, result.shape[dim] is :math:`(n - 1) * 2`, otherwise math:`(input.shape[dim] - 1) * 2`.
+        When the `input` is int16, int32, int64, float16, float32, complex64, the return value type is float32.
+        When the `input` is float64 or complex128, the return value type is float64.
 
     Raises:
         TypeError: If the `input` type is not Tensor.
@@ -2915,20 +3389,21 @@ def ifft(input, n=None, dim=-1, norm=None):
         >>> import mindspore
         >>> from mindspore import Tensor, ops
         >>> input = Tensor([ 1.6243454, -0.6117564, -0.5281718, -1.0729686])
-        >>> ops.ifft(input)
-        Tensor(shape=[4], dtype=Complex64, value= [-0.147138+0j, 0.538129+0.115303j, 0.695225+0j, 0.538129-0.115303j])
+        >>> out = ops.hfft(input, n=4, dim=-1, norm="backward")
+        >>> print(out)
+        [-0.12733912  2.1525173   2.3196864   2.1525173 ]
     """
-    return ifft_op(input, n, dim, norm)
+    return hfft_op(input, n, dim, norm)
 
 
-def ifftn(input, s=None, dim=None, norm=None):
+def hfftn(input, s=None, dim=None, norm=None):
     r"""
-    Computes the N dimensional inverse discrete Fourier transform of `input`.
+    Calculates the N dimensional discrete Fourier transform of of a Hermitian symmetric `input`.
 
     Note:
-        - `ifftn` is currently only used in `mindscience` scientific computing scenarios and
+        - `hfftn` is currently only used in `mindscience` scientific computing scenarios and
           dose not support other usage scenarios.
-        - `ifftn` is not supported on Windows platform yet.
+        - `hfftn` is not supported on Windows platform yet.
 
     Args:
         input (Tensor): The input tensor.
@@ -2937,20 +3412,21 @@ def ifftn(input, s=None, dim=None, norm=None):
             - Ascend/CPU: int16, int32, int64, float16, float32, float64, complex64, complex128.
 
         s (tuple[int], optional): Length of the transformed `dim` of the result.
-            If given, the size of the `dim[i]` axis will be zero-padded or truncated to `s[i]` before calculating `ifftn`.
+            If given, the size of the `dim[i]` axis will be zero-padded or truncated to `s[i]` before calculating `hfftn`.
             Default: ``None`` , which does not need to process `input`.
-        dim (tuple[int], optional): The dimension along which to take the one dimensional `ifftn`.
-            Default: ``None`` , which means transform the all dimension of `input`, or the last `len(s)` dimensions if s is given.
+        dim (tuple[int], optional): The dimension along which to take the one dimensional `hfftn`.
+            Default: ``(-2, -1)`` , which means transform the last two dimension of `input`.
         norm (str, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
-            Three modes are defined as,
+            Three modes are defined as, where :math: `n = prod(s)`
 
             - ``"backward"`` (no normalization).
-            - ``"forward"`` (normalize by :math:`1*n`).
-            - ``"ortho"`` (normalize by :math:`1*\sqrt{n}`).
+            - ``"forward"`` (normalize by :math:`1/n`).
+            - ``"ortho"`` (normalize by :math:`1/\sqrt{n}`).
 
     Returns:
-        Tensor, The result of `ifftn()` function. The default is the same shape as `input`.
-        If `s` is given, the size of the `dim[i]` axis is changed to `s[i]`.
+        Tensor, The result of `hfftn()` function.
+        If `s` is given, result.shape[dim[i]] is s[i], and for the last transformed dim, 
+        result.shape[dim[-1]] is :math:`(s[-1] - 1) * 2`, otherwise :math:`(input.shape[dim[-1]] - 1) * 2`.
         When the input is int16, int32, int64, float16, float32, complex64, the return value type is complex64.
         When the input is float64 or complex128, the return value type is complex128.
 
@@ -2970,71 +3446,634 @@ def ifftn(input, s=None, dim=None, norm=None):
     Examples:
         >>> import mindspore
         >>> from mindspore import Tensor, ops
-        >>> input = ops.ones((2, 2, 2))
-        >>> ops.ifftn(input, s=(2, 2, 2), dim=(0, 1, 2), norm="backward")
-        Tensor(shape=[2, 2, 2], dtype=Complex64, value=
-        [[[1+0j, 0+0j],
-         [0+0j, 0+0j]],
-         [[0+0j, 0+0j],
-         [0+0j, 0+0j]]])
+        >>> input = ops.ones((4, 4))
+        >>> out = ops.hfftn(input, s=(4, 4), dim=(0, 1), norm="backward")
+        >>> print(out)
+        [[16.  0.  0.  0.]
+         [ 0.  0.  0.  0.]
+         [ 0.  0.  0.  0.]
+         [ 0.  0.  0.  0.]]
     """
-    return ifftn_op(input, s, dim, norm)
+    return hfftn_op(input, s, dim, norm)
 
 
-def ifftshift(input, dim=None):
+def histc_ext(input, bins=100, min=0, max=0):
     r"""
-    The inverse of :func:`mindspore.ops.fftshift` .
+    Computes the histogram of a tensor.
 
-    Note:
-        - `ifftshift` is currently only used in `mindscience` scientific computing scenarios and
-          dose not support other usage scenarios.
-        - `ifftshift` is not supported on Windows platform yet.
+    The elements are sorted into equal width bins between `min` and `max`.
+    If `min` and `max` are both zero, the minimum and maximum values of the data are used.
+
+    Elements lower than min or higher than max are ignored.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+        If input is int64, valid values fit within int32; exceeding this may cause precision errors.
 
     Args:
-        input (Tensor): Input tensor.
-        dim (Union[int, list(int), tuple(int)], optional): The dimensions which to shift.
-            Default is ``None``, which shifts all dimensions.
+        input (Tensor): the input tensor.
+        bins (int, optional): Number of histogram bins, optional. If specified, must be positive. Default: ``100`` .
+        min (int, float, optional): the lower end of the range (inclusive), optional. Default: ``0`` .
+        max (int, float, optional): the upper end of the range (inclusive), optional. Default: ``0`` .
 
     Returns:
-        output (Tensor), the shifted tensor with the same shape and dtype as `input`.
+        A 1-D Tensor, has the same type as `input` with the shape :math:`(bins, )`.
 
     Raises:
-        TypeError: If `input` is not a tensor.
-        TypeError: If the type/dtype of `dim` is not int.
-        ValueError: If `dim` is out of the range of :math:`[-input.ndim, input.ndim)`.
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `input` datatype is not in support list.
+        TypeError: If attr `min` or `max` is not float or int.
+        TypeError: If attr `bins` is not int.
+        ValueError: If attr value `min` > `max`.
+        ValueError: If attr `bins` <= 0.
 
     Supported Platforms:
-        ``Ascend`` ``CPU``
+        ``Ascend``
 
     Examples:
-        >>> from mindspore.ops import fftshift, ifftshift
-        >>> from mindspore import Tensor
-        >>> from mindspore import dtype as mstype
-        >>> input = Tensor([0, 1, 2, 3, 4, -5, -4, -3, -2, -1], dtype=mstype.int32)
-        >>> ifftshift(fftshift(input))
-        Tensor(shape=[10], dtype=Int32, value= [ 0, 1, 2, 3, 4, -5, -4, -3, -2, -1])
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor([1., 2, 1])
+        >>> y = ops.histc_ext(x, bins=4, min=0, max=3)
+        >>> print(y)
+        [0 2 1 0]
     """
-    return ifftshift_op(input, dim)
+    return histc_ext_op(input, bins, min, max)
 
 
-def unfold_ext(input, kernel_size, dilation=1, padding=0, stride=1):
+def hardshrink(input, lambd=0.5):
     r"""
-    Extracts sliding local blocks from a batched input tensor.
+    Hard Shrink activation function. Calculates the output according to the input elements.
 
-    Consider a batched input tensor of shape :math:`(N, C, *)`,
-    where :math:`N` is the batch dimension, :math:`C` is the channel dimension,
-    and :math:`*` represent arbitrary spatial dimensions. This operation flattens
-    each sliding `Kernel_size`- sized block within the spatial dimensions
-    of `input` into a column (i.e., last dimension) of a 3-D output
-    tensor of shape :math:`(N, C \times \prod(\text{kernel_size}), L)`, where
-    :math:`C \times \prod(\text{kernel_size})` is the total number of values
-    within each block (a block has :math:`\prod(\text{kernel_size})` spatial
-    locations each containing a `C`-channeled vector), and :math:`L` is
-    the total number of such blocks:
+    The formula is defined as follows:
 
     .. math::
-        L = \prod_d \left\lfloor\frac{\text{spatial_size}[d] + 2 \times \text{padding}[d] %
-            - \text{dilation}[d] \times (\text{kernel_size}[d] - 1) - 1}{\text{stride}[d]} + 1\right\rfloor,
+        \text{HardShrink}(x) =
+        \begin{cases}
+        x, & \text{ if } x > \lambda \\
+        x, & \text{ if } x < -\lambda \\
+        0, & \text{ otherwise }
+        \end{cases}
+
+    HShrink Activation Function Graph:
+
+    .. image:: ../images/HShrink.png
+        :align: center
+
+    Args:
+        input (Tensor): The input of Hard Shrink. Supported dtypes: 
+
+            - Ascend: float16, float32, bfloat16.
+            - CPU/GPU: float16, float32.
+        lambd (number, optional): The threshold :math:`\lambda` defined by the Hard Shrink formula.
+            Default: ``0.5`` .
+
+    Returns:
+        Tensor, has the same data type and shape as the input `input`.
+
+    Raises:
+        TypeError: If `lambd` is not a float, int or bool.
+        TypeError: If `input` is not a tensor.
+        TypeError: If dtype of `input` is not float16, float32 or bfloat16.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([[0.5, 1, 2.0], [0.0533, 0.0776, -2.1233]]), mindspore.float32)
+        >>> output = ops.hardshrink(input)
+        >>> print(output)
+        [[ 0.      1.      2.    ]
+         [ 0.      0.     -2.1233]]
+    """
+    return hshrink_impl(input, lambd)
+
+
+def hardsigmoid(input):
+    r"""
+    Hard Sigmoid activation function. Calculates the output according to the input elements.
+
+    Hard Sigmoid is defined as:
+
+    .. math::
+        \text{Hardswish}(input) =
+        \begin{cases}
+        0, & \text{ if } input \leq -3, \\
+        1, & \text{ if } input \geq +3, \\
+        input/6 + 1/2, & \text{ otherwise }
+        \end{cases}
+
+    HSigmoid Activation Function Graph:
+
+    .. image:: ../images/HSigmoid.png
+        :align: center
+
+    Args:
+        input (Tensor): The input Tensor.
+
+    Returns:
+        Tensor, with the same type and shape as the `input`.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `input` is neither int nor float.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([-1, -2, 0, 2, 1]), mindspore.float16)
+        >>> output = ops.hardsigmoid(input)
+        >>> print(output)
+        [0.3333 0.1666 0.5    0.8335 0.6665]
+    """
+    return hsigmoid_op(input)
+
+
+def hardswish(input):
+    r"""
+    Hard Swish activation function. The input is a Tensor with any valid shape.
+
+    Hard swish is defined as:
+
+    .. math::
+        \text{Hardswish}(input) =
+        \begin{cases}
+        0, & \text{ if } input \leq -3, \\
+        input, & \text{ if } input \geq +3, \\
+        input*(input + 3)/6, & \text{ otherwise }
+        \end{cases}
+
+    HSwish Activation Function Graph:
+
+    .. image:: ../images/HSwish.png
+        :align: center
+
+    Args:
+        input (Tensor): The input Tensor.
+
+    Returns:
+        Tensor, with the same type and shape as the `input`.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `input` is neither int nor float.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([-1, -2, 0, 2, 1]), mindspore.float16)
+        >>> output = ops.hardswish(input)
+        >>> print(output)
+        [-0.3333  -0.3333  0  1.667  0.6665]
+    """
+    return hswish_op(input)
+
+
+def deepcopy(input_x):
+    r"""
+    Returns a deepcopy of input tensor.
+
+    Args:
+        input_x (Tensor): The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
+
+    Returns:
+        Tensor, a deepcopy of `input_x`.
+
+    Raises:
+        TypeError: If `input_x` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor([[0, 1], [2, 1]], dtype=mindspore.int32)
+        >>> output = ops.deepcopy(input)
+        >>> print(output)
+        [[0 1]
+        [2 1]]
+    """
+    return identity_op(input_x)
+
+
+def ifft2(input, s=None, dim=(-2, -1), norm=None):
+    r"""
+    Computes the two dimensional inverse discrete Fourier transform of `input`.
+
+    Note:
+        - `ifft2` is currently only used in `mindscience` scientific computing scenarios and
+          dose not support other usage scenarios.
+        - `ifft2` is not supported on Windows platform yet.
+
+    Args:
+        input (Tensor): The input tensor.
+            Supported dtypes:
+
+            - Ascend/CPU: int16, int32, int64, float16, float32, float64, complex64, complex128.
+
+        s (tuple[int], optional): Length of the transformed `dim` of the result.
+            If given, the size of the `dim[i]` axis will be zero-padded or truncated to `s[i]` before calculating `ifft2`.
+            Default: ``None`` , which does not need to process `input`.
+        dim (tuple[int], optional): The dimension along which to take the one dimensional `ifft2`.
+            Default: ``(-2, -1)`` , which means transform the last two dimension of `input`.
+        norm (str, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
+            Three modes are defined as, where :math: `n = prod(s)`
+
+            - ``"backward"`` (normalize by :math:`1/n`).
+            - ``"forward"`` (no normalization).
+            - ``"ortho"`` (normalize by :math:`1/\sqrt{n}`).
+
+    Returns:
+        Tensor, The result of `ifft2()` function. The default is the same shape as `input`.
+        If `s` is given, the size of the `dim[i]` axis is changed to `s[i]`.
+        When the input is int16, int32, int64, float16, float32, complex64, the return value type is complex64.
+        When the input is float64 or complex128, the return value type is complex128.
+
+    Raises:
+        TypeError: If the `input` type is not Tensor.
+        TypeError: If the `input` data type is not one of: int32, int64, float32, float64, complex64, complex128.
+        TypeError: If the type/dtype of `s` and `dim` is not int.
+        ValueError: If `dim` is not in the range of "[ `-input.ndim` , `input.ndim` )".
+        ValueError: If `dim` has duplicate values.
+        ValueError: If `s` is less than 1.
+        ValueError: If `s` and `dim` are given but have different shapes.
+        ValueError: If `norm` is none of ``"backward"`` , ``"forward"`` or ``"ortho"`` .
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> input = ops.ones((4, 4))
+        >>> out = ops.ifft2(input, s=(4, 4), dim=(0, 1), norm="backward")
+        >>> print(out)
+        [[1.+0.j 0.+0.j 0.+0.j 0.+0.j]
+         [0.+0.j 0.+0.j 0.+0.j 0.+0.j]
+         [0.+0.j 0.+0.j 0.+0.j 0.+0.j]
+         [0.+0.j 0.+0.j 0.+0.j 0.+0.j]]
+    """
+    return ifft2_op(input, s, dim, norm)
+
+
+def ifft(input, n=None, dim=-1, norm=None):
+    r"""
+    Calculates the inverse of `fft()`.
+
+    Note:
+        - `ifft` is currently only used in `mindscience` scientific computing scenarios and
+          dose not support other usage scenarios.
+        - `ifft` is not supported on Windows platform yet.
+
+    Args:
+        input (Tensor): The input tensor.
+            Supported dtypes:
+
+            - Ascend/CPU: int16, int32, int64, float16, float32, float64, complex64, complex128.
+
+        n (int, optional): Length of the transformed `dim` of the result.
+            If given, the size of the `dim` axis will be zero-padded or truncated to `n` before calculating `ifft`.
+            Default: ``None`` , which does not need to process `input`.
+        dim (int, optional): The dimension along which to take the one dimensional `ifft`.
+            Default: ``-1`` , which means transform the last dimension of `input`.
+        norm (str, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
+            Three modes are defined as,
+
+            - ``"backward"`` (normalize by :math:`1/n`).
+            - ``"forward"`` (no normalization).
+            - ``"ortho"`` (normalize by :math:`1/\sqrt{n}`).
+
+    Returns:
+        Tensor, The result of `ifft()` function. The default is the same shape as `input`.
+        If `n` is given, the size of the `dim` axis is changed to `n`.
+        When the input is int16, int32, int64, float16, float32, complex64, the return value type is complex64.
+        When the input is float64 or complex128, the return value type is complex128.
+
+    Raises:
+        TypeError: If the `input` type is not Tensor.
+        TypeError: If the `input` data type is not one of: int32, int64, float32, float64, complex64, complex128.
+        TypeError: If `n` or `dim` type is not int.
+        ValueError: If `dim` is not in the range of "[ `-input.ndim` , `input.ndim` )".
+        ValueError: If `n` is less than 1.
+        ValueError: If `norm` is none of ``"backward"`` , ``"forward"`` or ``"ortho"`` .
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor([ 1.6243454, -0.6117564, -0.5281718, -1.0729686])
+        >>> out = ops.ifft(input, n=4, dim=-1, norm="backward")
+        >>> print(out)
+        [-0.14713785+0.j          0.5381293 +0.11530305j  0.69522464+0.j
+          0.5381293 -0.11530305j]
+    """
+    return ifft_op(input, n, dim, norm)
+
+
+def ifftn(input, s=None, dim=None, norm=None):
+    r"""
+    Computes the N dimensional inverse discrete Fourier transform of `input`.
+
+    Note:
+        - `ifftn` is currently only used in `mindscience` scientific computing scenarios and
+          dose not support other usage scenarios.
+        - `ifftn` is not supported on Windows platform yet.
+
+    Args:
+        input (Tensor): The input tensor.
+            Supported dtypes:
+
+            - Ascend/CPU: int16, int32, int64, float16, float32, float64, complex64, complex128.
+
+        s (tuple[int], optional): Length of the transformed `dim` of the result.
+            If given, the size of the `dim[i]` axis will be zero-padded or truncated to `s[i]` before calculating `ifftn`.
+            Default: ``None`` , which does not need to process `input`.
+        dim (tuple[int], optional): The dimension along which to take the one dimensional `ifftn`.
+            Default: ``None`` , which means transform the all dimension of `input`, or the last `len(s)` dimensions if s is given.
+        norm (str, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
+            Three modes are defined as, where :math: `n = prod(s)`
+
+            - ``"backward"`` (normalize by :math:`1/n`).
+            - ``"forward"`` (no normalization).
+            - ``"ortho"`` (normalize by :math:`1/\sqrt{n}`).
+
+    Returns:
+        Tensor, The result of `ifftn()` function. The default is the same shape as `input`.
+        If `s` is given, the size of the `dim[i]` axis is changed to `s[i]`.
+        When the input is int16, int32, int64, float16, float32, complex64, the return value type is complex64.
+        When the input is float64 or complex128, the return value type is complex128.
+
+    Raises:
+        TypeError: If the `input` type is not Tensor.
+        TypeError: If the `input` data type is not one of: int32, int64, float32, float64, complex64, complex128.
+        TypeError: If the type/dtype of `s` and `dim` is not int.
+        ValueError: If `dim` is not in the range of "[ `-input.ndim` , `input.ndim` )".
+        ValueError: If `dim` has duplicate values.
+        ValueError: If `s` is less than 1.
+        ValueError: If `s` and `dim` are given but have different shapes.
+        ValueError: If `norm` is none of ``"backward"`` , ``"forward"`` or ``"ortho"`` .
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> input = ops.ones((2, 2, 2))
+        >>> out = ops.ifftn(input, s=(2, 2, 2), dim=(0, 1, 2), norm="backward")
+        >>> print(out)
+        [[[1.+0.j 0.+0.j]
+          [0.+0.j 0.+0.j]]
+          [[0.+0.j 0.+0.j]
+          [0.+0.j 0.+0.j]]]
+    """
+    return ifftn_op(input, s, dim, norm)
+
+
+def ifftshift(input, dim=None):
+    r"""
+    The inverse of :func:`mindspore.ops.fftshift` .
+
+    Note:
+        - `ifftshift` is currently only used in `mindscience` scientific computing scenarios and
+          dose not support other usage scenarios.
+        - `ifftshift` is not supported on Windows platform yet.
+
+    Args:
+        input (Tensor): Input tensor.
+        dim (Union[int, list(int), tuple(int)], optional): The dimensions which to shift.
+            Default is ``None``, which shifts all dimensions.
+
+    Returns:
+        output (Tensor), the shifted tensor with the same shape and dtype as `input`.
+
+    Raises:
+        TypeError: If `input` is not a tensor.
+        TypeError: If the type/dtype of `dim` is not int.
+        ValueError: If `dim` is out of the range of :math:`[-input.ndim, input.ndim)`.
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> from mindspore.ops import fftshift, ifftshift
+        >>> from mindspore import Tensor
+        >>> from mindspore import dtype as mstype
+        >>> input = Tensor([0, 1, 2, 3, 4, -5, -4, -3, -2, -1], dtype=mstype.int32)
+        >>> ifftshift(fftshift(input))
+        Tensor(shape=[10], dtype=Int32, value= [ 0, 1, 2, 3, 4, -5, -4, -3, -2, -1])
+    """
+    return ifftshift_op(input, dim)
+
+
+def ihfft2(input, s=None, dim=(-2, -1), norm=None):
+    r"""
+    Computes the two dimensional inverse discrete Fourier transform of real `input`.
+
+    Note:
+        - `ihfft2` is currently only used in `mindscience` scientific computing scenarios and
+          dose not support other usage scenarios.
+        - `ihfft2` is not supported on Windows platform yet.
+
+    Args:
+        input (Tensor): The input tensor.
+            Supported dtypes:
+
+            - Ascend/CPU: int16, int32, int64, float16, float32, float64.
+
+        s (tuple[int], optional): Length of the transformed `dim` of the result.
+            If given, the size of the `dim[i]` axis will be zero-padded or truncated to `s[i]` before calculating `ihfft2`.
+            Default: ``None`` , which does not need to process `input`.
+        dim (tuple[int], optional): The dimension along which to take the one dimensional `ihfft2`.
+            Default: ``(-2, -1)`` , which means transform the last two dimension of `input`.
+        norm (str, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
+            Three modes are defined as, where :math: `n = prod(s)`
+
+          - ``"backward"`` (normalize by :math:`1/n`).
+          - ``"forward"`` (no normalization).
+          - ``"ortho"`` (normalize by :math:`1/\sqrt{n}`).
+
+    Returns:
+        Tensor, The result of `ihfft2()` function.
+        If `s` is given, result.shape[dim[i]] is s[i], and for the last transformed dim, 
+        result.shape[dim[-1]] is :math:`s[-1] // 2 + 1`, otherwise :math:`input.shape[dim[-1]] // 2 + 1`.
+        When the input is int16, int32, int64, float16, float32, the return value type is complex64.
+        When the input is float64, the return value type is complex128.
+
+    Raises:
+        TypeError: If the `input` type is not Tensor.
+        TypeError: If the `input` data type is not one of: int32, int64, float32, float64.
+        TypeError: If the type/dtype of `s` and `dim` is not int.
+        ValueError: If `dim` is not in the range of "[ `-input.ndim` , `input.ndim` )".
+        ValueError: If `dim` has duplicate values.
+        ValueError: If `s` is less than 1.
+        ValueError: If `s` and `dim` are given but have different shapes.
+        ValueError: If `norm` is none of ``"backward"`` , ``"forward"`` or ``"ortho"`` .
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> input = ops.ones((4, 4))
+        >>> out = ops.ihfft2(input, s=(4, 4), dim=(0, 1), norm="backward")
+        >>> print(out)
+        [[1.-0.j 0.-0.j 0.-0.j]
+         [0.-0.j 0.-0.j 0.-0.j]
+         [0.-0.j 0.-0.j 0.-0.j]
+         [0.-0.j 0.-0.j 0.-0.j]]
+    """
+    return ihfft2_op(input, s, dim, norm)
+
+
+def ihfft(input, n=None, dim=-1, norm=None):
+    r"""
+    Calculates the inverse of `hfft()`.
+
+    Note:
+        - `ihfft` is currently only used in `mindscience` scientific computing scenarios and
+          dose not support other usage scenarios.
+        - `ihfft` is not supported on Windows platform yet.
+
+    Args:
+        input (Tensor): The input tensor.
+            Supported dtypes:
+
+            - Ascend/CPU: int16, int32, int64, float16, float32, float64.
+
+        n (int, optional): Length of the transformed `dim` of the result.
+            If given, the size of the `dim` axis will be zero-padded or truncated to `n` before calculating `ihfft`.
+            Default: ``None`` , which does not need to process `input`.
+        dim (int, optional): The dimension along which to take the one dimensional `ihfft`.
+            Default: ``-1`` , which means transform the last dimension of `input`.
+        norm (str, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
+            Three modes are defined as,
+
+            - ``"backward"`` (no normalization).
+            - ``"forward"`` (normalize by :math:`1*n`).
+            - ``"ortho"`` (normalize by :math:`1*\sqrt{n}`).
+
+    Returns:
+        Tensor, The result of `ihfft()` function.
+        If `n` is given, result.shape[dim] is :math:`n // 2 + 1`, otherwise math:`input.shape[dim] // 2 + 1`.
+        When the input is int16, int32, int64, float16, float32, the return value type is complex64.
+        When the input is float64, the return value type is complex128.
+
+    Raises:
+        TypeError: If the `input` type is not Tensor.
+        TypeError: If the `input` data type is not one of: int32, int64, float32, float64.
+        TypeError: If `n` or `dim` type is not int.
+        ValueError: If `dim` is not in the range of "[ `-input.ndim` , `input.ndim` )".
+        ValueError: If `n` is less than 1.
+        ValueError: If `norm` is none of ``"backward"`` , ``"forward"`` or ``"ortho"`` .
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor([ 1.6243454, -0.6117564, -0.5281718, -1.0729686])
+        >>> out = ops.ihfft(input, n=4, dim=-1, norm="backward")
+        >>> print(out)
+        [-0.14713785-0.j          0.5381293 +0.11530305j  0.69522464-0.j        ]
+    """
+    return ihfft_op(input, n, dim, norm)
+
+
+def ihfftn(input, s=None, dim=None, norm=None):
+    r"""
+    Computes the N dimensional inverse discrete Fourier transform of real `input`.
+
+    Note:
+        - `ihfftn` is currently only used in `mindscience` scientific computing scenarios and
+          dose not support other usage scenarios.
+        - `ihfftn` is not supported on Windows platform yet.
+
+    Args:
+        input (Tensor): The input tensor.
+            Supported dtypes:
+
+            - Ascend/CPU: int16, int32, int64, float16, float32, float64.
+
+        s (tuple[int], optional): Length of the transformed `dim` of the result.
+            If given, the size of the `dim[i]` axis will be zero-padded or truncated to `s[i]` before calculating `ihfftn`.
+            Default: ``None`` , which does not need to process `input`.
+        dim (tuple[int], optional): The dimension along which to take the one dimensional `ihfftn`.
+            Default: ``(-2, -1)`` , which means transform the last two dimension of `input`.
+        norm (str, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
+            Three modes are defined as, where :math: `n = prod(s)`
+
+          - ``"backward"`` (normalize by :math:`1/n`).
+          - ``"forward"`` (no normalization).
+          - ``"ortho"`` (normalize by :math:`1/\sqrt{n}`).
+
+    Returns:
+        Tensor, The result of `ihfftn()` function.
+        If `s` is given, result.shape[dim[i]] is s[i], and for the last transformed dim, 
+        result.shape[dim[-1]] is :math:`s[-1] // 2 + 1`, otherwise :math:`input.shape[dim[-1]] // 2 + 1`.
+        When the input is int16, int32, int64, float16, float32, the return value type is complex64.
+        When the input is float64, the return value type is complex128.
+
+    Raises:
+        TypeError: If the `input` type is not Tensor.
+        TypeError: If the `input` data type is not one of: int32, int64, float32, float64.
+        TypeError: If the type/dtype of `s` and `dim` is not int.
+        ValueError: If `dim` is not in the range of "[ `-input.ndim` , `input.ndim` )".
+        ValueError: If `dim` has duplicate values.
+        ValueError: If `s` is less than 1.
+        ValueError: If `s` and `dim` are given but have different shapes.
+        ValueError: If `norm` is none of ``"backward"`` , ``"forward"`` or ``"ortho"`` .
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> input = ops.ones((4, 4))
+        >>> out = ops.ihfftn(input, s=(4, 4), dim=(0, 1), norm="backward")
+        >>> print(out)
+        [[16.  0.  0.  0.]
+         [ 0.  0.  0.  0.]
+         [ 0.  0.  0.  0.]
+         [ 0.  0.  0.  0.]]
+    """
+    return ihfftn_op(input, s, dim, norm)
+
+
+def unfold_ext(input, kernel_size, dilation=1, padding=0, stride=1):
+    r"""
+    Extracts sliding local blocks from a batched input tensor.
+
+    Consider a batched input tensor of shape :math:`(N, C, *)`,
+    where :math:`N` is the batch dimension, :math:`C` is the channel dimension,
+    and :math:`*` represent arbitrary spatial dimensions. This operation flattens
+    each sliding `Kernel_size`- sized block within the spatial dimensions
+    of `input` into a column (i.e., last dimension) of a 3-D output
+    tensor of shape :math:`(N, C \times \prod(\text{kernel_size}), L)`, where
+    :math:`C \times \prod(\text{kernel_size})` is the total number of values
+    within each block (a block has :math:`\prod(\text{kernel_size})` spatial
+    locations each containing a `C`-channeled vector), and :math:`L` is
+    the total number of such blocks:
+
+    .. math::
+        L = \prod_d \left\lfloor\frac{\text{spatial_size}[d] + 2 \times \text{padding}[d] %
+            - \text{dilation}[d] \times (\text{kernel_size}[d] - 1) - 1}{\text{stride}[d]} + 1\right\rfloor,
 
     where :math:`\text{spatial_size}` is formed by the spatial dimensions
     of `input` (:math:`*` above), and :math:`d` is over all spatial
@@ -3114,25 +4153,111 @@ def index_select_ext(input, dim, index):
         ValueError: If the dimension of `index` is not equal to 1.
 
     Supported Platforms:
-        ``Ascend``
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> import numpy as np
+        >>> input = Tensor(np.arange(16).astype(np.float32).reshape(2, 2, 4))
+        >>> print(input)
+        [[[ 0.  1.  2.  3.]
+        [ 4.  5.  6.  7.]]
+        [[ 8.  9. 10. 11.]
+        [12. 13. 14. 15.]]]
+        >>> index = Tensor([0,], mindspore.int32)
+        >>> y = ops.auto_generate.index_select_ext(input, 1, index)
+        >>> print(y)
+        [[[ 0.  1.  2.  3.]]
+        [[ 8.  9. 10. 11.]]]
+    """
+    return index_select_op(input, dim, index)
+
+
+def inplace_add_ext(input, other, alpha=1):
+    r"""
+    
+    """
+    return inplace_add_ext_op(input, other, alpha)
+
+
+def inplace_addmm(input, mat1, mat2, beta=1, alpha=1):
+    r"""
+    
+    """
+    return inplace_addmm_op(input, mat1, mat2, beta, alpha)
+
+
+def inplace_adds_ext(input, other, alpha=1):
+    r"""
+    
+    """
+    return inplace_adds_ext_op(input, other, alpha)
+
+
+def zero_(input):
+    r"""
+    
+    """
+    return inplace_zero_op(input)
+
+
+def irfft2(input, s=None, dim=(-2, -1), norm=None):
+    r"""
+    Calculates the inverse of `rfft2()`.
+
+    Note:
+        - `irfft2` is currently only used in `mindscience` scientific computing scenarios and
+          dose not support other usage scenarios.
+        - `irfft2` is not supported on Windows platform yet.
+
+    Args:
+        input (Tensor): The input tensor.
+            Supported dtypes:
+
+            - Ascend/CPU: int16, int32, int64, float16, float32, float64, complex64, complex128.
+
+        s (tuple[int], optional): Length of the transformed `dim` of the result.
+            If given, the size of the `dim[i]` axis will be zero-padded or truncated to `s[i]` before calculating `irfft2`.
+            Default: ``None`` , the dim[-1] of the `input` will be zero-padded to :math:`2*(input.shape[dim[-1]]-1)`.
+        dim (tuple[int], optional): The dimension along which to take the one dimensional `irfft2`.
+            Default: ``(-2, -1)`` , which means transform the last two dimension of `input`.
+        norm (str, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
+            Three modes are defined as, where :math: `n = prod(s)`
+
+            - ``"backward"`` (normalize by :math:`1/n`).
+            - ``"forward"`` (no normalization).
+            - ``"ortho"`` (normalize by :math:`1/\sqrt{n}`).
+
+    Returns:
+        Tensor, The result of `irfft2()` function, result.shape[dim[i]] is s[i].
+        When the input is int16, int32, int64, float16, float32, complex64, the return value type is float32.
+        When the input is float64 or complex128, the return value type is float64.
+
+    Raises:
+        TypeError: If the `input` type is not Tensor.
+        TypeError: If the `input` data type is not one of: int32, int64, float32, float64, complex64, complex128.
+        TypeError: If the type/dtype of `s` and `dim` is not int.
+        ValueError: If `dim` is not in the range of "[ `-input.ndim` , `input.ndim` )".
+        ValueError: If `dim` has duplicate values.
+        ValueError: If `s` is less than 1.
+        ValueError: If `norm` is none of ``"backward"`` , ``"forward"`` or ``"ortho"`` .
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
 
     Examples:
         >>> import mindspore
         >>> from mindspore import Tensor, ops
-        >>> import numpy as np
-        >>> input = Tensor(np.arange(16).astype(np.float32).reshape(2, 2, 4))
-        >>> print(input)
-        [[[ 0.  1.  2.  3.]
-        [ 4.  5.  6.  7.]]
-        [[ 8.  9. 10. 11.]
-        [12. 13. 14. 15.]]]
-        >>> index = Tensor([0,], mindspore.int32)
-        >>> y = ops.auto_generate.index_select_ext(input, 1, index)
-        >>> print(y)
-        [[[ 0.  1.  2.  3.]]
-        [[ 8.  9. 10. 11.]]]
+        >>> input = ops.ones((4, 4))
+        >>> ops.irfft2(input, s=(4, 4), dim=(0, 1), norm="backward")
+        Tensor(shape=[4, 4], dtype=Float32, value=
+        [[ 1.00000000e+00,  0.00000000e+00,  0.00000000e+00,  0.00000000e+00],
+         [ 0.00000000e+00,  0.00000000e+00,  0.00000000e+00,  0.00000000e+00],
+         [ 0.00000000e+00,  0.00000000e+00,  0.00000000e+00,  0.00000000e+00],
+         [ 0.00000000e+00,  0.00000000e+00,  0.00000000e+00,  0.00000000e+00]])
     """
-    return index_select_op(input, dim, index)
+    return irfft2_op(input, s, dim, norm)
 
 
 def irfft(input, n=None, dim=-1, norm=None):
@@ -3177,14 +4302,72 @@ def irfft(input, n=None, dim=-1, norm=None):
         >>> import mindspore
         >>> from mindspore import Tensor, ops
         >>> input = Tensor([1, 2, 3, 4])
-        >>> y = ops.irfft(input)
+        >>> y = ops.irfft(input, n=6, dim=-1, norm='backward')
         >>> print(y)
-        [ 2.5000000e+00 -6.6666669e-01  1.2590267e-15 -1.6666667e-01
-        4.2470195e-16 -6.6666669e-01]
+        [ 2.5        -0.6666667   0.         -0.16666667  0.         -0.6666667 ]
     """
     return irfft_op(input, n, dim, norm)
 
 
+def irfftn(input, s=None, dim=None, norm=None):
+    r"""
+    Calculates the inverse of `rfftn()`.
+
+    Note:
+        - `irfftn` is currently only used in `mindscience` scientific computing scenarios and
+          dose not support other usage scenarios.
+        - `irfftn` is not supported on Windows platform yet.
+
+    Args:
+        input (Tensor): The input tensor.
+            Supported dtypes:
+
+            - Ascend/CPU: int16, int32, int64, float16, float32, float64, complex64, complex128.
+
+        s (tuple[int], optional): Length of the transformed `dim` of the result.
+            If given, the size of the `dim[i]` axis will be zero-padded or truncated to `s[i]` before calculating `irfftn`.
+            Default: ``None`` , the dim[-1] of the `input` will be zero-padded to :math:`2*(input.shape[dim[-1]]-1)`.
+        dim (tuple[int], optional): The dimension along which to take the one dimensional `irfftn`.
+            Default: ``None`` , which means transform the all dimension of `input`, or the last `len(s)` dimensions if s is given.
+        norm (str, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
+            Three modes are defined as, where :math: `n = prod(s)`
+
+            - ``"backward"`` (normalize by :math:`1/n`).
+            - ``"forward"`` (no normalization).
+            - ``"ortho"`` (normalize by :math:`1/\sqrt{n}`).
+
+    Returns:
+        Tensor, The result of `irfftn()` function, result.shape[dim[i]] is s[i].
+        When the input is int16, int32, int64, float16, float32 the return value type is float32.
+        When the input is float64, the return value type is float64.
+
+    Raises:
+        TypeError: If the `input` type is not Tensor.
+        TypeError: If the `input` data type is not one of: int32, int64, float32, float64, complex64, complex128.
+        TypeError: If the type/dtype of `s` and `dim` is not int.
+        ValueError: If `dim` is not in the range of "[ `-input.ndim` , `input.ndim` )".
+        ValueError: If `dim` has duplicate values.
+        ValueError: If `s` is less than 1.
+        ValueError: If `s` and `dim` are given but have different shapes.
+        ValueError: If `norm` is none of ``"backward"`` , ``"forward"`` or ``"ortho"`` .
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> input = ops.ones((2, 2, 2))
+        >>> ops.irfftn(input, s=(2, 2, 2), dim=(0, 1, 2), norm="backward")
+        Tensor(shape=[2, 2, 2], dtype=Float32, value=
+        [[[ 1.00000000e+00,  0.00000000e+00],
+          [ 0.00000000e+00,  0.00000000e+00]],
+         [[ 0.00000000e+00,  0.00000000e+00],
+          [ 0.00000000e+00,  0.00000000e+00]]])
+    """
+    return irfftn_op(input, s, dim, norm)
+
+
 def isfinite(x):
     r"""
     Determine which elements are finite for each position. If elements are not ``NaN`` , ``-INF`` , ``INF``,
@@ -3225,6 +4408,65 @@ def isfinite(x):
     return isfinite_op(x)
 
 
+def l1_loss_ext(input, target, reduction='mean'):
+    r"""
+    Calculate the mean absolute error between the `input` value and the `target` value.
+
+    Assuming that the :math:`x` and :math:`y` are the predicted value and target value,
+    both are one-dimensional tensors of length :math:`N`, length :math:`N`, `reduction` is set to ``'none'`` ,
+    then calculate the loss of :math:`x` and :math:`y` without dimensionality reduction.
+
+    The formula is as follows:
+
+    .. math::
+        \ell(x, y) = L = \{l_1,\dots,l_N\}^\top, \quad \text{with } l_n = \left| x_n - y_n \right|,
+
+    where :math:`N` is the batch size.
+
+    If `reduction` is ``'mean'`` or ``'sum'`` , then:
+
+    .. math::
+        \ell(x, y) =
+        \begin{cases}
+            \operatorname{mean}(L), & \text{if reduction} = \text{'mean';}\\
+            \operatorname{sum}(L),  & \text{if reduction} = \text{'sum'.}
+        \end{cases}
+
+    Args:
+        input (Tensor): Predicted value, Tensor of any dimension.
+        target (Tensor): Target value, usually has the same shape as the `input`.
+            If `input` and `target` have different shapes, make sure they can broadcast to each other.
+        reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
+            ``'sum'`` . Default: ``'mean'`` .
+
+            - ``'none'``: no reduction will be applied.
+            - ``'mean'``: compute and return the mean of elements in the output. Notice: At least one of the input and target is float type when the reduction is ``'mean'`` .
+            - ``'sum'``: the output elements will be summed.
+
+    Returns:
+        Tensor or Scalar, if `reduction` is ``'none'`` , return a Tensor with same shape and dtype as `input`.
+        Otherwise, a scalar value will be returned.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `target` is not a Tensor.
+        ValueError: If `reduction` is not one of ``'none'`` , ``'mean'`` or ``'sum'`` .
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore import dtype as mstype
+        >>> x = Tensor([[1, 2, 3], [4, 5, 6]], mstype.float32)
+        >>> target = Tensor([[6, 5, 4], [3, 2, 1]], mstype.float32)
+        >>> output = ops.l1_loss_ext(x, target, reduction="mean")
+        >>> print(output)
+        3.0
+    """
+    return l1_loss_ext_op(input, target, reduction)
+
+
 def leaky_relu_ext(input, negative_slope=0.01):
     r"""
     leaky_relu activation function. The element of `input` less than 0 times `negative_slope` .
@@ -3361,7 +4603,7 @@ def log1p(input):
     Returns the natural logarithm of one plus the input tensor element-wise.
 
     .. math::
-        out_i = \{log_e}(input_i + 1)
+        out_i = \log_e(input_i + 1)
 
     Args:
         input (Tensor): The input tensor. The value must be greater than -1.
@@ -3422,6 +4664,48 @@ def log(input):
     return log_op(input)
 
 
+def log_softmax_ext(input, dim=None, dtype=None):
+    r"""
+    Applies the Log Softmax function to the input tensor on the specified axis.
+    Supposes a slice in the given axis, :math:`x` for each element :math:`x_i`,
+    the Log Softmax function is shown as follows:
+
+    .. math::
+        \text{output}(x_i) = \log \left(\frac{\exp(x_i)} {\sum_{j = 0}^{N-1}\exp(x_j)}\right),
+
+    where :math:`N` is the length of the Tensor.
+
+    Args:
+        input (Tensor): The input Tensor.
+        dim (int, optional): The axis to perform the Log softmax operation. Default: ``None`` .
+
+    Keyword Args:
+        dtype (:class:`mindspore.dtype`, optional): The desired dtype of returned Tensor. If not set to None, the input
+            Tensor will be cast to `dtype` before the operation is performed. This is useful for preventing overflows.
+            If set to None, stay the same as original Tensor. Default: ``None`` . Supported data type is {float16, float32, double, bfloat16}.
+
+    Returns:
+        Tensor, with the same shape as the input.
+
+    Raises:
+        TypeError: If `dim` is not an int.
+        ValueError: If `dim` is not in range [-len(input.shape), len(input.shape)).
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> logits = Tensor(np.array([1, 2, 3, 4, 5]), mindspore.float32)
+        >>> output = ops.auto_generate.log_softmax(logits, dim=-1)
+        >>> print(output)
+        [-4.4519143 -3.4519143 -2.4519143 -1.4519144 -0.4519144]
+    """
+    return log_softmax_ext_op(input, dim, dtype)
+
+
 def log_softmax(logits, axis=-1):
     r"""
     Applies the Log Softmax function to the input tensor on the specified axis.
@@ -3459,8 +4743,55 @@ def log_softmax(logits, axis=-1):
         >>> print(output)
         [-4.4519143 -3.4519143 -2.4519143 -1.4519144 -0.4519144]
     """
-    log_softmax_op = _get_cache_prim(LogSoftmax)(axis)
-    return log_softmax_op(logits)
+    return log_softmax_impl(logits, axis)
+
+
+def logaddexp_ext(input, other):
+    r"""
+    Computes the logarithm of the sum of exponentiations of the inputs.
+    This function is useful in statistics where the calculated probabilities of events may be
+    so small as to exceed the range of normal floating point numbers.
+
+    .. math::
+
+        out_i = \log(exp(input_i) + \exp(other_i))
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): Input Tensor. The dtype of `input` must be float.
+        other (Tensor): Input Tensor. The dtype of `other` must be float.
+            If the shape of `input` is not equal to the shape of `other`,
+            they must be broadcastable to a common shape (which becomes the shape of the output).
+
+    Returns:
+        Tensor, with the same dtype as `input` and `other`.
+
+    Raises:
+        TypeError: If `input` or `other` is not a Tensor.
+        TypeError: The dtype of `input` or `other` is not float.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> x1 = Tensor(np.array([1, 2, 3]).astype(np.float16))
+        >>> x2 = Tensor(np.array(2).astype(np.float16))
+        >>> output = ops.logaddexp_ext(x1, x2)
+        >>> print(output)
+        [2.312 2.693 3.312]
+    """
+    return logaddexp_op(input, other)
+
+
+def logsigmoid_grad(dy, input, buffer):
+    r"""
+    
+    """
+    return logsigmoid_grad_op(dy, input, buffer)
 
 
 def masked_fill(input_x, mask, value):
@@ -3502,6 +4833,38 @@ def masked_fill(input_x, mask, value):
     return masked_fill_op(input_x, mask, value)
 
 
+def masked_select(input, mask):
+    r"""
+    Returns a new 1-D Tensor which indexes the `input` tensor according to the boolean `mask`.
+    The shapes of the `mask` tensor and the `input` tensor don't need to match, but they must be broadcastable.
+
+    Args:
+        input (Tensor): The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
+        mask (Tensor[bool]): The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
+
+    Returns:
+        A 1-D Tensor, with the same type as `input`.
+
+    Raises:
+        TypeError: If `input` or `mask` is not a Tensor.
+        TypeError: If dtype of `mask` is not bool.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor(np.array([1, 2, 3, 4]), mindspore.int64)
+        >>> mask = Tensor(np.array([1, 0, 1, 0]), mindspore.bool_)
+        >>> output = ops.masked_select(x, mask)
+        >>> print(output)
+        [1 3]
+    """
+    return masked_select_op(input, mask)
+
+
 def matmul_ext(input, mat2):
     r"""
     
@@ -3592,10 +4955,12 @@ def maximum(input, other):
     r"""
     Computes the maximum of input tensors element-wise.
 
+    .. math::
+        output_i = \max(input_i, other_i)
+
     Note:
         - Inputs of `input` and `other` comply with the implicit type conversion rules to make the data types
           consistent.
-        - The input must be two Tensors, or a Tensor and a Scalar.
         - When the inputs are two tensors,
           dtypes of them cannot be bool at the same time, and the shapes of them could be broadcast.
         - When the inputs are one tensor and one scalar,
@@ -3603,8 +4968,9 @@ def maximum(input, other):
         - Broadcasting is supported.
         - If one of the elements being compared is a NaN, then that element is returned.
 
-    .. math::
-        output_i = \max(input_i, other_i)
+    .. warning::
+        If all inputs are scalar of integers. In GRAPH mode, the output will be Tensor of int32, while in
+        PYNATIVE mode, the output will be Tensor of int64.
 
     Args:
         input (Union[Tensor, Number, bool]): The first input is a number or
@@ -3751,44 +5117,134 @@ def minimum(input, other):
         - Shapes of them are supposed to be broadcast.
         - If one of the elements being compared is a NaN, then that element is returned.
 
-    .. math::
-        output_i = \min(input_i, other_i)
+    .. math::
+        output_i = \min(input_i, other_i)
+
+    Args:
+        input (Union[Tensor, Number, bool]): The first input is a number or
+            a bool or a tensor whose data type is number or bool.
+        other (Union[Tensor, Number, bool]): The second input is a number or
+            a bool when the first input is a tensor or a tensor whose data type is number or bool.
+
+    Returns:
+        Tensor, the shape is the same as the one after broadcasting,
+        and the data type is the one with higher precision or higher digits among the two inputs.
+
+    Raises:
+        TypeError: If `input` and `other` is not one of the following: Tensor, Number, bool.
+        ValueError: If `input` and `other` are not the same shape after broadcast.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> # case 1 : same data type
+        >>> input = Tensor(np.array([1.0, 5.0, 3.0]), mindspore.float32)
+        >>> other = Tensor(np.array([4.0, 2.0, 6.0]), mindspore.float32)
+        >>> output = ops.minimum(input, other)
+        >>> print(output)
+        [1. 2. 3.]
+        >>> # case 2 : different data type
+        >>> input = Tensor(np.array([1.0, 5.0, 3.0]), mindspore.int32)
+        >>> other = Tensor(np.array([4.0, 2.0, 6.0]), mindspore.float32)
+        >>> output = ops.minimum(input, other)
+        >>> print(output.dtype)
+        Float32
+    """
+    return minimum_op(input, other)
+
+
+def mish_ext(input):
+    r"""
+    Computes MISH (A Self Regularized Non-Monotonic Neural Activation Function)
+    of input tensors element-wise.
+
+    The formula is defined as follows:
+
+    .. math::
+        \text{mish}(input) = input * \tanh(softplus(\text{input}))
+
+    See more details in `A Self Regularized Non-Monotonic Neural Activation Function 
+    <https://arxiv.org/abs/1908.08681>`_.
+
+    Mish Activation Function Graph:
+
+    .. image:: ../images/Mish.png
+        :align: center
+
+    Args:
+        input (Tensor): The input of MISH. Supported dtypes: 
+
+            - Ascend: float16, float32.
+
+    Returns:
+        Tensor, has the same type and shape as the `input`.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If dtype of `input` is not float16 or float32.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> import numpy as np
+        >>> x = Tensor(np.array([[-1.1, 4.0, -8.0], [2.0, -5.0, 9.0]]), mindspore.float32)
+        >>> output = ops.mish(x)
+        >>> print(output)
+        [[-3.0764845e-01 3.9974124e+00 -2.6832507e-03]
+         [ 1.9439589e+00 -3.3576239e-02 8.9999990e+00]]
+    """
+    return mish_ext_op(input)
+
+
+def mse_loss_ext(input, target, reduction='mean'):
+    r"""
+    Calculates the mean squared error between the predicted value and the label value.
+
+    For detailed information, please refer to :class:`mindspore.nn.MSELoss`.
 
     Args:
-        input (Union[Tensor, Number, bool]): The first input is a number or
-            a bool or a tensor whose data type is number or bool.
-        other (Union[Tensor, Number, bool]): The second input is a number or
-            a bool when the first input is a tensor or a tensor whose data type is number or bool.
+        input (Tensor): Tensor of any dimension. The data type needs to be consistent with the `target`.
+            It should also be broadcastable with the `target`.
+        target (Tensor): The input label. Tensor of any dimension. The data type needs to be consistent with the `input`.
+            It should also be broadcastable with the `input`.
+        reduction (str, optional): Apply specific reduction method to the output: ``'mean'`` , ``'none'`` ,
+            ``'sum'`` . Default: ``'mean'`` .
+
+            - ``'none'``: no reduction will be applied.
+            - ``'mean'``: compute and return the mean of elements in the output.
+            - ``'sum'``: the output elements will be summed.
 
     Returns:
-        Tensor, the shape is the same as the one after broadcasting,
-        and the data type is the one with higher precision or higher digits among the two inputs.
+        - Tensor. If `reduction` is ``'mean'`` or ``'sum'``, the shape of output is `Tensor Scalar`.
+        - If reduction is ``'none'``, the shape of output is the broadcasted shape of **input** and **target** .
 
     Raises:
-        TypeError: If `input` and `other` is not one of the following: Tensor, Number, bool.
-        ValueError: If `input` and `other` are not the same shape after broadcast.
+        ValueError: If `reduction` is not one of ``'mean'`` , ``'sum'`` or ``'none'``.
+        ValueError: If `input` and `target` are not broadcastable.
+        TypeError: If `input` and `target` are in different data type.
 
     Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
+        ``Ascend``
 
     Examples:
         >>> import mindspore
         >>> import numpy as np
         >>> from mindspore import Tensor, ops
-        >>> # case 1 : same data type
-        >>> input = Tensor(np.array([1.0, 5.0, 3.0]), mindspore.float32)
-        >>> other = Tensor(np.array([4.0, 2.0, 6.0]), mindspore.float32)
-        >>> output = ops.minimum(input, other)
+        >>> logits = Tensor(np.array([1, 2, 3]), mindspore.float32)
+        >>> labels = Tensor(np.array([[1, 1, 1], [1, 2, 2]]), mindspore.float32)
+        >>> output = ops.mse_loss_ext(logits, labels, reduction='none')
         >>> print(output)
-        [1. 2. 3.]
-        >>> # case 2 : different data type
-        >>> input = Tensor(np.array([1.0, 5.0, 3.0]), mindspore.int32)
-        >>> other = Tensor(np.array([4.0, 2.0, 6.0]), mindspore.float32)
-        >>> output = ops.minimum(input, other)
-        >>> print(output.dtype)
-        Float32
+        [[0. 1. 4.]
+         [0. 0. 1.]]
     """
-    return minimum_op(input, other)
+    return mse_loss_ext_op(input, target, reduction)
 
 
 def mul(input, other):
@@ -3810,12 +5266,12 @@ def mul(input, other):
     Args:
         input (Union[Tensor, number.Number, bool]): The first input is a number.Number or
             a bool or a tensor whose data type is
-            `number <https://www.mindspore.cn/docs/en/r2.3/api_python/mindspore.html#mindspore.dtype>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/r2.3/api_python/mindspore.html#mindspore.dtype>`_.
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         other (Union[Tensor, number.Number, bool]): The second input, which is a number.Number or
             a bool or a tensor whose data type is
-            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
 
     Returns:
         Tensor, the shape is the same as the one after broadcasting,
@@ -3841,6 +5297,13 @@ def mul(input, other):
     return mul_op(input, other)
 
 
+def muls(input, other):
+    r"""
+    
+    """
+    return muls_op(input, other)
+
+
 def mv(input, vec):
     r"""
     
@@ -3848,6 +5311,44 @@ def mv(input, vec):
     return mv_op(input, vec)
 
 
+def nan_to_num(input, nan=None, posinf=None, neginf=None):
+    r"""
+    Replace the `NaN`, positive infinity and negative infinity values in `input` with the
+    specified values in `nan`, `posinf` and `neginf` respectively.
+
+    .. warning::
+        For Ascend, it is only supported on Atlas A2 Training Series Products.
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): The shape of tensor is :math:`(input_1, input_2, ..., input_R)`.
+        nan (number, optional): The replace value of `NaN`. Default value is ``None``.
+        posinf (number, optional): the value to replace positive infinity values with. Default: ``None``,
+            replacing positive infinity with the maximum value supported by the data type of `input`.
+        neginf (number, optional): the value to replace negative infinity values with. Default: ``None``,
+            replacing negative infinity with the minimum value supported by the data type of `input`.
+
+    Returns:
+        Tensor, has the same shape and dtype as the `input`.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([float('nan'), float('inf'), -float('inf'), 5.0]), mindspore.float32)
+        >>> output = ops.nan_to_num(input, 1.0, 2.0, 3.0)
+        >>> print(output)
+        [1.  2.  3.  5.0]
+    """
+    return nan_to_num_impl(input, nan, posinf, neginf)
+
+
 def neg(input):
     r"""
     Returns a tensor with negative values of the input tensor element-wise.
@@ -3971,101 +5472,46 @@ def ones(shape, dtype=None):
     return ones_op(shape, dtype)
 
 
-def paged_attention_mask(query, key_cache, value_cache, block_tables, context_lens, alibi_mask, head_num, scale_value, kv_head_num):
+def outer_ext(input, vec2):
     r"""
-    The PagedAttentionMask is the fusion of block-wise KV Cache access and self-attention(with alibi-mask) computing.
-
-    Args:
-        query (Tensor): The query tensor with data type of float16.
-          :math:`(num\_tokens, num\_head, head\_dim)`.
-        key_cache (Tensor): The cache tensor with data type of float16.
-          :math:`(num\_blocks, block\_size, num\_head, head\_dim)`.
-        value_cache (Tensor): The cache tensor with data type of float16.
-          :math:`(num\_blocks, block\_size, num\_head, head\_dim)`.
-        block_tables (Tensor): The block mapping table with data type of int32.
-          :math:`(num\_tokens, max_num_blocks_per_batch)`.
-        context_lens (Tensor): The context length of each sequence with data type of int32.
-          :math:`(num\_tokens,)`.
-        alibi_mask (Tensor): The context length of each sequence with data type of float16.
-          :math:`(num\_tokens, num\_head, 1, max\_context\_len)`.
-                    
-    Outputs:
-        attention output.
+    Return outer product of `input` and `vec2`. If `input` is a vector of size :math:`n`
+    and `vec2` is a vector of size :math:`m` , then output must be a matrix of shape :math:`(n, m)` .
 
-    Notes:
-        No backend implementation in MindSpore, only use to export MindIr and run in MindSpore Lite.
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
-    Examples:
-        >>> from mindspore.ops.operations import _inner_ops
-        >>> num_tokens =  = 4
-        >>> num_head = 40
-        >>> num_kv_head = 40
-        >>> head_dim = 128
-        >>> block_size = 16
-        >>> num_blocks = 128
-        >>> max_seq = 1024
-        >>> max_num_blocks_per_batch = max_seq // block_size
-        >>> scale_value = 1.0 / math.sqrt(head_dim)
-        >>> query = Tensor(np.random.randn(num_tokens, num_head, head_dim).astype(np.float16))
-        >>> key_cache = Parameter(default_input=Tensor(np.random.randn(num_blocks, block_size, num_head, head_dim).astype(np.float16)))
-        >>> value_cache = Parameter(default_input=Tensor(np.random.randn(num_blocks, block_size, num_head, head_dim).astype(np.float16)))
-        >>> dummy_block_indice = np.random.shuffle(np.arange(num_tokens * max_num_blocks_per_batch, dtype=np.int32))
-        >>> block_tables = Tensor(np.reshape(dummy_block_indice, (num_tokens, max_num_blocks_per_batch)))
-        >>> context_lens = Tensor(np.random.randint(max_seq, size=num_tokens).astype(np.int32)))
-        >>> alibi_mask = Tensor(np.random.randn(num_tokens, num_head, 1, max_seq).astype(np.int32)))
-        >>> paged_attention_mask = _inner_ops.PagedAttentionMask()
-        >>> output = paged_attention_mask(query, key_cache, value_cache, block_tables, context_lens, alibi_mask)
-        >>> print(output)
-    """
-    paged_attention_mask_op = _get_cache_prim(PagedAttentionMask)(head_num, scale_value, kv_head_num)
-    return paged_attention_mask_op(query, key_cache, value_cache, block_tables, context_lens, alibi_mask)
+    .. note::
+        This function does not broadcast.
 
+    Args:
+        input (Tensor): 1-D input vector.
+        vec2 (Tensor): 1-D input vector.
 
-def paged_attention(query, key_cache, value_cache, block_tables, context_lens, head_num, scale_value, kv_head_num):
-    r"""
-    The PagedAttention is the fusion of block-wise KV Cache access and self-attention computing.
+    Returns:
+        out, 2-D matrix, the outer product of two vectors.
 
-    Args:
-        query (Tensor): The query tensor with data type of float16.
-          :math:`(num\_tokens, num\_head, head\_dim)`.
-        key_cache (Tensor): The cache tensor with data type of float16.
-          :math:`(num\_blocks, block\_size, num\_head, head\_dim)`.
-        value_cache (Tensor): The cache tensor with data type of float16.
-          :math:`(num\_blocks, block\_size, num\_head, head\_dim)`.
-        block_tables (Tensor): The block mapping table with data type of int32.
-          :math:`(num\_tokens, max_num_blocks_per_batch)`.
-        context_lens (Tensor): The context length of each sequence with data type of int32.
-          :math:`(num\_tokens,)`.
-                    
-    Outputs:
-        attention output.
+    Raises:
+        TypeError: If `input` or `vec2` is not a Tensor.
+        TypeError: The implicitly converted data types of `input` and `vec2` are not one of float16, float32, float64, bool, uint8, int8, int16, int32, int64, complex64, complex128, bfloat16
+        ValueError: If the dimension of `input` or `vec2` is not equal to 1.
 
-    Notes:
-        No backend implementation in MindSpore, only use to export MindIr and run in MindSpore Lite.
+    Supported Platforms:
+        ``Ascend``
 
     Examples:
-        >>> from mindspore.ops.operations import _inner_ops
-        >>> num_tokens =  = 4
-        >>> num_head = 40
-        >>> num_kv_head = 40
-        >>> head_dim = 128
-        >>> block_size = 16
-        >>> num_blocks = 128
-        >>> max_seq = 1024
-        >>> max_num_blocks_per_batch = max_seq // block_size
-        >>> scale_value = 1.0 / math.sqrt(head_dim)
-        >>> query = Tensor(np.random.randn(num_tokens, num_head, head_dim).astype(np.float16))
-        >>> key_cache = Parameter(default_input=Tensor(np.random.randn(num_blocks, block_size, num_head, head_dim).astype(np.float16)))
-        >>> value_cache = Parameter(default_input=Tensor(np.random.randn(num_blocks, block_size, num_head, head_dim).astype(np.float16)))
-        >>> dummy_block_indice = np.random.shuffle(np.arange(num_tokens * max_num_blocks_per_batch, dtype=np.int32))
-        >>> block_tables = Tensor(np.reshape(dummy_block_indice, (num_tokens, max_num_blocks_per_batch)))
-        >>> context_lens = Tensor(np.random.randint(max_seq, size=num_tokens).astype(np.int32)))
-        >>> paged_attention = _inner_ops.PagedAttention()
-        >>> output = paged_attention(query, key_cache, value_cache, block_tables, context_lens)
-        >>> print(output)
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor
+        >>> from mindspore import ops
+        >>> input = Tensor(np.array([7, 8, 9]), mindspore.int32)
+        >>> vec2 = Tensor(np.array([7, 10, 11]), mindspore.int32)
+        >>> out = ops.outer(input, vec2)
+        >>> print(out)
+        [[49 70 77]
+         [56 80 88]
+         [63 90 99]]
     """
-    paged_attention_op = _get_cache_prim(PagedAttention)(head_num, scale_value, kv_head_num)
-    return paged_attention_op(query, key_cache, value_cache, block_tables, context_lens)
+    return outer_op(input, vec2)
 
 
 def pow(input, exponent):
@@ -4080,11 +5526,11 @@ def pow(input, exponent):
 
     Args:
         input (Union[Tensor, Number]): The first input is a Number or a tensor whose data type is
-            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         exponent (Union[Tensor, Number]): The second input is a Number or a tensor whose data type is
-            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
 
     Returns:
         Tensor, the shape is the same as the one after broadcasting,
@@ -4112,7 +5558,7 @@ def pow(input, exponent):
     return pow_op(input, exponent)
 
 
-def prelu(x, weight):
+def prelu(input, weight):
     r"""
     Parametric Rectified Linear Unit activation function.
 
@@ -4124,30 +5570,26 @@ def prelu(x, weight):
 
     where :math:`x_i` is an element of a channel of the input, `w` is the weight of the channel.
 
-    Note:
-        Scalar or 1-D Tensor is not supported on Ascend.
-
     PReLU Activation Function Graph:
 
-    .. image:: ../images/PReLU.png
+    .. image:: ../images/PReLU2.png
         :align: center
 
+    .. note::
+        Channel dim is the 2nd dim of input. When input has dims < 2, then there is
+        no channel dim and the number of channels = 1.
+
     Args:
-        x (Tensor): The input Tensor of the activation function. The data type is float16 or float32.
-            The shape is :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
-        weight (Tensor):  Weight Tensor. The data type is float16 or float32.
-            The weight can only be a Tensor, and the length is the same as the number of channels C of the `input_x`.
-            On GPU devices, when the input is a scalar, the shape is :math:`(1,)` .
+        input (Tensor): The input Tensor of the activation function.
+        weight (Tensor):  Weight Tensor. The size of the weight should be 1 or the number of channels at Tensor `input`.
 
     Returns:
-        Tensor, with the same shape and dtype as `x`.
-        For detailed information, please refer to :class:`mindspore.nn.PReLU`.
+        Tensor, with the same shape and dtype as `input`.
+        For detailed information, please refer to :class:`mindspore.mint.nn.PReLU`.
 
     Raises:
-        TypeError: If dtype of `x` or `weight` is neither float16 nor float32.
-        TypeError: If the `x` or the `weight` is not a Tensor.
-        ValueError: If the `x` is a 0-D or 1-D Tensor on Ascend.
-        ValueError: If the `weight` is not a 1-D Tensor.
+        TypeError: If the `input` or the `weight` is not a Tensor.
+        ValueError: If the `weight` is not a 0-D or 1-D Tensor.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -4167,7 +5609,7 @@ def prelu(x, weight):
           [ 2.00  3.00]
           [ 4.0   5.00]]]
     """
-    return prelu_op(x, weight)
+    return prelu_op(input, weight)
 
 
 def prod_ext(input, axis=None, keep_dims=False, dtype=None):
@@ -4315,7 +5757,10 @@ def randperm(n, seed=0, offset=0, dtype=mstype.int64):
     that a given type can represent.
 
     .. warning::
-        This is an experimental API that is subject to change or deletion.
+        - This is an experimental API that is subject to change or deletion.
+        - The Ascend backend does not support the reproducibility of random numbers, so
+          the `seed` parameter has no effect.
+
 
     Args:
         n (Union[Tensor, int]): The input n Tensor with shape: () or (1,) and with data type of int64.
@@ -4697,6 +6142,63 @@ def flip(input, axis):
     return reverse_v2_impl(input, axis)
 
 
+def rfft2(input, s=None, dim=(-2, -1), norm=None):
+    r"""
+    Calculates the two dimensional discrete Fourier transform for real input `input`.
+
+    Note:
+        - `rfft2` is currently only used in `mindscience` scientific computing scenarios and
+          dose not support other usage scenarios.
+        - `rfft2` is not supported on Windows platform yet.
+
+    Args:
+        input (Tensor): The input tensor.
+            Supported dtypes:
+
+            - Ascend/CPU: int16, int32, int64, float16, float32, float64.
+
+        s (tuple[int], optional): Length of the transformed `dim` of the result.
+            If given, the size of the `dim[i]` axis will be zero-padded or truncated to `s[i]` before calculating `rfft2`.
+            Default: ``None`` , which does not need to process `input`.
+        dim (tuple[int], optional): The dimension along which to take the one dimensional `rfft2`.
+            Default: ``(-2, -1)`` , which means transform the last two dimension of `input`.
+        norm (str, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
+            Three modes are defined as, where :math: `n = prod(s)`
+
+            - ``"backward"`` (no normalization).
+            - ``"forward"`` (normalize by :math:`1/n`).
+            - ``"ortho"`` (normalize by :math:`1/\sqrt{n}`).
+
+    Returns:
+        Tensor, The result of `rfft2()` function, result.shape[dim[i]] is s[i], and for the last transformed dim, 
+        result.shape[dim[-1]] is :math:`s[-1] // 2 + 1`.
+        When the input is int16, int32, int64, float16, float32, the return value type is complex64.
+        When the input is float64, the return value type is complex128.
+
+    Raises:
+        TypeError: If the `input` type is not Tensor.
+        TypeError: If the `input` data type is not one of: int32, int64, float32, float64.
+        TypeError: If the type/dtype of `s` and `dim` is not int.
+        ValueError: If `dim` is not in the range of "[ `-input.ndim` , `input.ndim` )".
+        ValueError: If `dim` has duplicate values.
+        ValueError: If `s` is less than 1.
+        ValueError: If `norm` is none of ``"backward"`` , ``"forward"`` or ``"ortho"`` .
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> input = ops.ones((2, 2))
+        >>> ops.rfft2(input, s=(2, 2), dim=(0, 1), norm="backward")
+        Tensor(shape=[2, 2], dtype=Complex64, value=
+        [[4+0j, 0+0j],
+         [0+0j, 0+0j]])
+    """
+    return rfft2_op(input, s, dim, norm)
+
+
 def rfft(input, n=None, dim=-1, norm=None):
     r"""
     Calculates the one dimensional discrete Fourier transform for real input `input`.
@@ -4739,20 +6241,117 @@ def rfft(input, n=None, dim=-1, norm=None):
         >>> import mindspore
         >>> from mindspore import Tensor, ops
         >>> input = Tensor([1, 2, 3, 4])
-        >>> y = ops.rfft(input)
+        >>> y = ops.rfft(input, n=4, dim=-1, norm='backward')
         >>> print(y)
         [10.+0.j -2.+2.j -2.+0.j]
     """
     return rfft_op(input, n, dim, norm)
 
 
+def rfftfreq(n, d=1.0, dtype=None):
+    r"""
+    Computes the sample frequencies for `rfft` with a signal of size `n`.
+    For instance, Given a length `n` and a sample spacing `d` , the returned result `f` is:
+
+    .. math::
+        f = [0, 1, ..., n // 2] / (d * n)
+
+    Note:
+        - `rfftfreq` is currently only used in `mindscience` scientific computing scenarios and
+          dose not support other usage scenarios.
+        - `rfftfreq` is not supported on Windows platform yet.
+
+    Args:
+        n (int): Window length.
+        d (float, optional): Sample spacing (inverse of the sampling rate). Default: ``1.0`` .
+        dtype (mindspore.dtype, optional): The dtype of the returned frequencies. Default: ``None`` represents float32.
+
+    Returns:
+        Tensor, Array of length ``n`` containing the sample frequencies.
+
+    Raises:
+        ValueError: If `n` is less than 1.
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import ops
+        >>> out = ops.rfftfreq(n=4, d=1.0)
+        >>> print(out)
+        [0.   0.25 0.5 ]
+    """
+    return rfftfreq_op(n, d, dtype)
+
+
+def rfftn(input, s=None, dim=None, norm=None):
+    r"""
+    Computes the N dimensional discrete Fourier transform for real input `input`.
+
+    Note:
+        - `rfftn` is currently only used in `mindscience` scientific computing scenarios and
+          dose not support other usage scenarios.
+        - `rfftn` is not supported on Windows platform yet.
+
+    Args:
+        input (Tensor): The input tensor.
+            Supported dtypes:
+
+            - Ascend/CPU: int16, int32, int64, float16, float32, float64.
+
+        s (tuple[int], optional): Length of the transformed `dim` of the result.
+            If given, the size of the `dim[i]` axis will be zero-padded or truncated to `s[i]` before calculating `rfftn`.
+            Default: ``None`` , which does not need to process `input`.
+        dim (tuple[int], optional): The dimension along which to take the one dimensional `rfftn`.
+            Default: ``None`` , which means transform the all dimension of `input`, or the last `len(s)` dimensions if s is given.
+        norm (str, optional): Normalization mode. Default: ``None`` that means ``"backward"`` .
+            Three modes are defined as, where :math: `n = prod(s)`
+
+            - ``"backward"`` (no normalization).
+            - ``"forward"`` (normalize by :math:`1/n`).
+            - ``"ortho"`` (normalize by :math:`1/\sqrt{n}`).
+
+    Returns:
+        Tensor, The result of `rfftn()` function, result.shape[dim[i]] is s[i], and for the last transformed dim, 
+        result.shape[dim[-1]] is :math:`s[-1] // 2 + 1`.
+        When the input is int16, int32, int64, float16, float32 the return value type is complex64.
+        When the input is float64, the return value type is complex128.
+
+    Raises:
+        TypeError: If the `input` type is not Tensor.
+        TypeError: If the `input` data type is not one of: int32, int64, float32, float64.
+        TypeError: If the type/dtype of `s` and `dim` is not int.
+        ValueError: If `dim` is not in the range of "[ `-input.ndim` , `input.ndim` )".
+        ValueError: If `dim` has duplicate values.
+        ValueError: If `s` is less than 1.
+        ValueError: If `s` and `dim` are given but have different shapes.
+        ValueError: If `norm` is none of ``"backward"`` , ``"forward"`` or ``"ortho"`` .
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> input = ops.ones((2, 2, 2))
+        >>> ops.rfftn(input, s=(2, 2, 2), dim=(0, 1, 2), norm="backward")
+        Tensor(shape=[2, 2, 2], dtype=Complex64, value=
+        [[[8+0j, 0+0j],
+          [0+0j, 0+0j]],
+         [[0+0j, 0+0j],
+          [0+0j, 0+0j]]])
+    """
+    return rfftn_op(input, s, dim, norm)
+
+
 def rms_norm(x, gamma, epsilon=1e-6):
     r"""
     The RmsNorm(Root Mean Square Layer Normalization) operator is a normalization operation. Compared to
     LayerNorm, it retains scaling invariance and removes translation invariance. Its formula is:
 
     .. math::
-        y=\frac{x_i}{\sqrt{\frac{1}{n}}\sum_{i=1}^{n}{ x_i^2}+\varepsilon  }\gamma_i
+        y=\frac{x_i}{\sqrt{\frac{1}{n}\sum_{i=1}^{n}{ x_i^2}+\varepsilon}}\gamma_i
 
     .. warning::
         This is an experimental API that is subject to change or deletion. This API is only supported in Atlas A2
@@ -4795,36 +6394,83 @@ def rms_norm(x, gamma, epsilon=1e-6):
     return rms_norm_impl(x, gamma, epsilon)
 
 
-def round(input):
+def rotary_position_embedding(x, cos, sin, mode=0):
     r"""
-    Returns half to even of a tensor element-wise.
-
-    .. math::
+    Implements the Rotary Position Embedding algorithm.
+    Refer to paper `Enhanced Transformer with Rotary Position Embedding <https://arxiv.org/pdf/2104.09864.pdf>`_.
 
-        out_i \approx input_i
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
     Args:
-        input (Tensor): The input tensor.
+        x (Tensor): 4D tensor, with float16, bfloat16 or float32 data type.
+        cos (Tensor): 4D tensor, has the same type as `x` , in range of [-1, 1].
+        sin (Tensor): Same with `cos` .
+        mode (int): An optional attribute. Used to select a calculation mode. 0: rotate_half(GPT-NeoX style); 1: rotate_interleaved(GPT-J style). Defaults to ``0`` .
+
+    .. list-table:: Config layout constraints
+        :widths: 5 20 20
+        :header-rows: 1
+
+        * - Args
+          - RotateHalf(mode:0)
+          - RotateInterleaved(mode:1)
+        * - x
+          - Supported layout:
+
+            11SD, B1SD, BNSD; D < 896 and D is an Even. B, N < 1000;
+
+            B * N <= 1024 if gradient calculation of cos/sin is used.
+          - Supported layout: 11SD, B1SD, BNSD;
+
+            D < 896 and D is an Even.
+
+            B, N < 1000;
+        * - cos
+          - Support layout for different values of `x`:
+
+            `x` is BNSD: 11SD, B1SD, BNSD;
+
+            `x` is BSND: 1S1D, BS1D, BSND;
+
+            `x` is SBND: S11D, SB1D, SBND
+          - Support layout for different values of `x`:
+
+            `x` is BNSD: 11SD;
+
+            `x` is BSND: 1S1D;
+
+            `x` is SBND: S11D
+        * - sin
+          - Same with `cos` .
+          - Same with `cos` .
+
+    .. note::
+        When the layout is BNSD, B * N > 8S and D is 32-bytes alignment, the performance is poor. Therefore, this interface cannot be called.
 
     Returns:
-        Tensor, has the same shape and type as the `input`.
+        Tensor, has the same dtype and shape as the `x`.
 
     Raises:
-        TypeError: If `input` is not a Tensor.
+        TypeError: If `x` is not a Tensor.
+        TypeError: If `cos` is not a Tensor.
+        TypeError: If `sin` is not a Tensor.
+        TypeError: If `mode` is not an int.
 
     Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
+        ``Ascend``
 
     Examples:
-        >>> import mindspore
         >>> import numpy as np
         >>> from mindspore import Tensor, ops
-        >>> input = Tensor(np.array([0.8, 1.5, 2.3, 2.5, -4.5]), mindspore.float32)
-        >>> output = ops.round(input)
-        >>> print(output)
-        [ 1.  2.  2.  2. -4.]
+        >>> x = Tensor(np.random.uniform(-2, 2, (4, 8192, 4, 128)))
+        >>> cos = Tensor(np.random.uniform(-1, 1, (1, 8192, 1, 128)))
+        >>> sin = Tensor(np.random.uniform(-1, 1, (1, 8192, 1, 128)))
+        >>> output = ops.rotary_position_embedding(x, cos, sin, 0)
+        >>> print(output.shape)
+        (4, 8192, 4, 128)
     """
-    return round_op(input)
+    return rotary_position_embedding_op(x, cos, sin, mode)
 
 
 def rsqrt(input):
@@ -4850,7 +6496,7 @@ def rsqrt(input):
 
     Examples:
         >>> import mindspore as ms
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> input = ms.Tensor([-0.0370,  0.2970,  1.5420, -0.9105])
         >>> output = ops.rsqrt(input)
         >>> print(output)
@@ -4999,7 +6645,41 @@ def scatter_nd(indices, updates, shape):
          [0. 1.1 0.]
          [0. 0.  0.]]
     """
-    return scatter_nd_op(indices, updates, shape)
+    return scatter_nd_op(indices, updates, shape)
+
+
+def select_ext(input, dim, index):
+    r"""
+    Slices the input tensor along the selected dimension at the given index.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): the input tensor.
+        dim (int): the dimension to slice.
+        index (int): the index to select with.
+
+    Returns:
+        Tensor.
+
+    Raises:
+        TypeError: If input is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, mint
+        >>> input = Tensor([[2, 3, 4, 5],[3, 2, 4, 5]])
+        >>> y = mint.select(input, 0, 0)
+        >>> y = Tensor([1,2], mindspore.float32)
+        >>> print(y)
+        [2 3 4 5]
+        
+    """
+    return select_ext_op(input, dim, index)
 
 
 def select(condition, input, other):
@@ -5021,12 +6701,12 @@ def select(condition, input, other):
             The shape is :math:`(x_1, x_2, ..., x_N, ..., x_R)`.
         input (Union[Tensor, int, float]): The first Tensor to be selected.
             If input is a Tensor, its shape should be or be braodcast to :math:`(x_1, x_2, ..., x_N, ..., x_R)`.
-            If input is int or float, it will be casted to int32 or float32, and broadcast to the same shape as y.
-            There must be at least one Tensor between x and y.
+            If input is int or float, it will be casted to int32 or float32, and broadcast to the same shape as other.
+            There must be at least one Tensor between input and other.
         other (Union[Tensor, int, float]): The second Tensor to be selected.
             If other is a Tensor, its shape should be or be braodcast to :math:`(x_1, x_2, ..., x_N, ..., x_R)`.
-            If other is int or float, it will be casted to int32 or float32, and broadcast to the same shape as y.
-            There must be at least one Tensor between x and y.
+            If other is int or float, it will be casted to int32 or float32, and broadcast to the same shape as input.
+            There must be at least one Tensor between input and other.
 
     Returns:
         Tensor, has the same shape as `condition`.
@@ -5053,6 +6733,70 @@ def select(condition, input, other):
     return select_op(condition, input, other)
 
 
+def select_v2(condition, input, other):
+    r"""
+    
+    """
+    return select_v2_op(condition, input, other)
+
+
+def selu_ext(input):
+    r"""
+    Activation function SELU (Scaled exponential Linear Unit).
+
+    The activation function is defined as:
+
+    .. math::
+        E_{i} =
+        scale *
+        \begin{cases}
+        x_{i}, &\text{if } x_{i} \geq 0; \cr
+        \text{alpha} * (\exp(x_i) - 1), &\text{otherwise.}
+        \end{cases}
+
+    where :math:`alpha` and :math:`scale` are pre-defined constants(:math:`alpha=1.67326324`
+    and :math:`scale=1.05070098`).
+
+    See more details in `Self-Normalizing Neural Networks <https://arxiv.org/abs/1706.02515>`_.
+
+    SELU Activation Function Graph:
+
+    .. image:: ../images/SeLU.png
+        :align: center
+
+    Args:
+        input (Tensor): Tensor of any dimension.
+            The data type is float16, float32, bfloat16.
+
+    Returns:
+        Tensor, with the same type and shape as the `input`.
+
+    Raises:
+        TypeError: If dtype of `input` is not float16, float32, bfloat16.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, mint
+        >>> import numpy as np
+        >>> input = Tensor(np.array([[-1.0, 4.0, -8.0], [2.0, -5.0, 9.0]]), mindspore.float32)
+        >>> output = mint.nn.functional.selu(input)
+        >>> print(output)
+        [[-1.1113307 4.202804 -1.7575096]
+        [ 2.101402 -1.7462534 9.456309 ]]
+    """
+    return selu_ext_op(input)
+
+
+def selu_grad(gradient, result):
+    r"""
+    
+    """
+    return selu_grad_op(gradient, result)
+
+
 def sequence_concat(x, axis=0):
     r"""
     Support sequence Concat operation.
@@ -5079,6 +6823,14 @@ def sequence_concat(x, axis=0):
     return sequence_concat_op(x)
 
 
+def shard_identity(input):
+    r"""
+    A intermediate operator only be created when using mindspore.shard or
+    cell.shard during parallel procedure. Will not be exposed to the users.
+    """
+    return shard_identity_op(input)
+
+
 def sigmoid(input):
     r"""
     Computes Sigmoid of input element-wise. The Sigmoid function is defined as:
@@ -5122,7 +6874,7 @@ def sigmoid(input):
 
 def sign(input):
     r"""
-    Returns an element-wise indication of the sign of a number. Notice: When the input dtype is float64, the gradient of this operator is NaN.
+    Returns an element-wise indication of the sign of a number. Notice: When the input is NaN and dtype is float64, the output of this operator is NaN.
 
     .. math::
         \text{out}_{i} = \begin{cases}
@@ -5285,12 +7037,20 @@ def sinh(input):
 
     Args:
         input (Tensor): The input tensor of hyperbolic sine function.
+            Supported dtypes: 
+
+            - GPU/CPU: float16, float32, float64, complex64 or complex128.
+            - Ascend: bool, int8, uint8, int16, int32, int64, float16, float32, float64, complex64, complex128 or bfloat16.
 
     Returns:
-        Tensor, has the same shape as `input`.
+        Tensor, has the same shape as the `input`. 
+        The dtype of output is float32 when dtype of `input` is in
+        [bool, int8, uint8, int16, int32, int64]. Otherwise output has the same dtype as the `input`.
 
-    Raises:
-        TypeError: If `input` is not a Tensor.
+    :raise TypeError: If `input` is not a Tensor.
+    :raise TypeError:
+        * CPU/GPU: If dtype of `input` is not float16, float32 or float64, complex64, complex128.
+        * Ascend: If dtype of `input` is not bool, int8, uint8, int16, int32, int64, float16, float32, float64, complex64, complex128 or bfloat16.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -5349,6 +7109,88 @@ def softplus_ext(input, beta=1, threshold=20):
     return softplus_ext_op(input, beta, threshold)
 
 
+def softshrink_grad(input_grad, input_x, lambd=0.5):
+    r"""
+    Computes gradients for SoftShrinkGrad operation.
+
+    Args:
+        input_grad (Tensor): the gradients of loss to output of SoftShrink function. Supported dtypes:
+
+            - Ascend: float16, float32, bfloat16.
+            - CPU/GPU: float16, float32.
+        input_x (Tensor): Must be the input `input` of the forward operator SoftSHrink. Supported dtypes:
+
+            - Ascend: float16, float32, bfloat16.
+            - CPU/GPU: float16, float32.
+        lambd (float): the lambda value for the Softshrink formulation. Default: ``0.5`` .
+
+    Returns:
+        backprops, a Tensor with the same shape and data type as `input_x`.
+
+    Rasise:
+        ValueError: If `lambd` is not a float.
+        ValueError: If shape of `input_grad` is not the same as `input_x`.
+        TypeError: If dtype of `input_grad` is not the same as `input_x`.
+        TypeError: If dtype of `input_grad` or `input_x` is not float16, float32 or bfloat16.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+    """
+    return softshrink_grad_impl(input_grad, input_x, lambd)
+
+
+def softshrink(input, lambd=0.5):
+    r"""
+    Soft Shrink activation function. Calculates the output according to the input elements.
+
+    The formula is defined as follows:
+
+    .. math::
+        \text{SoftShrink}(x) =
+        \begin{cases}
+        x - \lambda, & \text{ if } x > \lambda \\
+        x + \lambda, & \text{ if } x < -\lambda \\
+        0, & \text{ otherwise }
+        \end{cases}
+
+    SoftShrink Activation Function Graph:
+
+    .. image:: ../images/Softshrink.png
+        :align: center
+
+    Args:
+        input (Tensor): The input of Soft Shrink. Supported dtypes: 
+
+            - Ascend: float16, float32, bfloat16.
+            - CPU/GPU: float16, float32.
+        lambd (number, optional): The threshold :math:`\lambda` defined by the Soft Shrink formula.
+            It should be greater than or equal to 0, default: ``0.5`` .
+
+    Returns:
+        Tensor, has the same data type and shape as the input `input`.
+
+    Raises:
+        TypeError: If `lambd` is not a float, int or bool.
+        TypeError: If `input` is not a tensor.
+        TypeError: If dtype of `input` is not float16, float32 or bfloat16.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor
+        >>> from mindspore import ops
+        >>> import numpy as np
+        >>> x = Tensor(np.array([[ 0.5297,  0.7871,  1.1754], [ 0.7836,  0.6218, -1.1542]]), mindspore.float32)
+        >>> output = ops.softshrink(x)
+        >>> print(output)
+        [[ 0.02979  0.287    0.676  ]
+        [ 0.2837   0.1216  -0.6543 ]]
+    """
+    return softshrink_impl(input, lambd)
+
+
 def solve_triangular(a, b, trans=0, lower=False, unit_diagonal=False):
     r"""
     Solve the linear system :math:`a x = b` for `x`, Assuming `a` is a triangular matrix.
@@ -5694,12 +7536,12 @@ def sub_ext(input, other, alpha=1):
     Args:
         input (Union[Tensor, number.Number, bool]): The first input is a number.Number or
             a bool or a tensor whose data type is
-            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         other (Union[Tensor, number.Number, bool]): The second input, is a number.Number or
             a bool or a tensor whose data type is
-            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         alpha (number.Number): A scaling factor applied to `other`, default 1.
 
     Returns:
@@ -5751,8 +7593,8 @@ def sub(input, other):
     Args:
         input (Union[Tensor, number.Number, bool]): The first input is a number.Number or
             a bool or a tensor whose data type is
-            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         other (Union[Tensor, number.Number, bool]): The second input, when the first input is a Tensor,
             the second input should be a number.Number or bool value, or a Tensor whose data type is number or bool.
 
@@ -5779,6 +7621,83 @@ def sub(input, other):
     return sub_op(input, other)
 
 
+def swiglu_grad(grad_output, input, dim=-1):
+    r"""
+    
+    """
+    return swiglu_grad_op(grad_output, input, dim)
+
+
+def swiglu(input, dim=-1):
+    r"""
+    Computes SwiGLU (Swish-Gated Linear Unit activation function) of input tensor.
+    SwiGLU is a variant of the :class:`mindspore.ops.GLU` activation function, it is defined as:
+
+    .. math::
+        {SwiGLU}(a, b)= Swish(a) \otimes b
+
+    where :math:`a` is the first half of the `input` matrices and :math:`b` is the second half,
+    Swish(a)=a :math:`\sigma` (a), :math:`\sigma` is the :func:`mindspore.ops.sigmoid` activation function
+    and :math:`\otimes` is the Hadamard product.
+
+    Args:
+        input (Tensor): Tensor to be split. It has shape :math:`(\ast_1, N, \ast_2)`
+            where `*` means, any number of additional dimensions. :math:`N` must be divisible by 2.
+        dim (int, optional): the axis to split the input. It must be int. Default: ``-1`` , the last axis of `input`.
+
+    Returns:
+        Tensor, the same dtype as the `input`, with the shape :math:`(\ast_1, M, \ast_2)` where :math:`M=N/2`.
+
+    Raises:
+        TypeError: If dtype of `input` is not float16, float32 or bfloat16.
+        TypeError: If `input` is not a Tensor.
+        RuntimeError: If the dimension specified by `dim` is not divisible by 2.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor([[-0.12, 0.123, 31.122], [2.1223, 4.1212121217, 0.3123]], dtype=mindspore.float32)
+        >>> output = ops.swiglu(input, 0)
+        >>> print(output)
+        [[-0.11970687 0.2690224 9.7194 ]]
+    """
+    return swiglu_op(input, dim)
+
+
+def tan(input):
+    r"""
+    Computes tangent of `input` element-wise.
+
+    .. math::
+
+        out_i = \tan(input_i)
+
+    Args:
+        input (Tensor): The input Tensor, valid for any dimensions.
+
+    Returns:
+        Tensor, has the same shape as `input`. The dtype of output is float32 when dtype of `input` is in [bool, int8, uint8, int16, int32, int64]. Otherwise output has the same dtype as `input`.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([-1.0, 0.0, 1.0]), mindspore.float32)
+        >>> output = ops.tan(input)
+        >>> print(output)
+        [-1.5574077 0. 1.5574077]
+    """
+    return tan_op(input)
+
+
 def tanh(input):
     r"""
     Computes hyperbolic tangent of input element-wise. The Tanh function is defined as:
@@ -5818,6 +7737,14 @@ def tanh(input):
     return tanh_op(input)
 
 
+def tensor_scatter_elements(data, indices, updates, axis=0, reduce='none'):
+    r"""
+    
+    """
+    tensor_scatter_elements_op = _get_cache_prim(TensorScatterElements)(axis, reduce)
+    return tensor_scatter_elements_op(data, indices, updates)
+
+
 def topk_ext(input, k, dim=-1, largest=True, sorted=True):
     r"""
     Finds values and indices of the `k` largest or smallest entries along a given dimension.
@@ -5891,7 +7818,7 @@ def topk_ext(input, k, dim=-1, largest=True, sorted=True):
     return topk_ext_op(input, k, dim, largest, sorted)
 
 
-def topkrouter(input, capacity, expert_num):
+def topkrouter(input, capacity, expert_num, drop_type=0):
     r"""
     TopkRouter implementation in MOE.
 
@@ -5899,6 +7826,7 @@ def topkrouter(input, capacity, expert_num):
         - **x** (Tensor) - Input Tensor of 3D, Supporting types:[int32, int64]
         - **capacity** (Int64) - The maximum number of tokens each expert can handle
         - **expert_num** (Int64) - The number of expert.
+        - **drop_type** (Int64) - S-Drop/K-Drop, 0 means S-Drop, 1 means K-Drop, default 0.
 
     Outputs:
         tuple(Tensor), tuple of 2 tensors, `dispatch_index` and `combine_inex`.
@@ -5908,7 +7836,48 @@ def topkrouter(input, capacity, expert_num):
     Supported Platforms:
         ``Ascend``
     """
-    return topkrouter_op(input, capacity, expert_num)
+    return topkrouter_op(input, capacity, expert_num, drop_type)
+
+
+def trace_ext(input):
+    r"""
+    Returns a new tensor that is the sum of the `input` main trace.
+
+    Note:
+        Input must be tensor.
+
+    Args:
+        input (Tensor): 2-D Tensor.
+
+    Returns:
+        Tensor, when the data type of `input` is integer or bool, its data type is int64, otherwise it is the same as `input`, and size equals to 1.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        ValueError: If the dimension of `input` is not equal to 2.
+        TypeError:  If the dtype of `input` is not one of float16, float32, float64, bool, uint8, int8, int16, int32, int64, complex64, complex128, bfloat16.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([[10, 11, 12], [13, 14, 15], [16, 17, 18]]), mindspore.float32)
+        >>> output = ops.trace_ext(input)
+        >>> print(output)
+        42.0
+        >>> input = Tensor(np.arange(1, 13).reshape(3, 4), mindspore.float32)
+        >>> output = ops.trace_ext(input)
+        >>> print(output)
+        18.0
+        >>> input = Tensor(np.arange(12, 0, -1).reshape(4, 3), mindspore.float32)
+        >>> output = ops.trace_ext(input)
+        >>> print(output)
+        24.0
+    """
+    return trace_ext_op(input)
 
 
 def trace(input):
@@ -5951,6 +7920,41 @@ def trace(input):
     return trace_op(input)
 
 
+def transpose_ext(input, dim0, dim1):
+    r"""
+    Interchange two axes of a tensor.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input(Tensor): Input tensor.
+        dim0 (int): First axis.
+        dim1 (int): Second axis.
+
+    Returns:
+        Transposed tensor, has the same data type as `input`.
+
+    Raises:
+        TypeError: If argument `input` is not Tensor.
+        TypeError: If `dim0` or `dim1` is not integer.
+        ValueError: If `dim0` or `dim1` is not in the range of :math:`[-ndim, ndim-1]`.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import mint
+        >>> from mindspore import Tensor
+        >>> input = Tensor(np.ones((2,3,4), dtype=np.float32))
+        >>> output = mint.transpose(input, 0, 2)
+        >>> print(output.shape)
+        (4, 3, 2)
+    """
+    return transpose_ext_op(input, dim0, dim1)
+
+
 def transpose(input, input_perm):
     r"""
     Permutes the dimensions of the input tensor according to input permutation.
@@ -6002,9 +8006,16 @@ def transpose(input, input_perm):
     return transpose_op(input, input_perm)
 
 
+def tril_ext(input, diagonal=0):
+    r"""
+    
+    """
+    return tril_ext_impl(input, diagonal)
+
+
 def triu(input, diagonal=0):
     r"""
-    Returns the upper triangle part of 'input' (elements that contain the diagonal and below),
+    Returns the upper triangle part of `input` (elements that contain the diagonal and below),
     and set the other elements to zeros.
 
     .. warning::
@@ -6016,7 +8027,7 @@ def triu(input, diagonal=0):
             indicating the main diagonal.
 
     Returns:
-        Tensor, a tensor has the same shape and data type as input.
+        Tensor, a tensor has the same shape and data type as `input`.
 
     Raises:
         TypeError: If `diagonal` is not an int.
@@ -6063,6 +8074,34 @@ def triu(input, diagonal=0):
     return triu_impl(input, diagonal)
 
 
+def trunc(input):
+    r"""
+    Returns a new tensor with the truncated integer values of the elements of the input tensor.
+
+    Args:
+        input (Tensor): The input tensor.
+
+    Returns:
+        Tensor, the same shape and data type as the input.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor(np.array([3.4742, 0.5466, -0.8008, -3.9079]),mindspore.float32)
+        >>> output = ops.trunc(x)
+        >>> print(output)
+        [3. 0. 0. -3.]
+    """
+    return trunc_op(input)
+
+
 def tuple_to_tensor(input_tuple, dtype=None):
     r"""
     
@@ -6429,11 +8468,11 @@ def moe_finalize_routing(expanded_x, x1, x2=None, bias=None, scales=None, expand
     return moe_finalize_routing_op(expanded_x, x1, x2, bias, scales, expanded_row_idx, expanded_expert_idx)
 
 
-def quant_batch_matmul(x1, x2, scale, offset=None, bias=None, transpose_x1=False, transpose_x2=False, dtype=mstype.float16):
+def quant_batch_matmul(x1, x2, scale, offset=None, bias=None, pertokenScaleOptional=None, transpose_x1=False, transpose_x2=False, dtype=mstype.float16):
     r"""
     
     """
-    return quant_batch_matmul_impl(x1, x2, scale, offset, bias, transpose_x1, transpose_x2, dtype)
+    return quant_batch_matmul_impl(x1, x2, scale, offset, bias, pertokenScaleOptional, transpose_x1, transpose_x2, dtype)
 
 
 def weight_quant_batch_matmul(x, weight, antiquant_scale, antiquant_offset=None, quant_scale=None, quant_offset=None, bias=None, transpose_x=False, transpose_weight=False, antiquant_group_size=0):