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

mindspore/ops/auto_generate/gen_ops_def.py

@@ -150,7 +150,7 @@ def add_ext(input, other, alpha=1):
         alpha (number.Number): A scaling factor applied to `other`, default 1.
 
     Returns:
-        Tensor with a shape that is the same as the broadcasted shape of the input `input` and `other`,
+        Tensor, the shape is the same as the one of the input `input`, `other` after broadcasting,
         and the data type is the one with higher precision or higher digits among the two inputs and alpha.
 
     Raises:
@@ -165,11 +165,11 @@ def add_ext(input, other, alpha=1):
         >>> import numpy as np
         >>> import mindspore
         >>> from mindspore import Tensor
-        >>> from mindspore import ops
+        >>> from mindspore.ops.extend import add
         >>> x = Tensor(1, mindspore.int32)
         >>> y = Tensor(np.array([4, 5, 6]).astype(np.float32))
         >>> alpha = 0.5
-        >>> output = ops.auto_generate.add_ext(x, y, alpha)
+        >>> output = add(x, y, alpha)
         >>> print(output)
         [3. 3.5 4.]
         >>> # the data type of x is int32, the data type of y is float32,
@@ -208,7 +208,7 @@ def add(input, other):
             `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
 
     Returns:
-        Tensor with a shape that is the same as the broadcasted shape of the input `input` and `other`,
+        Tensor, the shape is the same as the one of the input `input` , `other` after broadcasting,
         and the data type is the one with higher precision or higher digits among the two inputs.
 
     Raises:
@@ -241,13 +241,6 @@ def add(input, other):
     return add_op(input, other)
 
 
-def addmm(input, mat1, mat2, beta, alpha):
-    r"""
-    
-    """
-    return addmm_op(input, mat1, mat2, beta, alpha)
-
-
 def addn(x):
     r"""
     Computes addition of all input tensors element-wise.
@@ -320,7 +313,7 @@ def apply_rotary_pos_emb_(query, key, cos, sin, position_ids, cos_format=0):
     return apply_rotary_pos_emb_op(query, key, cos, sin, position_ids)
 
 
-def argmax_ext(input, dim=None, keepdim=False):
+def argmax(input, dim=None, keepdim=False):
     r"""
     Return the indices of the maximum values of a tensor across a dimension.
 
@@ -339,14 +332,13 @@ def argmax_ext(input, dim=None, keepdim=False):
         ValueError: If `dim` is out of range.
 
     Supported Platforms:
-        ``Ascend``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> import numpy as np
-        >>> from mindspore import Tensor
-        >>> from mindspore import ops
+        >>> from mindspore import Tensor, ops
         >>> x = Tensor(np.array([[1, 20, 5], [67, 8, 9], [130, 24, 15]]).astype(np.float32))
-        >>> output = ops.auto_generate.argmax_ext(x, dim=-1)
+        >>> output = ops.argmax(x, dim=-1)
         >>> print(output)
         [1 0 0]
     """
@@ -504,47 +496,6 @@ def assign(variable, value):
     return assign_op(variable, value)
 
 
-def atan2_ext(input, other):
-    r"""
-    Returns arctangent of input/other element-wise.
-
-    It returns :math:`\theta\ \in\ [-\pi, \pi]`
-    such that :math:`input = r*\sin(\theta), other = r*\cos(\theta)`, where :math:`r = \sqrt{input^2 + other^2}`.
-
-    Note:
-        - Arg `input` and `other` comply with the implicit type conversion rules to make the data types consistent.
-          If they have different data types, the lower precision data type will be converted to relatively the
-          highest precision data type.
-
-    Args:
-        input (Tensor, Number.number): The input tensor or scalar.
-        other (Tensor, Number.number): The input tensor or scalar. It has the same shape with `input` or
-            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`.
-
-    Raises:
-        TypeError: If `input` or `other` is not a Tensor or scalar.
-        RuntimeError: If the data type of `input` and `other` conversion of Parameter is required
-                    when data type conversion of Parameter is not supported.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> input = Tensor(np.array([0, 1]), mindspore.float32)
-        >>> other = Tensor(np.array([1, 1]), mindspore.float32)
-        >>> output = mint.atan2(input, other)
-        >>> print(output)
-        [0.        0.7853982]
-    """
-    return atan2_ext_op(input, other)
-
-
 def atan2(input, other):
     r"""
     Returns arctangent of input/other element-wise.
@@ -664,19 +615,19 @@ def bmm_ext(input, mat2):
     Performs batch matrix-matrix multiplication of two three-dimensional tensors.
 
     .. math::
-        \text{output}= \text{input} @ \text{mat2}
+        \text{output}[b, i, j] = \text{input}[b, i, k] @ \text{mat2}[b, k, j]
 
     Args:
-        input (Tensor): The first batch of matrices to be multiplied. Must be a three-dimensional tensor of shape `(b, n, m)`.
-        mat2 (Tensor): The second batch of matrices to be multiplied. Must be a three-dimensional tensor of shape `(b, m, p)`.
+        input (Tensor): The first batch of matrices to be multiplied. Must be a three-dimensional tensor.
+        mat2 (Tensor): The second batch of matrices to be multiplied. Must be a three-dimensional tensor.
 
     Returns:
         Tensor, the output tensor of shape `(b, n, p)`, where each matrix is the product of the corresponding matrices in the input batches.
 
     Raises:
-        ValueError: If `input` or `mat2` is not three-dimensional tensors.
+        TypeError: If `input` or `mat2` is not three-dimensional tensors.
         ValueError: If the length of the third dimension of `input` is not equal to the length of the second dimension of `mat2`.
-        ValueError: If the batch size of the inputs is not equal to the batch size of the mat2.
+        ValueError: If the batch size of the inputs do not match.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -685,17 +636,12 @@ def bmm_ext(input, mat2):
         >>> import mindspore
         >>> import numpy as np
         >>> from mindspore import Tensor
-        >>> from mindspore import ops
+        >>> from mindspore.ops.extend import bmm
         >>> a = Tensor(np.ones(shape=[2, 3, 4]), mindspore.float32)
         >>> b = Tensor(np.ones(shape=[2, 4, 5]), mindspore.float32)
-        >>> output = ops.auto_generate.bmm_ext(a, b)
-        >>> print(output)
-        [[[4. 4. 4. 4. 4.]
-          [4. 4. 4. 4. 4.]
-          [4. 4. 4. 4. 4.]]
-         [[4. 4. 4. 4. 4.]
-          [4. 4. 4. 4. 4.]
-          [4. 4. 4. 4. 4.]]]
+        >>> output = bmm(a, b)
+        >>> print(output.shape)
+        (2, 3, 5)
     """
     return bmm_ext_op(input, mat2)
 
@@ -766,13 +712,13 @@ def broadcast_to(input, shape):
         >>> output = ops.broadcast_to(x, shape)
         >>> print(output)
         [[1. 2. 3.]
-         [1. 2. 3.]]
+        [1. 2. 3.]]
         >>> shape = (-1, 2)
         >>> x = Tensor(np.array([[1], [2]]).astype(np.float32))
         >>> output = ops.broadcast_to(x, shape)
         >>> print(output)
         [[1. 1.]
-         [2. 2.]]
+        [2. 2.]]
     """
     return broadcast_to_impl(input, shape)
 
@@ -1020,72 +966,6 @@ def clamp_tensor(input, min=None, max=None):
     return clamp_tensor_op(input, min, max)
 
 
-def fold_ext(input, output_size, kernel_size, dilation=1, padding=0, stride=1):
-    r"""
-    Combines an array of sliding local blocks into a large containing tensor.
-
-    Consider a batched input tensor of shape :math:`(N, C \times \prod(\text{kernel_size}), L)` ,
-    where :math:`N` is the batch dimension, :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{output_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:`d` is over all spatial dimensions.
-
-    Therefore, `output_size` is the spatial shape of the large containing tensor of the sliding local blocks.
-
-    The `dilation`, `padding` and `stride` arguments specify how the sliding blocks are retrieved.
-
-    .. warning::
-        Currently, only unbatched(3D) or batched(4D) image-like output tensors are supported.
-
-    Args:
-        input (Tensor): 2-D or 3-D Tensor.
-        output_size (Union[int, tuple[int], list[int]]): The shape of the spatial dimensions of
-            the output(i.e., output.shape[2:]).
-        kernel_size (Union[int, tuple[int], list[int]]): The size of the kernel, should be two int
-            for height and width. If type is int, it means that height equal with width. Must be specified.
-        dilation (Union[int, tuple[int], list[int]], optional): The size of the dilation, should be two int
-            for height and width. If type is int, it means that height equal with width. Default: ``1`` .
-        padding (Union[int, tuple[int], list[int]], optional): The size of the padding, should be two int
-            for height and width. If type is int, it means that height equal with width. Default: ``0`` .
-        stride (Union[int, tuple[int], list[int]], optional): The size of the stride, should be two int
-            for height and width. If type is int, it means that height equal with width. Default: ``1`` .
-
-    Returns:
-        A Tensor, with same type as `input` .
-
-    Shape:
-        - Input: :math:`(N, C \times \prod(\text{kernel_size}), L)` or
-          :math:`(C \times \prod(\text{kernel_size}), L)`
-        - Output: :math:`(N, C, output\_size[0], output\_size[1], ...)` or
-          :math:`(C, output\_size[0], output\_size[1], ...)`
-
-    Raises:
-        TypeError: If `output_size`, `kernel_size`, `stride`, `dilation`, `padding` data type is not int, tuple or list.
-        ValueError: If `output_size`, `kernel_size`, `dilation`, `stride` value is not
-            greater than zero or elements number invalid.
-        ValueError: If `padding` value is less than zero or elements number invalid.
-        ValueError: If input.shape[-2] can't be divisible by the product of kernel_size.
-        ValueError: If `input.shape[-1]` is not equal to the calculated number of sliding blocks `L`.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> x = Tensor(np.random.rand(16, 64, 25).astype(np.float32))
-        >>> output = ops.auto_generate.fold_ext(x, (8, 8), [2, 2], [2, 2], [2, 2], [2, 2])
-        >>> print(output.shape)
-        (16, 16, 8, 8)
-    """
-    return col2im_ext_op(input, output_size, kernel_size, dilation, padding, stride)
-
-
 def cat(tensors, axis=0):
     r"""
     Connect input tensors along with the given axis.
@@ -1392,54 +1272,6 @@ def cummax(input, axis):
     return cummax_op(input)
 
 
-def cumsum_ext(input, dim, dtype=None):
-    r"""
-    Computes the cumulative sum of input Tensor along `dim`.
-
-    .. math::
-
-        y_i = x_1 + x_2 + x_3 + ... + x_i
-
-    Args:
-        input (Tensor): The input Tensor.
-        dim (int): Dim along which the cumulative sum is computed.
-        dtype (:class:`mindspore.dtype`, optional): The desired dtype of returned Tensor. If specified,
-            the input Tensor will be cast to `dtype` before the computation. This is useful for preventing overflows.
-            If not specified, stay the same as original Tensor. Default: ``None`` .
-
-    Returns:
-        Tensor, the shape of the output Tensor is consistent with the input Tensor's.
-
-    Raises:
-        TypeError: If `input` is not a Tensor.
-        ValueError: If the `dim` is out of range.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import numpy as np
-        >>> from mindspore import Tensor
-        >>> import mindspore.ops as ops
-        >>> x = Tensor(np.array([[3, 4, 6, 10], [1, 6, 7, 9], [4, 3, 8, 7], [1, 3, 7, 9]]).astype(np.float32))
-        >>> # case 1: along the dim 0
-        >>> y = ops.auto_generate.cumsum_ext(x, 0)
-        >>> print(y)
-        [[ 3.  4.  6. 10.]
-        [ 4. 10. 13. 19.]
-        [ 8. 13. 21. 26.]
-        [ 9. 16. 28. 35.]]
-        >>> # case 2: along the dim 1
-        >>> y = ops.auto_generate.cumsum_ext(x, 1)
-        >>> print(y)
-        [[ 3.  7. 13. 23.]
-        [ 1.  7. 14. 23.]
-        [ 4.  7. 15. 22.]
-        [ 1.  4. 11. 20.]]
-    """
-    return cumsum_ext_op(input, dim, dtype)
-
-
 def decoder_k_v_cache(cache, update, valid_seq_len, batch_index, seq_len_axis, new_max_seq_len, cur_max_seq_len):
     r"""
     The DecoderKVCache is used for decoding the KVCache of transformer network.
@@ -1628,56 +1460,6 @@ def dot(input, other):
     return dot_op(input, other)
 
 
-def elu_ext(input, alpha=1.0):
-    r"""
-    Exponential Linear Unit activation function.
-
-    Applies the exponential linear unit function element-wise.
-    The activation function is defined as:
-
-    .. math::
-
-        \text{ELU}(x)= \left\{
-        \begin{array}{align}
-            \alpha(e^{x}  - 1) & \text{if } x \le 0\\
-            x & \text{if } x \gt 0\\
-        \end{array}\right.
-
-    Where :math:`x` is the element of input Tensor `input`, :math:`\alpha` is param `alpha`,
-    it determines the smoothness of ELU.
-
-    ELU function graph:
-
-    .. image:: ../images/ELU.png
-        :align: center
-
-    Args:
-        input (Tensor): The input of ELU is a Tensor of any dimension.
-        alpha (float, optional): The alpha value of ELU, the data type is float.
-            Default: ``1.0`` .
-
-    Returns:
-        Tensor, has the same shape and data type as `input`.
-
-    Raises:
-        TypeError: If `alpha` is not a float.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> x = Tensor(np.array([[-1.0, 4.0, -8.0], [2.0, -5.0, 9.0]]), mindspore.float32)
-        >>> output = ops.auto_generate.elu_ext(x)
-        >>> print(output)
-        [[-0.63212055  4.         -0.99966455]
-         [ 2.         -0.99326205  9.        ]]
-    """
-    return elu_ext_impl(input, alpha)
-
-
 def elu(input_x, alpha=1.0):
     r"""
     Exponential Linear Unit activation function.
@@ -1695,6 +1477,8 @@ def elu(input_x, alpha=1.0):
 
     Where :math:`x` is the element of input Tensor `input_x`, :math:`\alpha` is param `alpha`,
     it determines the smoothness of ELU.
+    The picture about ELU looks like this `ELU <https://en.wikipedia.org/wiki/
+    Activation_function#/media/File:Activation_elu.svg>`_ .
 
     ELU function graph:
 
@@ -1746,7 +1530,6 @@ def equal(input, other):
 
     Note:
         - `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.
         - The shapes of the inputs can be broadcasted to each other.
 
     Args:
@@ -1794,18 +1577,20 @@ def erf(input):
         input (Tensor): The input tensor of Gaussian error function. :math:`x` in the following formula.
             Supported dtypes: 
 
+            - Ascend: float16, float32, int64, bool.
             - GPU/CPU: float16, float32, float64.
-            - Ascend: float16, float32, float64, int64, bool.
 
     Returns:
-        Tensor, has the same shape as the `input`. 
-        The dtype of output is float32 when dtype of `input` is in
-        [bool, int64]. Otherwise output has the same dtype as the `input`.
+        Tensor. If the input is int64 or bool, the return value type is float32.
+        Otherwise, the return value type is the same as the input type.
 
-    :raise TypeError: If `input` is not a Tensor.
-    :raise TypeError:
-            * GPU/CPU: If dtype of `input` is not float16, float32, float64.
-            * Ascend: If dtype of `input` is not float16, float32, float64, int64, bool.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If dtype of `input` is not as follows
+
+            - Ascend: float16, float32, int64, bool.
+            - GPU/CPU: float16, float32, float64.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -1877,8 +1662,7 @@ def erfinv(input):
             - GPU/CPU: float16, float32 or float64.
 
     Returns:
-        Tensor. When the `input` is int8, int16, int32, int64, uint8, bool, the return value type is float32.
-        Otherwise, the return value type is the same as the input type.
+        Tensor, has the same shape and dtype as `input`.
 
     :raise TypeError: If dtype of `input` is not as follows
 
@@ -1895,7 +1679,7 @@ def erfinv(input):
         >>> input = Tensor(np.array([0, 0.5, -0.9]), mindspore.float32)
         >>> output = ops.erfinv(input)
         >>> print(output)
-        [ 0.          0.47693613 -1.1630869 ]
+        [ 0.          0.47695306 -1.1630805 ]
     """
     return erfinv_op(input)
 
@@ -1926,7 +1710,7 @@ def exp(input):
         >>> input = Tensor(np.array([0.0, 1.0, 3.0]), mindspore.float32)
         >>> output = ops.exp(input)
         >>> print(output)
-        [ 1.        2.7182817 20.085537]
+        [ 1.        2.718282 20.085537]
     """
     return exp_op(input)
 
@@ -2456,20 +2240,18 @@ def floor(input):
 
     .. math::
 
-        out_i = \lfloor input_i \rfloor
+        out_i = \lfloor x_i \rfloor
 
     Args:
-        input (Tensor): The input tensor. Its supported data types are:
-        
-            - Ascend: float16, float32, float64, bfloat16, int8, int16, int32, int64, uint8, uint16, uint32, uint64.
-            - GPU/CPU: float16, float32, float64.
+        input (Tensor): The input tensor, :math:`x` in the above formula. Its data type must be float16,
+            float32 or float64.
 
     Returns:
         Tensor, has the same shape as `input`.
 
     Raises:
         TypeError: If `input` is not a Tensor.
-        TypeError: If dtype of `input` is not support.
+        TypeError: If dtype of `input` is not in [float16, float32, float64].
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -2728,8 +2510,8 @@ def greater_equal(input, other):
     Args:
         input (Union[Tensor, Number]): The first input is a number or
             a bool or a tensor whose data type is number or bool.
-        other (Union[Tensor, Number]): When the first input is a Tensor, the second input should be a Number or Tensor with data type number or bool.
-            When the first input is a Scalar, the second input must be a Tensor with data type number or bool.
+        other (Union[Tensor, Number]): The second input is a number
+            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 bool.
@@ -3017,124 +2799,6 @@ def ifftshift(input, dim=None):
     return ifftshift_op(input, dim)
 
 
-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
-    dimensions.
-
-    Therefore, indexing `output` at the last dimension (column dimension)
-    gives all values within a certain block.
-
-    The `dilation`, `padding` and `stride` arguments specify
-    how the sliding blocks are retrieved.
-
-    .. warning::
-        - Currently, batched(4D) image-like tensors are supported.
-        - For Ascend, it is only supported on platforms above Atlas A2.
-
-    Args:
-        input (Tensor): 4-D Tensor.
-        kernel_size (Union[int, tuple[int], list[int]]): The size of the kernel, should be two int
-            for height and width. If type is int, it means that height equal with width. Must be specified.
-        dilation (Union[int, tuple[int], list[int]], optional): The dilation of the window, should be two int
-            for height and width. If type is int, it means that height equal with width. Default: ``1`` .
-        padding (Union[int, tuple[int], list[int]], optional): The pad of the window, should be two int
-            for height and width. If type is int, it means that height equal with width. Default: ``0`` .
-        stride (Union[int, tuple[int], list[int]], optional): The stride of the window, should be two int
-            for height and width. If type is int, it means that height equal with width. Default: ``1`` .
-
-    Returns:
-        A Tensor, with same type as `input` .
-
-    Shape:
-        - Input: :math:`(N, C, *)`
-        - Output: :math:`(N, C \times \prod(\text{kernel_size}), L)`
-
-    Raises:
-        TypeError: If any data type of `kernel_size`, `stride`, `dilation`, `padding` is not int, tuple or list.
-        ValueError: If `kernel_size`, `dilation`, `stride` value is not
-            greater than zero or elements number more than `2`.
-        ValueError: If `padding` value is less than zero.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> x = Tensor(np.random.rand(4, 4, 32, 32), mindspore.float32)
-        >>> output = ops.auto_generate.unfold_ext(x, kernel_size=3, dilation=1, stride=1)
-        >>> print(output.shape)
-        (4, 36, 900)
-    """
-    return im2col_ext_op(input, kernel_size, dilation, padding, stride)
-
-
-def index_select_ext(input, dim, index):
-    r"""
-    Generates a new Tensor that accesses the values of `input` along the specified `dim` dimension
-    using the indices specified in `index`. The new Tensor has the same number of dimensions as `input`,
-    with the size of the `dim` dimension being equal to the length of `index`, and the size of all other
-    dimensions will be unchanged from the original `input` Tensor.
-
-    .. note::
-        The value of index must be in the range of `[0, input.shape[dim])`, the result is undefined out of range.
-
-    Args:
-        input (Tensor): The input Tensor.
-        dim (int): The dimension to be indexed.
-        index (Tensor): A 1-D Tensor with the indices.
-
-    Returns:
-        Tensor, has the same dtype as input Tensor.
-
-    Raises:
-        TypeError: If `input` or `index` is not a Tensor.
-        TypeError: If `dim` is not int number.
-        ValueError: If the value of `dim` is out the range of `[-input.ndim, input.ndim - 1]`.
-        ValueError: If the dimension of `index` is not equal to 1.
-
-    Supported Platforms:
-        ``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 irfft(input, n=None, dim=-1, norm=None):
     r"""
     Calculates the inverse of `rfft()`.
@@ -3233,9 +2897,9 @@ def leaky_relu_ext(input, negative_slope=0.01):
 
     .. math::
         \text{leaky_relu}(input) = \begin{cases}input, &\text{if } input \geq 0; \cr
-        \text{negative_slope} * input, &\text{otherwise.}\end{cases}
+        {\negative_slope} * input, &\text{otherwise.}\end{cases}
 
-    where :math:`negative\_slope` represents the `negative_slope` parameter.
+    where :math:`\negative_slope` represents the `negative_slope` parameter.
 
     For more details, see `Rectifier Nonlinearities Improve Neural Network Acoustic Models
     <https://ai.stanford.edu/~amaas/papers/relu_hybrid_icml2013_final.pdf>`_.
@@ -3258,14 +2922,14 @@ def leaky_relu_ext(input, negative_slope=0.01):
         TypeError: If `negative_slope` is not a float or an int.
 
     Supported Platforms:
-        ``Ascend``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> import mindspore
         >>> import numpy as np
         >>> from mindspore import Tensor, ops
         >>> input = Tensor(np.array([[-1.0, 4.0, -8.0], [2.0, -5.0, 9.0]]), mindspore.float32)
-        >>> print(ops.extend.leaky_relu_ext(input, negative_slope=0.2))
+        >>> print(mint.leaky_relu(input, negative_slope=0.2))
         [[-0.2  4.  -1.6]
          [ 2.  -1.   9. ]]
     """
@@ -3297,7 +2961,7 @@ def less_equal(input, other):
         Tensor, the shape is the same as the one after broadcasting, and the data type is bool.
 
     Raises:
-        TypeError: If neither `input` nor `other` is a Tensor, number.Number or bool.
+        TypeError: If neither `input` nor `other` is a Tensor or number.Number.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -3549,36 +3213,6 @@ def matrix_exp(input):
     return matrix_exp_op(input)
 
 
-def matrix_inverse_ext(input):
-    r"""
-    Compute the inverse of the input matrix.
-
-    Args:
-        input (Tensor): A matrix to be calculated. Input `input` must be at least two dimensions, and the size of
-            the last two dimensions must be the same size.
-
-    Returns:
-        Tensor, has the same type and shape as input`.
-
-    Raises:
-        TypeError: If `input` is not a Tensor.
-        ValueError: If the size of the last two dimensions of `input` is not the same.
-        ValueError: If the dimension of `input` is 1.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> from mindspore import Tensor, ops
-        >>> from mindspore import dtype as mstype
-        >>> x = Tensor([[1., 2.], [3., 4.]], mstype.float32)
-        >>> print(ops.matrix_inverse_ext(x))
-        [[-2.   1. ]
-         [ 1.5 -0.5]]
-    """
-    return matrix_inverse_ext_op(input)
-
-
 def max_(input):
     r"""
     Calculates the maximum value of the input tensor.
@@ -3595,7 +3229,6 @@ def maximum(input, other):
     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,
@@ -3791,6 +3424,13 @@ def minimum(input, other):
     return minimum_op(input, other)
 
 
+def moe_finalize_routing(expanded_x, x1, x2=None, bias=None, scales=None, expanded_row_idx=None, expanded_expert_idx=None):
+    r"""
+    
+    """
+    return moe_finalize_routing_op(expanded_x, x1, x2, bias, scales, expanded_row_idx, expanded_expert_idx)
+
+
 def mul(input, other):
     r"""
     Multiplies two tensors element-wise.
@@ -3926,22 +3566,62 @@ def nextafter(input, other):
     return next_after_op(input, other)
 
 
-def not_equal(input, other):
+def nonzero(input):
     r"""
-    Alias for :func:`mindspore.ops.ne` .
+    Return a Tensor of the positions of all non-zero values.
 
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-    """
-    return not_equal_op(input, other)
+    Args:
+        input (Tensor): The input Tensor, its rank should be greater than or eaqual to 1.
 
-ones_op=Ones()
+    Returns:
+        Tensor, a 2-D Tensor whose data type is int64, containing the positions of all non-zero values of the input.
 
-def ones(shape, dtype=None):
-    r"""
-    Creates a tensor filled with value ones, whose shape and type are described by the first argument `size` and second argument `dtype` respectively.
+    Raises:
+        TypeError: If `input` is not Tensor.
+        ValueError: If dim of `input` equals to 0.
 
-    .. warning::
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor
+        >>> import mindspore.ops as ops
+        >>> x = Tensor(np.array([[[1,  0], [-5, 0]]]), mindspore.int32)
+        >>> output = ops.nonzero(x)
+        >>> print(output)
+        [[0 0 0]
+         [0 1 0]]
+        >>> x = Tensor(np.array([1, 0, 2, 0, 3]), mindspore.int32)
+        >>> output = ops.nonzero(x)
+        >>> print(output)
+        [[0]
+         [2]
+         [4]]
+    """
+    return non_zero_op(input)
+
+
+def not_equal(input, other):
+    r"""
+    Alias for :func:`mindspore.ops.ne` .
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+    """
+    return not_equal_op(input, other)
+
+ones_op=Ones()
+
+def ones(shape, dtype=None):
+    r"""
+    Creates a tensor filled with value ones.
+
+    Creates a tensor with shape described by the first argument and fills it with value ones in type of the second
+    argument.
+
+    .. warning::
         For argument `shape`, Tensor type input will be deprecated in the future version.
 
     Args:
@@ -4170,84 +3850,6 @@ def prelu(x, weight):
     return prelu_op(x, weight)
 
 
-def prod_ext(input, axis=None, keep_dims=False, dtype=None):
-    r"""
-    Reduces a dimension of a tensor by multiplying all elements in the dimension, by default. And also can
-    reduce a dimension of `input` along the `axis`. Determine whether the dimensions of the output and input are the
-    same by controlling `keep_dims`.
-
-    Args:
-        input (Tensor[Number]): The input tensor. The dtype of the tensor to be reduced is number.
-            :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
-        axis (int): The dimensions to reduce. Default: ``None`` , reduce all dimensions.
-            Only constant value is allowed. Assume the rank of `input` is r, and the value range is [-r,r).
-        keep_dims (bool): If ``True`` , keep these reduced dimensions and the length is 1.
-            If ``False`` , don't keep these dimensions. Default: ``False`` .
-        dtype (:class:`mindspore.dtype`): The desired data type of returned Tensor. Default: ``None`` .
-
-    Returns:
-        Tensor, has the same data type as input tensor.
-
-        - If `axis` is ``None`` , and `keep_dims` is  ``False`` ,
-          the output is a 0-D tensor representing the product of all elements in the input tensor.
-        - If `axis` is int, set as 1, and `keep_dims` is  ``False`` ,
-          the shape of output is :math:`(input_0, input_2, ..., input_R)`.
-
-    Raises:
-        TypeError: If `input` is not a Tensor.
-        TypeError: If `axis` is not one of the following: int or None.
-        TypeError: If `keep_dims` is not a bool.
-        ValueError: If `axis` is out of range.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> x = Tensor(np.random.randn(3, 4, 5, 6).astype(np.float32))
-        >>> output = ops.ProdExt()(x, 1, keep_dims=True)
-        >>> result = output.shape
-        >>> print(result)
-        (3, 1, 5, 6)
-        >>> # case 1: Reduces a dimension by multiplying all elements in the dimension.
-        >>> x = Tensor(np.array([[[1, 1, 1, 1, 1, 1], [2, 2, 2, 2, 2, 2], [3, 3, 3, 3, 3, 3]],
-        ...                      [[4, 4, 4, 4, 4, 4], [5, 5, 5, 5, 5, 5], [6, 6, 6, 6, 6, 6]],
-        ...                      [[7, 7, 7, 7, 7, 7], [8, 8, 8, 8, 8, 8], [9, 9, 9, 9, 9, 9]]]), mindspore.float32)
-        >>> output = ops.ProdExt()(x)
-        >>> print(output)
-        2.2833798e+33
-        >>> print(output.shape)
-        ()
-        >>> # case 2: Reduces a dimension along axis 0.
-        >>> output = ops.ProdExt()(x, 0, True)
-        >>> print(output)
-        [[[ 28.  28.  28.  28.  28.  28.]
-        [ 80.  80.  80.  80.  80.  80.]
-        [162. 162. 162. 162. 162. 162.]]]
-        >>> # case 3: Reduces a dimension along axis 1.
-        >>> output = ops.ProdExt()(x, 1, True)
-        >>> print(output)
-        [[[  6.   6.   6.   6.   6.   6.]]
-        [[120. 120. 120. 120. 120. 120.]]
-        [[504. 504. 504. 504. 504. 504.]]]
-        >>> # case 4: Reduces a dimension along axis 2.
-        >>> output = ops.ProdExt()(x, 2, True)
-        >>> print(output)
-        [[[1.00000e+00]
-        [6.40000e+01]
-        [7.29000e+02]]
-        [[4.09600e+03]
-        [1.56250e+04]
-        [4.66560e+04]]
-        [[1.17649e+05]
-        [2.62144e+05]
-        [5.31441e+05]]]
-    """
-    return prod_ext_op(input, axis, keep_dims, dtype)
-
-
 def prompt_k_v_cache(cache, update, valid_seq_len, batch_index, seq_len_axis, new_max_seq_len, cur_max_seq_len, align_mode='LEFT'):
     r"""
     The PromptKVCache is used for prefill the KVCache of transformer network.
@@ -4307,6 +3909,13 @@ def prompt_k_v_cache(cache, update, valid_seq_len, batch_index, seq_len_axis, ne
     return prompt_k_v_cache_op(cache, update, valid_seq_len, batch_index, seq_len_axis, new_max_seq_len, cur_max_seq_len)
 
 
+def quant_batch_matmul(x1, x2, scale, offset=None, bias=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)
+
+
 def randperm(n, seed=0, offset=0, dtype=mstype.int64):
     r"""
     Generates random permutation of integers from 0 to n-1.
@@ -4572,6 +4181,13 @@ def relu(input):
     return relu_op(input)
 
 
+def repeat_interleave(input, repeats, axis=None, output_size=None):
+    r"""
+    
+    """
+    return repeat_interleave_op(input, repeats, axis, output_size)
+
+
 def reshape_and_cache(key, value, key_cache, value_cache, slot_mapping):
     r"""
     The ReshapeAndCache is used for updating the block-wise KVCache of transformer network.
@@ -4746,55 +4362,6 @@ def rfft(input, n=None, dim=-1, norm=None):
     return rfft_op(input, n, 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
-
-    .. warning::
-        This is an experimental API that is subject to change or deletion. This API is only supported in Atlas A2
-        training series for now.
-
-    Args:
-        x (Tensor): Input data of RmsNorm. Support data type: float16, float32, bfloat16.
-        gamma (Tensor): Learnable parameter :math:`\gamma` . Support data type: float16, float32, bfloat16.
-        epsilon (float, optional): A float number ranged in (0, 1] to prevent division by 0. Default value is `1e-6`.
-
-    Returns:
-        - Tensor, denotes the normalized result, has the same type and shape as `x`.
-        - Tensor, with the float data type, denotes the reciprocal of the input standard deviation, used by gradient
-          calculation.
-
-    Raises:
-        TypeError: If data type of `x` is not one of the following: float16, float32, bfloat16.
-        TypeError: If data type of `gamma` is not one of the following: float16, float32, bfloat16.
-        TypeError: If data type of `x` is not the same with the data type of `gamma`.
-        ValueError: If `epsilon` is not a float between 0 and 1.
-        ValueError: If the rank of `gamma` is lagger than the rank of `x`.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> x = Tensor(np.array([[1, 2, 3], [1, 2, 3]]), mindspore.float32)
-        >>> gamma = Tensor(np.ones([3]), mindspore.float32)
-        >>> y, rstd = ops.rms_norm(x, gamma)
-        >>> print(y)
-        [[0.46290997  0.92581993  1.3887299]
-         [0.46290997  0.92581993  1.3887299]]
-        >>> print(rstd)
-        [[0.46290997]
-         [0.46290997]]
-    """
-    return rms_norm_impl(x, gamma, epsilon)
-
-
 def round(input):
     r"""
     Returns half to even of a tensor element-wise.
@@ -4854,7 +4421,7 @@ def rsqrt(input):
         >>> input = ms.Tensor([-0.0370,  0.2970,  1.5420, -0.9105])
         >>> output = ops.rsqrt(input)
         >>> print(output)
-        [       nan 1.8349396  0.8053002        nan]
+        [       nan 1.8349396  0.80530024        nan]
     """
     return rsqrt_op(input)
 
@@ -5120,47 +4687,6 @@ def sigmoid(input):
     return sigmoid_op(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.
-
-    .. math::
-        \text{out}_{i} = \begin{cases}
-                          -1 & \text{input}_{i} < 0 \\
-                           0 & \text{input}_{i} = 0 \\
-                           1 & \text{input}_{i} > 0
-                         \end{cases}
-
-    Args:
-        input (Tensor): Input Tensor.
-
-    Returns:
-        Tensor, the sign of input.
-
-    Raises:
-        TypeError: If `input` is not a Tensor.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore as ms
-        >>> import mindspore.ops as ops
-        >>> input = ms.Tensor([[-1, 0, 2, 4, 6], [2, 3, 5, -6, 0]])
-        >>> output = ops.sign(input)
-        >>> print(output)
-        [[-1  0  1  1  1]
-         [ 1  1  1 -1  0]]
-        >>> ms.set_context(device_target="CPU")
-        >>> x = ms.Tensor([[-1, 0, float('inf'), 4, float('nan')], [2, 3, float('-inf'), -6, 0]])
-        >>> output = ops.sign(x)
-        >>> print(output)
-        [[-1.  0.  1.  1.  0.]
-         [ 1.  1. -1. -1.  0.]]
-    """
-    return sign_op(input)
-
-
 def silu(input):
     r"""
     Computes Sigmoid Linear Unit of input element-wise. The SiLU function is defined as:
@@ -5222,10 +4748,10 @@ def sin(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`.
 
-    :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 type of `input` is not bool, int8, uint8, int16, int32, int64, float16, float32 or float64, complex64, complex128.
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: On CPU or GPU: If dtype of `input` is not float16, float32 or float64, complex64, complex128.
+                   On Ascend: If type of `input` is not bool, int8, uint8, int16, int32, int64, float16, float32 or float64, complex64, complex128.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -5237,7 +4763,7 @@ def sin(input):
         >>> input = Tensor(np.array([0.62, 0.28, 0.43, 0.62]), mindspore.float32)
         >>> output = ops.sin(input)
         >>> print(output)
-        [0.58103514 0.27635565 0.4168708 0.58103514]
+        [0.5810352 0.27635565 0.41687083 0.5810352]
     """
     return sin_op(input)
 
@@ -5309,42 +4835,7 @@ def sinh(input):
 
 def softplus_ext(input, beta=1, threshold=20):
     r"""
-    Applies softplus function to `input` element-wise.
-
-    The softplus function is shown as follows, x is the element of `input` :
-
-    .. math::
-
-        \text{output} = \frac{1}{beta}\log(1 + \exp(\text{beta * x}))
-
-    where :math:`input * beta > threshold`, the implementation converts to the linear function to ensure numerical stability.
-
-    Args:
-        input (Tensor): Tensor of any dimension. Supported dtypes: 
-
-            - Ascend: float16, float32, bfloat16.
-        beta (number.Number, optional): Scaling parameters in the softplus function. Default: ``1`` .
-        threshold (number.Number, optional): For numerical stability, the softplus function is converted 
-            to a threshold parameter of a linear function. Default: ``20`` .
-
-    Returns:
-        Tensor, with the same type and shape as the input.
-
-    Raises:
-        TypeError: If `input` is not a Tensor.
-        TypeError: If dtype of `input` is not float16, float32, bfloat16.
-
-    Supported Platforms:
-        ``Ascend`` 
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> input = Tensor(np.array([0.1, 0.2, 30, 25]), mindspore.float32)
-        >>> output = ops.auto_generate.softplus_ext(input)
-        >>> print(output)
-        [0.74439657 0.7981388 30. 25.]
+    
     """
     return softplus_ext_op(input, beta, threshold)
 
@@ -5406,13 +4897,6 @@ def solve_triangular(a, b, trans=0, lower=False, unit_diagonal=False):
     return solve_triangular_op(a, b, trans, lower, unit_diagonal)
 
 
-def sort_ext(input, dim=-1, descending=False, stable=False):
-    r"""
-    
-    """
-    return sort_ext_op(input, dim, descending, stable)
-
-
 def sqrt(x):
     r"""
     Returns sqrt of a tensor element-wise.
@@ -5496,22 +4980,23 @@ def stack_ext(tensors, dim=0):
 
     Raises:
         TypeError: If the data types of elements in `tensors` are not the same.
-        ValueError: If `dim` is out of the range [-(R+1), R+1);
+        ValueError: If the length of `tensors` is not greater than zero;
+                    or if dim is out of the range [-(R+1), R+1);
                     or if the shapes of elements in tensors are not the same.
 
     Supported Platforms:
-        ``Ascend``
+        ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> import mindspore
-        >>> from mindspore import Tensor, ops
+        >>> from mindspore import Tensor, mint
         >>> import numpy as np
         >>> data1 = Tensor(np.array([0, 1]).astype(np.float32))
         >>> data2 = Tensor(np.array([2, 3]).astype(np.float32))
-        >>> output = ops.auto_generate.stack_ext([data1, data2], 0)
+        >>> output = mint.stack([data1, data2], 0)
         >>> print(output)
         [[0. 1.]
-         [2. 3.]]
+            [2. 3.]]
     """
     return stack_ext_impl(tensors, dim)
 
@@ -5703,7 +5188,7 @@ def sub_ext(input, other, alpha=1):
         alpha (number.Number): A scaling factor applied to `other`, default 1.
 
     Returns:
-        Tensor with a shape that is the same as the broadcasted shape of the input `input` and `other`,
+        Tensor, the shape is the same as the one of the input `input`, `other` after broadcasting,
         and the data type is the one with higher precision or higher digits among the two inputs and alpha.
 
     Raises:
@@ -5718,11 +5203,11 @@ def sub_ext(input, other, alpha=1):
         >>> import numpy as np
         >>> import mindspore
         >>> from mindspore import Tensor
-        >>> from mindspore import ops
+        >>> from mindspore.ops.extend import sub
         >>> x = Tensor(np.array([4, 5, 6]).astype(np.float32))
         >>> y = Tensor(1, mindspore.int32)
         >>> alpha = 0.5
-        >>> output = ops.auto_generate.sub_ext(x, y, alpha)
+        >>> output = sub(x, y, alpha)
         >>> print(output)
         [3.5 4.5 5.5]
         >>> # the data type of x is float32, the data type of y is int32,
@@ -5757,7 +5242,7 @@ def sub(input, other):
             the second input should be a number.Number or bool value, or a Tensor whose data type is number or bool.
 
     Returns:
-        Tensor with a shape that is the same as the broadcasted shape of the input `input` and `other`,
+        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:
@@ -5820,97 +5305,11 @@ def tanh(input):
 
 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.
-
-    .. warning::
-        - If sorted is set to False, due to different memory layout and traversal methods on different platforms,
-          the display order of calculation results may be inconsistent when `sorted` is False.
-
-    If the `input` is a one-dimensional Tensor, finds the `k` largest  or smallest entries in the Tensor,
-    and outputs its value and index as a Tensor. values[`k`] is the `k` largest item in `input`,
-    and its index is indices [`k`].
-
-    For a multi-dimensional matrix,
-    calculates the first or last `k` entries in a given dimension, therefore:
-
-    .. math::
-
-        values.shape = indices.shape
-
-    If the two compared elements are the same, the one with the smaller index value is returned first.
-
-    Args:
-        input (Tensor): Input to be computed.
-        k (int): The number of top or bottom elements to be computed along the last dimension.
-        dim (int, optional): The dimension to sort along. Default: ``-1`` .
-        largest (bool, optional): If largest is ``False``  then the k smallest elements are returned.
-            Default: ``True`` .
-        sorted (bool, optional): If ``True`` , the obtained elements will be sorted by the values in descending
-            order or ascending order according to `largest`. If ``False`` , the obtained elements will not be
-            sorted. Default: ``True`` .
-
-    Returns:
-        A tuple consisting of `values` and `indices`.
-
-        - values (Tensor) - The `k` largest or smallest elements in each slice of the given dimension.
-        - indices (Tensor) - The indices of values within the last dimension of input.
-
-    Raises:
-        TypeError: If `sorted` is not a bool.
-        TypeError: If `input` is not a Tensor.
-        TypeError: If `k` is not an int.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import mindspore as ms
-        >>> from mindspore import ops
-        >>> x = ms.Tensor([[0.5368, 0.2447, 0.4302, 0.9673],
-        ...                [0.4388, 0.6525, 0.4685, 0.1868],
-        ...                [0.3563, 0.5152, 0.9675, 0.8230]], dtype=ms.float32)
-        >>> output = ops.topk_ext(x, 2, dim=1)
-        >>> print(output)
-        (Tensor(shape=[3, 2], dtype=Float32, value=
-        [[ 9.67299998e-01,  5.36800027e-01],
-         [ 6.52499974e-01,  4.68499988e-01],
-         [ 9.67499971e-01,  8.23000014e-01]]), Tensor(shape=[3, 2], dtype=Int32, value=
-        [[3, 0],
-         [1, 2],
-         [2, 3]]))
-        >>> output2 = ops.topk_ext(x, 2, dim=1, largest=False)
-        >>> print(output2)
-        (Tensor(shape=[3, 2], dtype=Float32, value=
-        [[ 2.44700000e-01,  4.30200011e-01],
-         [ 1.86800003e-01,  4.38800007e-01],
-         [ 3.56299996e-01,  5.15200019e-01]]), Tensor(shape=[3, 2], dtype=Int32, value=
-        [[1, 2],
-         [3, 0],
-         [0, 1]]))
+    
     """
     return topk_ext_op(input, k, dim, largest, sorted)
 
 
-def topkrouter(input, capacity, expert_num):
-    r"""
-    TopkRouter implementation in MOE.
-
-    Inputs:
-        - **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.
-
-    Outputs:
-        tuple(Tensor), tuple of 2 tensors, `dispatch_index` and `combine_inex`.
-        - dispatch_index (Tensor) - Token ID processed by each expert.
-        - combine_index (Tensor) - The combine index of each token.
-
-    Supported Platforms:
-        ``Ascend``
-    """
-    return topkrouter_op(input, capacity, expert_num)
-
-
 def trace(input):
     r"""
     Returns a new tensor that is the sum of the `input` main trace.
@@ -6002,6 +5401,66 @@ def transpose(input, input_perm):
     return transpose_op(input, input_perm)
 
 
+def tril(input, diagonal=0):
+    r"""
+    Returns the lower triangle part of 'input' (elements that contain the diagonal and below),
+    and set the other elements to zeros.
+
+    Args:
+        input (Tensor): A Tensor with shape :math:`(x_1, x_2, ..., x_R)`. The rank must be at least 2.
+          Supporting all number types including bool.
+        diagonal (int, optional): An optional attribute indicates the diagonal to consider, default: 0,
+            indicating the main diagonal.
+
+    Returns:
+        Tensor, the same shape and data type as the input `x`.
+
+    Raises:
+        TypeError: If `x` is not a Tensor.
+        TypeError: If `diagonal` is not an int.
+        TypeError: If the type of `x` is neither number nor bool.
+        ValueError: If the rank of `x` is less than 2.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor(np.array([[ 1,  2,  3,  4],
+        ...                      [ 5,  6,  7,  8],
+        ...                      [10, 11, 12, 13],
+        ...                      [14, 15, 16, 17]]))
+        >>> result = ops.tril(x)
+        >>> print(result)
+        [[ 1  0  0  0]
+         [ 5  6  0  0]
+         [10 11 12  0]
+         [14 15 16 17]]
+        >>> x = Tensor(np.array([[ 1,  2,  3,  4],
+        ...                      [ 5,  6,  7,  8],
+        ...                      [10, 11, 12, 13],
+        ...                      [14, 15, 16, 17]]))
+        >>> result = ops.tril(x, diagonal=1)
+        >>> print(result)
+        [[ 1  2  0  0]
+         [ 5  6  7  0]
+         [10 11 12 13]
+         [14 15 16 17]]
+        >>> x = Tensor(np.array([[ 1,  2,  3,  4],
+        ...                      [ 5,  6,  7,  8],
+        ...                      [10, 11, 12, 13],
+        ...                      [14, 15, 16, 17]]))
+        >>> result = ops.tril(x, diagonal=-1)
+        >>> print(result)
+        [[ 0  0  0  0]
+         [ 5  0  0  0]
+         [10 11  0  0]
+         [14 15 16  0]]
+    """
+    return tril_impl(input, diagonal)
+
+
 def triu(input, diagonal=0):
     r"""
     Returns the upper triangle part of 'input' (elements that contain the diagonal and below),
@@ -6151,11 +5610,18 @@ def view(input, shape):
     """
     return view_op(input, shape)
 
+
+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):
+    r"""
+    
+    """
+    return weight_quant_batch_matmul_impl(x, weight, antiquant_scale, antiquant_offset, quant_scale, quant_offset, bias, transpose_x, transpose_weight, antiquant_group_size)
+
 zeros_op=Zeros()
 
 def zeros(size, dtype=None):
     r"""
-    Creates a tensor filled with value zeros, whose shape and type are described by the first argument `size` and second argument `dtype` respectively.
+    Creates a tensor filled with 0 with shape described by `size` and fills it with value 0 in type of `dtype`.
 
     .. warning::
         For argument `size`, Tensor type input will be deprecated in the future version.
@@ -6185,259 +5651,3 @@ def zeros(size, dtype=None):
          [0. 0.]]
     """
     return zeros_op(size, dtype)
-
-
-def grouped_matmul(x, weight, bias=None, scale=None, offset=None, antiquant_scale=None, antiquant_offset=None, group_list=None, split_item=0, group_type=-1):
-    r"""
-    Group calculation matmul.
-
-    ** Non-Quant: **
-
-    .. math::
-            y_i = x_i\times weight_i + bias_i
-
-    ** Antiquant-Quant: **
-
-    .. math::
-            y_i = x_i\times (weight_i + antiquant\_offset_i) * antiquant\_scale_i + bias_i
-
-    Args:
-        split_item (int): Splitting input mode. Only support 0 and 3. 0 represents multiple Tensors, and 3 represents a single Tensor.
-        group_type (int): The axis to be split. Only support -1 and 0. If the matrix is multiplied by A[m,k]xB[k,n]=C[m,n].
-                          -1: No grouping, 0: Group on the m-axis
-
-    Inputs:
-        x (TensorList): TensorList, including 2D-6D Tensors. Supported dtypes: Float16, Float32.
-                        The shape of the tensor in tensorlist is :math:`(M, N)` or :math:`(..., M, N)`.
-        weight (TensorList): TensorList, include 2D-3D Tensors. Supported dtypes: Float16, Float32, int8.
-                             The shape of the tensor in tensorlist is :math:`(N, K)` or :math:`(E, N, K)`.
-        bias (TensorList, optional): TensorList, include 1D-2D Tensors. Supported dtypes: Float16, Float32. If not used, None.
-                                     Length is the same as the weight length. The shape of the tensor is :math:`(N)` or :math:`(E, N)`.
-        scale (TensorList, optional): TensorList, scale factor of quant(A8W8) parameters. Supported dtypes: Unit64.
-                                      Length is the same as the weight length. Currently not supported, use None.
-        offset (TensorList, optional): TensorList, offset of quant(A8W8) parameters. Supported dtypes: Float32.
-                                       Length is the same as the weight length. Currently not supported, use None.
-        antiquant_scale (TensorList, optional): TensorList, scale factor of antiquant(A16W8) parameters. Supported dtypes: Float16.
-                                                Length is the same as the weight length. Only use in antiquant. If not used, None.
-        antiquant_offset (TensorList, optional): TensorList, offset factor of antiquant(A16W8) parameters. Supported dtypes: Float16.
-                                                 Length is the same as the weight length.  Only use in antiquant. If not used, None.
-        group_list (Tensor, optional): Grouping positions for the M-axis of input x. Supported dtypes: Int64
-
-
-        Parameter limitations 1
-        =========== ============ =========== ====================================================================================================
-        split_item  group_type   group_list  notes
-        =========== ============ =========== ====================================================================================================
-        0           -1           None        The length of x is n, tensor in x must be 2D-6D. The length of weight is n, tensor in weight must be 2D.
-        3           0            1D Tensor   The length of x is 1, tensor in x must be 2D. The length of weight is 1, tensor in weight must be 3D.
-                                             (group_list.shape)[0] must be equal to (weight.shape)[0]
-                                             The last number in group_list needs to be equal to the 0th dimension of the shape with weight
-        =========== ============ =========== ====================================================================================================
-
-        Parameter limitations 2
-        Non-quant tyep table
-        =========   =========  =========  =========  =========  ================  =================   =========
-        x           weight     bias       scale      offset     antiquant_scale   antiquant_offset    y
-        =========   =========  =========  =========  =========  ================  =================   =========
-        Float16     Float16    Float16    None       None       None              None                Float16
-        =========   =========  =========  =========  =========  ================  =================   =========
-
-        Parameter limitations 3
-        Only in split_item=3, group_type=0
-        =========   =========  =========  =========  =========  ================  =================   =========
-        x           weight     bias       scale      offset     antiquant_scale   antiquant_offset    y
-        =========   =========  =========  =========  =========  ================  =================   =========
-        Float32     Float32    Float32    None       None       None              None                Float32
-        =========   =========  =========  =========  =========  ================  =================   =========
-
-    Outputs:
-        y (TensorList): TensorList, include 2D Tensors. The shape of the tensor is :math:`(M, K)`.
-
-    Raises:
-        TypeError: If `split_item` is not 0 or 3.
-        TypeError: If `group_type` is not -1 or 0.
-        TypeError: when `split_item` is 0, `group_type` is not -1.
-        TypeError: when `split_item` is 3, `group_type` is not 0.
-        TypeError: when `split_item` is 3, `group_list` is None.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import mindspore as ms
-        >>> import numpy as np
-        >>> from mindspore import nn, context
-        >>> from mindspore.ops.auto_generate import GroupedMatmul
-        >>> class Net(nn.Cell):
-        ...     def __init__(self, split_item=3, group_type=0):
-        ...         super(Net, self).__init__()
-        ...         self.gmm = GroupedMatmul(split_item, group_type)
-        ...
-        ...     def construct(self, x, weight, bias, scale, offset, antiquant_scale, antiquant_offset, group_list):
-        ...         result = self.gmm(x, weight, bias, scale, offset, antiquant_scale, antiquant_offset, group_list)
-        ...         return result
-        ...
-        >>> context.set_context(device_target="Ascend", mode=ms.GRAPH_MODE)
-        >>> x = [ms.Tensor(np.array([[0, 0, 0, 0],
-        ...                          [1, 1, 1, 1],
-        ...                          [2, 2, 2, 2],
-        ...                          [2, 2, 2, 2],
-        ...                          [1, 1, 1, 1],
-        ...                          [1, 1, 1, 1]]), ms.float16)]
-        >>> weight = [ms.Tensor(np.arange(32).reshape((4, 4, 2)), ms.float16)]
-        >>> bias = None
-        >>> scale = None
-        >>> offset = None
-        >>> antiquant_scale = None
-        >>> antiquant_offset = None
-        >>> group_list = ms.Tensor([1, 3, 4, 6], ms.int64)
-        >>> net = Net()
-        >>> output = net(x, weight, bias, scale, offset, antiquant_scale, antiquant_offset, group_list)
-        >>> print(output[0])
-        [[0   0  ]
-         [44  48 ]
-         [88  96 ]
-         [152 160]
-         [108 112]
-         [108 112]]
-    """
-    return grouped_matmul_impl(x, weight, bias, scale, offset, antiquant_scale, antiquant_offset, group_list, split_item, group_type)
-
-
-def kv_cache_scatter_update(var, indices, updates, axis, reduce='none'):
-    r"""
-    Update var with updates and indices along sequence axis.
-
-    Args:
-        var (Tensor): 4-D tensor, the target tensor.
-        indices (Tensor): 1-D tensor, the index tensor.
-        updates (Tensor): 4-D tensor, the tensor doing the update operation.
-        axis (Int): Which axis to scatter, can be '-1' and '-2'.
-        reduce (String): Scatter mode, default to string "none" and can be "update".
-
-    Returns:
-        Tensor, has the same data type and shape as original `var`.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor, ops
-        >>> from mindspore.ops.operations._infer_ops import KVCacheScatterUpdate
-        >>> kv_cache_scatter_update_op = KVCacheScatterUpdate()
-        >>> var_shape = [1, 5, 128, 4096]
-        >>> var = np.random.uniform(low=1, high=10, size=var_shape).astype(np.float32)
-        >>> indices_shape = [1]
-        >>> indices = np.random.randint(low=1, high=10, size=indices_shape).astype(np.int64)
-        >>> updates_shape = [1, 5, 128, 1]
-        >>> updates = np.random.uniform(low=1, high=10, size=updates_shape).astype(np.float32)
-        >>> output = kv_cache_scatter_update_op(Tensor(var), Tensor(indices), Tensor(updates), -1, 'update')
-        >>> print(output.shape)
-    """
-    return kv_cache_scatter_update_op(var, indices, updates, axis, reduce)
-
-
-def moe_finalize_routing(expanded_x, x1, x2=None, bias=None, scales=None, expanded_row_idx=None, expanded_expert_idx=None):
-    r"""
-    In MoE calculation, merge the results output by FFN and rearrange the output in time order by experts.
-
-    Notes:
-        - E: The number of experts, such as 8.
-        - K: The number of experts selected by a token, such as 1 or 2.
-        - N: The number of rows in x1, which is the number of original tokens.
-        - H: The number of cols in x1, which is the hiddens of tokens.
-
-    .. math::
-
-        expertid = expanded_expert_idx[i,k]
-        out(i,j) = x1_{i,j} + x2_{i,j} + \sum_{k=0}^{K}(scales_{i,k}*(expanded\_x_{expanded\_row\_idx_{i+k*N},j} + bias_{expertid,j}))
-
-    Inputs:
-        expanded_x (Tensor): The output of MoE FFN. The tensor must be 2D tensor. The shape of the tensor must be :math:`(K*N, H)`.
-                             Supported dtypes: Float16, Float32.
-        x1 (Tensor): The output of attention. The tensor must be 2D tensor. The shape of the tensor must be :math:`(N, H)`.
-                     Data type requirements should be consistent with expanded_x.
-                     If not used, the required values to be passed are all 0, The shape of the Tensor meets the requirements
-        x2 (Tensor, optional): The output of attention. The tensor must be 2D tensor. The shape of the tensor must be :math:`(N, H)`. If not used, None.
-                               Data type requirements should be consistent with expanded_x.
-        bias (Tensor): The bias of the last matmul in MoE FFN. The tensor must be 2D tensor. The shape of the tensor must be :math:`(E, H)`.
-                       Data type requirements should be consistent with expanded_x.
-        scales (Tensor): Weighted expanded when each token corresponds to multiple experts. The tensor must be 2D tensor.
-                         The shape of the tensor must be :math:`(N, K)`. Data type requirements should be consistent with expanded_x.
-                         If not used, the required values to be passed are all 1. The shape of the Tensor meets the requirements
-        expanded_row_idx (Tensor): The index in time order. The tensor must be 1D tensor. The shape of the tensor must be :math:`(K*N)`. Supported dtypes: Int32.
-                                   The value in Tensor must be between 0 and K*N, and the value cannot be repeated.
-        expanded_expert_idx (Tensor): The experts selected for each token are used to find the bias of which experts need to be accumulated.
-                                      The tensor must be 2D tensor. The shape of the tensor must be :math:`(N, K)`. Supported dtypes: Int32.
-
-    Outputs:
-        Tensor, the merged and sorted results. The tensor is 2D tensor. The shape of the tensor is :math:`(N, H)`. Data type consistent with expanded_x.
-
-    Raises:
-        TypeError: If the data type of input Tensor does not match the description in args.
-        ShapeError: If the shape of input Tensor does not match the description in args.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import mindspore as ms
-        >>> import numpy as np
-        >>> from mindspore import Tensor, nn, context
-        >>> from mindspore.ops.auto_generate import MoeFinalizeRouting
-        >>> class Net(nn.Cell):
-        ...     def __init__(self):
-        ...         super(Net, self).__init__()
-        ...         self.moe_finalize_routing = MoeFinalizeRouting()
-        ...
-        ...     def construct(self, expanded_x, x1, x2, bias, scales, expanded_row_idx, expanded_expert_idx):
-        ...         result = self.moe_finalize_routing(expanded_x, x1, x2, bias, scales, expanded_row_idx, expanded_expert_idx)
-        ...         return result
-        ...
-        >>> context.set_context(device_target="Ascend", mode=ms.GRAPH_MODE)
-        >>> # E = 4, K = 2, N = 3, H = 4
-        >>> expanded_x = ms.Tensor(np.array([[0.1, 0.1, 0.1, 0.1],
-        ...                                  [0.2, 0.2, 0.2, 0.2],
-        ...                                  [0.3, 0.3, 0.3, 0.3],
-        ...                                  [0.1, 0.1, 0.1, 0.1],
-        ...                                  [0.2, 0.2, 0.2, 0.2],
-        ...                                  [0.3, 0.3, 0.3, 0.3]]), ms.float16)
-        >>> x1 = ms.Tensor(np.array([[1, 1, 1, 1],
-        ...                          [0.2, 0.2, 0.2, 0.2],
-        ...                          [0.3, 0.3, 0.3, 0.3]]), ms.float16)
-        >>> x2 = None
-        >>> bias = ms.Tensor(np.array([[0.1, 0.1, 0.1, 0.1],
-        ...                            [0.2, 0.2, 0.2, 0.2],
-        ...                            [0.3, 0.3, 0.3, 0.3],
-        ...                            [0.4, 0.4, 0.4, 0.4]]), ms.float16)
-        >>> scales = ms.Tensor(np.array([[0.7, 0.3],
-        ...                              [0.8, 0.2],
-        ...                              [0.8, 0.2]]), ms.float16)
-        >>> expanded_row_idx = ms.Tensor(np.array([2, 3, 1, 0, 5, 4]), ms.int32)
-        >>> expanded_expert_idx = ms.Tensor(np.array([[0, 1],
-        ...                                           [0, 2],
-        ...                                           [1, 3]]), ms.int32)
-        >>> net = Net()
-        >>> output = net(expanded_x, x1, x2, bias, scales, expanded_row_idx, expanded_expert_idx)
-        >>> print(output)
-        [[1.37 1.37 1.37 1.37]
-         [0.48 0.48 0.48 0.48]
-         [0.74 0.74 0.74 0.74]]
-    """
-    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):
-    r"""
-    
-    """
-    return quant_batch_matmul_impl(x1, x2, scale, offset, bias, 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):
-    r"""
-    
-    """
-    return weight_quant_batch_matmul_impl(x, weight, antiquant_scale, antiquant_offset, quant_scale, quant_offset, bias, transpose_x, transpose_weight, antiquant_group_size)