mindspore 2.3.0rc1__cp37-cp37m-manylinux1_x86_64.whl → 2.3.0rc2__cp37-cp37m-manylinux1_x86_64.whl

mindspore/ops/auto_generate/gen_ops_def.py

@@ -313,6 +313,38 @@ 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(input, dim=None, keepdim=False):
+    r"""
+    Return the indices of the maximum values of a tensor across a dimension.
+
+    Args:
+        input (Tensor): Input tensor.
+        dim (Union[int, None], optional): The dimension to reduce. If `dim` is ``None`` , the indices of the maximum
+            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 maximum values across a dimension.
+
+    Raises:
+        TypeError: If `keepdim` is not bool.
+        ValueError: If `dim` is out of range.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor(np.array([[1, 20, 5], [67, 8, 9], [130, 24, 15]]).astype(np.float32))
+        >>> output = ops.argmax(x, dim=-1)
+        >>> print(output)
+        [1 0 0]
+    """
+    return argmax_ext_op(input, dim, keepdim)
+
+
 def asin(input):
     r"""
     Computes arcsine of input tensors element-wise.
@@ -578,6 +610,42 @@ def atanh(input):
     return atanh_op(input)
 
 
+def bmm_ext(input, mat2):
+    r"""
+    Performs batch matrix-matrix multiplication of two three-dimensional tensors.
+
+    .. math::
+        \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.
+        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:
+        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 do not match.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor
+        >>> 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 = bmm(a, b)
+        >>> print(output.shape)
+        (2, 3, 5)
+    """
+    return bmm_ext_op(input, mat2)
+
+
 def broadcast_to(input, shape):
     r"""
     Broadcasts input tensor to a given shape. The dim of input shape must be smaller
@@ -784,6 +852,120 @@ def celu(x, alpha=1.0):
     return celu_op(x)
 
 
+def clamp_scalar(input, min=None, max=None):
+    r"""
+    Clamps tensor values between the specified minimum value and maximum value.
+
+    Limits the value of :math:`input` to a range, whose lower limit is `min` and upper limit is `max` .
+
+    .. math::
+
+        out_i= \left\{
+        \begin{array}{align}
+            max & \text{ if } input_i\ge max \\
+            input_i & \text{ if } min \lt input_i \lt max \\
+            min & \text{ if } input_i \le min \\
+        \end{array}\right
+
+    Note:
+        - `min` and `max` cannot be None at the same time;
+        - When `min` is None and `max` is not None, the elements in Tensor larger than `max` will become `max`;
+        - When `min` is not None and `max` is None, the elements in Tensor smaller than `min` will become `min`;
+        - If `min` is greater than `max`, the value of all elements in Tensor will be set to `max`;
+        - The data type of `input`, `min` and `max` should support implicit type conversion and cannot be bool type.
+
+    Args:
+          input (Tensor): Input data, which type is Tensor. Tensors of arbitrary dimensions are supported.
+          min (Union(float, int), optional): The minimum value. Default: ``None`` .
+          max (Union(float, int), optional): The maximum value. Default: ``None`` .
+
+    Returns:
+          Tensor, a clipped Tensor.
+          The data type and shape are the same as input.
+
+    Raises:
+          ValueError: If both `min` and `max` are None.
+          TypeError: If the type of `input` is not Tensor.
+          TypeError: If the type of `min` is not in None, float or int.
+          TypeError: If the type of `max` is not in None, float or int.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> # case 1: the data type of input is number
+        >>> import mindspore
+        >>> from mindspore import Tensor
+        >>> from mindspore.ops.auto_generate import clamp_scalar
+        >>> import numpy as np
+        >>> min_value = 5
+        >>> max_value = 20
+        >>> input = Tensor(np.array([[1., 25., 5., 7.], [4., 11., 6., 21.]]), mindspore.float32)
+        >>> output = clamp_scalar(input, min_value, max_value)
+        >>> print(output)
+        [[ 5. 20.  5.  7.]
+        [ 5. 11.  6. 20.]]
+    """
+    return clamp_scalar_op(input, min, max)
+
+
+def clamp_tensor(input, min=None, max=None):
+    r"""
+    Clamps tensor values between the specified minimum value and maximum value.
+
+    Limits the value of :math:`input` to a range, whose lower limit is `min` and upper limit is `max` .
+
+    .. math::
+
+        out_i= \left\{
+        \begin{array}{align}
+            max & \text{ if } input_i\ge max \\
+            input_i & \text{ if } min \lt input_i \lt max \\
+            min & \text{ if } input_i \le min \\
+        \end{array}\right
+
+    Note:
+        - `min` and `max` cannot be None at the same time;
+        - When `min` is None and `max` is not None, the elements in Tensor larger than `max` will become `max`;
+        - When `min` is not None and `max` is None, the elements in Tensor smaller than `min` will become `min`;
+        - If `min` is greater than `max`, the value of all elements in Tensor will be set to `max`;
+        - The data type of `input`, `min` and `max` should support implicit type conversion and cannot be bool type.
+
+    Args:
+          input (Tensor): Input data, which type is Tensor. Tensors of arbitrary dimensions are supported.
+          min (Tensor, optional): The minimum value. Default: ``None`` .
+          max (Tensor, optional): The maximum value. Default: ``None`` .
+
+    Returns:
+          Tensor, a clipped Tensor.
+          The data type and shape are the same as input.
+
+    Raises:
+          ValueError: If both `min` and `max` are None.
+          TypeError: If the type of `input` is not Tensor.
+          TypeError: If the type of `min` is not in None, Tensor.
+          TypeError: If the type of `max` is not in None, Tensor.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> # case 1: the data type of input is Tensor
+        >>> import mindspore
+        >>> from mindspore import Tensor
+        >>> from mindspore.ops.auto_generate import clamp_tensor
+        >>> import numpy as np
+        >>> min_value = Tensor(5, mindspore.float32)
+        >>> max_value = Tensor(20, mindspore.float32)
+        >>> input = Tensor(np.array([[1., 25., 5., 7.], [4., 11., 6., 21.]]), mindspore.float32)
+        >>> output = clamp_tensor(input, min_value, max_value)
+        >>> print(output)
+        [[ 5. 20.  5.  7.]
+        [ 5. 11.  6. 20.]]
+    """
+    return clamp_tensor_op(input, min, max)
+
+
 def cat(tensors, axis=0):
     r"""
     Connect input tensors along with the given axis.
@@ -1145,6 +1327,50 @@ def decoder_k_v_cache(cache, update, valid_seq_len, batch_index, seq_len_axis, n
     return decoder_k_v_cache_op(cache, update, valid_seq_len, batch_index, seq_len_axis, new_max_seq_len, cur_max_seq_len)
 
 
+def dense(input, weight, bias=None):
+    r"""
+    Applies the dense connected operation to the `input`. The dense function is defined as:
+
+    .. math::
+        output = input * weight^{T} + bias
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): Input Tensor of shape :math:`(*, in\_channels)`,
+            where :math:`*` means any number of additional dimensions.
+        weight (Tensor): The weight applied to the input.
+            The shape is :math:`(out\_channels, in\_channels)` or :math:`(in\_channels)`.
+        bias (Tensor, optional): Additive biases to the output.
+            The shape is :math:`(out\_channels)` or :math:`()`. Defaults: ``None``, the `bias` is 0.
+
+    Returns:
+        Output whose shape is determined by the shape of the input and the weight.
+
+    Raises:
+        TypeError: If `input` is not Tensor.
+        TypeError: If `weight` is not Tensor.
+        TypeError: If `bias` is not Tensor.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU``  ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor([[-1., 1., 2.], [-3., -3., 1.]], mindspore.float32)
+        >>> weight = Tensor([[-2., -2., -2.], [0., -1., 0.]], mindspore.float32)
+        >>> bias = Tensor([0., 1.], mindspore.float32)
+        >>> output = ops.dense(input, weight, bias)
+        >>> print(output)
+        [[-4.  0.]
+         [10.  4.]]
+    """
+    return dense_op(input, weight, bias)
+
+
 def diag(input):
     r"""
     Constructs a diagonal tensor with a given diagonal values.
@@ -1227,6 +1453,13 @@ def diagonal(input, offset=0, dim1=0, dim2=1):
     return diagonal_op(input)
 
 
+def dot(input, other):
+    r"""
+    
+    """
+    return dot_op(input, other)
+
+
 def elu(input_x, alpha=1.0):
     r"""
     Exponential Linear Unit activation function.
@@ -1344,15 +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.
+            - Ascend: float16, float32, int64, bool.
             - GPU/CPU: float16, float32, float64.
 
     Returns:
-        Tensor, has the same shape and 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.
+
 
     Raises:
         TypeError: If `input` is not a Tensor.
-        TypeError: If dtype of `input` is not float16, float32 or float64.
+        TypeError: If dtype of `input` is not as follows
+
+            - Ascend: float16, float32, int64, bool.
+            - GPU/CPU: float16, float32, float64.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -1637,6 +1875,13 @@ def fast_gelu(x):
     return fast_gelu_op(x)
 
 
+def ffn_ext(x, weight1, weight2, expertTokens=None, bias1=None, bias2=None, scale=None, offset=None, deqScale1=None, deqScale2=None, antiquant_scale1=None, antiquant_scale2=None, antiquant_offset1=None, antiquant_offset2=None, activation='fastgelu', inner_precise=0):
+    r"""
+    
+    """
+    return ffn_ext_impl(x, weight1, weight2, expertTokens, bias1, bias2, scale, offset, deqScale1, deqScale2, antiquant_scale1, antiquant_scale2, antiquant_offset1, antiquant_offset2, activation, inner_precise)
+
+
 def fft2(input, s=None, dim=(-2, -1), norm=None):
     r"""
     Calculates the two dimensional discrete Fourier transform of `input`.
@@ -1846,6 +2091,42 @@ def fftshift(input, dim=None):
     return fftshift_op(input, dim)
 
 
+def flatten_ext(input, start_dim=0, end_dim=-1):
+    r"""
+    Flatten a tensor along dimensions from `start_dim` to `end_dim`.
+
+    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`` .
+
+    Returns:
+        Tensor. If no dimensions are flattened, returns the original `input`, otherwise return the flattened Tensor.
+        If `input` is a 0-dimensional Tensor, a 1-dimensional Tensor will be returned.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `start_dim` or `end_dim` is not int.
+        ValueError: If `start_dim` is greater than `end_dim` after canonicalized.
+        ValueError: If `start_dim` or `end_dim` is not in range of [-input.dim, input.dim-1].
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, mint
+        >>> input_x = Tensor(np.ones(shape=[1, 2, 3, 4]), mindspore.float32)
+        >>> output = mint.flatten(input_x)
+        >>> print(output.shape)
+        (24,)
+    """
+    return flatten_ext_op(input, start_dim, end_dim)
+
+
 def floor_divide(input, other):
     r"""
     Divides the first input tensor by the second input tensor element-wise and round down to the closest integer.
@@ -2568,12 +2849,20 @@ def irfft(input, n=None, dim=-1, norm=None):
     return irfft_op(input, n, dim, norm)
 
 
-def is_finite(x):
+def isfinite(x):
     r"""
-    Determine which elements are finite for each position.
+    Determine which elements are finite for each position. If elements are not ``NaN`` , ``-INF`` , ``INF``,
+    they are finite.
+
+    .. math::
+
+        out_i = \begin{cases}
+          & \text{ if } x_{i} = \text{Finite},\ \ True \\
+          & \text{ if } x_{i} \ne \text{Finite},\ \ False
+        \end{cases}
 
     Args:
-      - **x** (Tensor) - The input tensor.
+      x (Tensor): The input tensor.
 
     Returns:
         Tensor, has the same shape of input, and the dtype is bool.
@@ -2586,15 +2875,65 @@ def is_finite(x):
 
     Examples:
         >>> import mindspore
+        >>> import numpy as np
         >>> from mindspore import Tensor, ops
-        >>> is_finite = ops.IsFinite()
         >>> x = Tensor(np.array([np.log(-1), 1, np.log(0)]), mindspore.float32)
-        >>> output = is_finite(x)
+        >>> output = ops.isfinite(x)
         >>> print(output)
         [False True False]
-        
+        >>> x = Tensor(2.1, mindspore.float64)
+        >>> output = ops.isfinite(x)
+        >>> print(output)
+        True
+    """
+    return isfinite_op(x)
+
+
+def leaky_relu_ext(input, negative_slope=0.01):
+    r"""
+    leaky_relu activation function. The element of `input` less than 0 times `negative_slope` .
+
+    The activation function is defined as:
+
+    .. math::
+        \text{leaky_relu}(input) = \begin{cases}input, &\text{if } input \geq 0; \cr
+        {\negative_slope} * input, &\text{otherwise.}\end{cases}
+
+    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>`_.
+
+    LeakyReLU Activation Function Graph:
+
+    .. image:: ../images/LeakyReLU.png
+        :align: center
+
+    Args:
+        input (Tensor): The input of leaky_relu is a Tensor of any dimension.
+        negative_slope (Union[int, float]): Slope of the activation function when the element of `input` is less than 0.
+          Default: ``0.01`` .
+
+    Returns:
+        Tensor, has the same type and shape as the `input`.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `negative_slope` is not a float or an int.
+
+    Supported Platforms:
+        ``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(mint.leaky_relu(input, negative_slope=0.2))
+        [[-0.2  4.  -1.6]
+         [ 2.  -1.   9. ]]
     """
-    return is_finite_op(x)
+    return leaky_relu_ext_op(input, negative_slope)
 
 
 def less_equal(input, other):
@@ -2827,6 +3166,13 @@ def masked_fill(input_x, mask, value):
     return masked_fill_op(input_x, mask, value)
 
 
+def matmul_ext(input, mat2):
+    r"""
+    
+    """
+    return matmul_ext_op(input, mat2)
+
+
 def matrix_exp(input):
     r"""
     Computes the exponential of a single or a batch of square matrices.
@@ -2867,6 +3213,15 @@ def matrix_exp(input):
     return matrix_exp_op(input)
 
 
+def max_(input):
+    r"""
+    Calculates the maximum value of the input tensor.
+
+    Also see :func:`mindspore.ops.extend.max`.
+    """
+    return max_op(input)
+
+
 def maximum(input, other):
     r"""
     Computes the maximum of input tensors element-wise.
@@ -2921,6 +3276,102 @@ def maximum(input, other):
     return maximum_op(input, other)
 
 
+def mean_ext(input, axis=None, keep_dims=False, dtype=None):
+    r"""
+    Reduces all dimension of a tensor by averaging all elements in the dimension, by default.
+    And reduce a dimension of `input` along the specified `axis`. `keep_dims`
+    determines whether the dimensions of the output and input are the same.
+
+    Note:
+        The `axis` with tensor type is only used for compatibility with older versions and is not recommended.
+
+    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 (Union[int, tuple(int), list(int), Tensor]): 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:`(x_0, x_2, ..., x_R)`.
+        - If `axis` is tuple(int), set as (1, 2), and `keep_dims` is ``False`` ,
+          the shape of output is :math:`(x_0, x_3, ..., x_R)`.
+        - If `axis` is 1-D Tensor, set as [1, 2], and `keep_dims` is ``False`` ,
+          the shape of output is :math:`(x_0, x_3, ..., x_R)`.
+
+    Raises:
+        TypeError: If `x` is not a Tensor.
+        TypeError: If `axis` is not one of the following: int, tuple, list or Tensor.
+        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.mean(x, 1, keep_dims=True)
+        >>> result = output.shape
+        >>> print(result)
+        (3, 1, 5, 6)
+        >>> # case 1: Reduces a dimension by averaging all elements in the dimension.
+        >>> x = Tensor(np.array([[[2, 2, 2, 2, 2, 2], [2, 2, 2, 2, 2, 2], [2, 2, 2, 2, 2, 2]],
+        ... [[4, 4, 4, 4, 4, 4], [5, 5, 5, 5, 5, 5], [6, 6, 6, 6, 6, 6]],
+        ... [[6, 6, 6, 6, 6, 6], [8, 8, 8, 8, 8, 8], [10, 10, 10, 10, 10, 10]]]),
+        ... mindspore.float32)
+        >>> output = ops.mean(x)
+        >>> print(output)
+        5.0
+        >>> print(output.shape)
+        ()
+        >>> # case 2: Reduces a dimension along the axis 0
+        >>> output = ops.mean(x, 0, True)
+        >>> print(output)
+        [[[4. 4. 4. 4. 4. 4.]
+        [5. 5. 5. 5. 5. 5.]
+        [6. 6. 6. 6. 6. 6.]]]
+        >>> # case 3: Reduces a dimension along the axis 1
+        >>> output = ops.mean(x, 1, True)
+        >>> print(output)
+        [[[2. 2. 2. 2. 2. 2.]]
+        [[5. 5. 5. 5. 5. 5.]]
+        [[8. 8. 8. 8. 8. 8.]]]
+        >>> # case 4: Reduces a dimension along the axis 2
+        >>> output = ops.mean(x, 2, True)
+        >>> print(output)
+        [[[ 2.]
+        [ 2.]
+        [ 2.]]
+        [[ 4.]
+        [ 5.]
+        [ 6.]]
+        [[ 6.]
+        [ 8.]
+        [10.]]]
+    """
+    return mean_ext_op(input, axis, keep_dims, dtype)
+
+
+def min_(input):
+    r"""
+    Calculates the minimum value of the input tensor.
+
+    Also see :func:`mindspore.ops.extend.min`.
+    """
+    return min_op(input)
+
+
 def minimum(input, other):
     r"""
     Computes the minimum of input tensors element-wise.
@@ -2973,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.
@@ -3023,6 +3481,13 @@ def mul(input, other):
     return mul_op(input, other)
 
 
+def mv(input, vec):
+    r"""
+    
+    """
+    return mv_op(input, vec)
+
+
 def neg(input):
     r"""
     Returns a tensor with negative values of the input tensor element-wise.
@@ -3147,6 +3612,44 @@ def not_equal(input, other):
     """
     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:
+        shape (Union[tuple[int], list[int], int, Tensor]): The specified shape of output tensor. Only positive integer or
+            tuple or Tensor containing positive integers are allowed. If it is a Tensor,
+            it must be a 0-D or 1-D Tensor with int32 or int64 dtypes.
+        dtype (:class:`mindspore.dtype`): The specified type of output tensor. If `dtype` is ``None`` ,
+            `mindspore.float32` will be used. Default: ``None`` .
+
+    Returns:
+        Tensor, whose dtype and size are defined by input.
+
+    Raises:
+        TypeError: If `shape` is neither an int nor an tuple/list/Tensor of int.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import ops
+        >>> output = ops.ones((2, 2), mindspore.float32)
+        >>> print(output)
+        [[1. 1.]
+         [1. 1.]]
+    """
+    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):
     r"""
@@ -3410,8 +3913,7 @@ def quant_batch_matmul(x1, x2, scale, offset=None, bias=None, transpose_x1=False
     r"""
     
     """
-    quant_batch_matmul_op = _get_cache_prim(QuantBatchMatmul)(transpose_x1, transpose_x2, dtype)
-    return quant_batch_matmul_op(x1, x2, scale, offset, bias)
+    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):
@@ -3535,6 +4037,66 @@ def real(input):
     return real_op(input)
 
 
+def all(input, axis=None, keep_dims=False):
+    r"""
+    Reduces a dimension of `input` by the "logical AND" of 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`.
+
+    Note:
+        The `axis` with tensor type is only used for compatibility with older versions and is not recommended.
+
+    Args:
+        input (Tensor): Input Tensor, has the shape :math:`(N, *)` where :math:`*` means,
+            any number of additional dimensions.
+        axis (Union[int, tuple(int), list(int), Tensor], optional): The dimensions to reduce.
+            Suppose the rank of `input` is r, `axis` must be in the range [-rank(input), rank(input)).
+            Default: ``None`` , all dimensions are reduced.
+        keep_dims (bool, optional): If ``True`` , keep these reduced dimensions and the length is 1.
+            If ``False`` , don't keep these dimensions. Default : ``False`` .
+
+    Returns:
+        Tensor, the dtype is bool.
+
+        - If `axis` is ``None`` , and `keep_dims` is ``False`` ,
+          the output is a 0-D Tensor representing the "logical AND" of all elements in the input Tensor.
+        - If `axis` is int, such as 2, and `keep_dims` is ``False`` ,
+          the shape of output is :math:`(input_1, input_3, ..., input_R)`.
+        - If `axis` is tuple(int), such as (2, 3), and `keep_dims` is ``False`` ,
+          the shape of output is :math:`(input_1, input_4, ..., input_R)`.
+        - If `axis` is 1-D Tensor, such as [2, 3], and `keep_dims` is ``False`` ,
+          the shape of output is :math:`(input_1, input_4, ..., input_R)`.
+
+    Raises:
+        TypeError: If `keep_dims` is not a bool.
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `axis` is not one of the following: int, tuple, list or Tensor.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor(np.array([[True, False], [True, True]]))
+        >>> # case 1: Reduces a dimension by the "logicalAND" of all elements in the dimension.
+        >>> output = ops.all(x, keep_dims=True)
+        >>> print(output)
+        [[False]]
+        >>> print(output.shape)
+        (1, 1)
+        >>> # case 2: Reduces a dimension along axis 0.
+        >>> output = ops.all(x, axis=0)
+        >>> print(output)
+        [ True False]
+        >>> # case 3: Reduces a dimension along axis 1.
+        >>> output = ops.all(x, axis=1)
+        >>> print(output)
+        [False True]
+    """
+    return reduce_all_impl(input, axis, keep_dims)
+
+
 def relu6(x):
     r"""
     Computes ReLU (Rectified Linear Unit) upper bounded by 6 of input tensors element-wise.
@@ -3619,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.
@@ -3704,20 +4273,20 @@ def reshape(input, shape):
     return reshape_op(input, shape)
 
 
-def reverse(x, axis):
+def flip(input, axis):
     r"""
     Reverses specific dimensions of a tensor.
 
     .. warning::
-        The value range of "axis" is [-dims, dims - 1]. "dims" is the dimension length of "x".
+        The value range of "axis" is [-dims, dims - 1]. "dims" is the dimension length of "input".
 
     Args:
-        x (Tensor): The target tensor.
+        input (Tensor): The target tensor.
             The shape is :math:`(N, *)` where :math:`*` means, any number of additional dimensions.
         axis (Union[tuple(int), list(int)]): The indices of the dimensions to reverse.
 
     Outputs:
-        Tensor, has the same shape and type as `x`.
+        Tensor, has the same shape and type as `input`.
 
     Raises:
         TypeError: If `axis` is neither list nor tuple.
@@ -3731,18 +4300,17 @@ def reverse(x, axis):
         >>> import numpy as np
         >>> from mindspore import Tensor, ops
         >>> input_x = Tensor(np.array([[1, 2, 3, 4], [5, 6, 7, 8]]), mindspore.int32)
-        >>> output = ops.reverse(input_x, axis=[1])
+        >>> output = ops.flip(input_x, axis=[1])
         >>> print(output)
         [[4 3 2 1]
          [8 7 6 5]]
         >>> input_x = Tensor(np.array([[1, 2, 3, 4], [5, 6, 7, 8]]), mindspore.int32)
-        >>> output = ops.reverse(input_x, axis=[1, 0])
+        >>> output = ops.flip(input_x, axis=[1, 0])
         >>> print(output)
         [[8 7 6 5]
          [4 3 2 1]]
     """
-    reverse_v2_op = _get_cache_prim(ReverseV2)(axis)
-    return reverse_v2_op(x)
+    return reverse_v2_impl(input, axis)
 
 
 def rfft(input, n=None, dim=-1, norm=None):
@@ -4001,6 +4569,57 @@ def scatter_nd(indices, updates, shape):
     return scatter_nd_op(indices, updates, shape)
 
 
+def select(condition, input, other):
+    r"""
+    The conditional tensor determines whether the corresponding element in the output must be
+    selected from `input` (if True) or `other` (if False) based on the value of each
+    element.
+
+    It can be defined as:
+
+    .. math::
+        out_i = \begin{cases}
+        input_i, & \text{if } condition_i \\
+        other_i, & \text{otherwise}
+        \end{cases}
+
+    Args:
+        condition (Tensor[bool]): The condition tensor, decides which element is chosen.
+            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.
+        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.
+
+    Returns:
+        Tensor, has the same shape as `condition`.
+
+    Raises:
+        TypeError: If input or other is not a Tensor.
+        ValueError: The shape of inputs cannot be broadcast.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> # Both inputs are Tensor
+        >>> cond = Tensor([True, False])
+        >>> x = Tensor([2,3], mindspore.float32)
+        >>> y = Tensor([1,2], mindspore.float32)
+        >>> output = ops.select(cond, x, y)
+        >>> print(output)
+        [2. 2.]
+        
+    """
+    return select_op(condition, input, other)
+
+
 def sequence_concat(x, axis=0):
     r"""
     Support sequence Concat operation.
@@ -4214,6 +4833,13 @@ def sinh(input):
     return sinh_op(input)
 
 
+def softplus_ext(input, beta=1, threshold=20):
+    r"""
+    
+    """
+    return softplus_ext_op(input, beta, threshold)
+
+
 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.
@@ -4335,6 +4961,46 @@ def square(input):
     return square_op(input)
 
 
+def stack_ext(tensors, dim=0):
+    r"""
+    Stacks a list of tensors in specified dim.
+
+    Stacks the list of input tensors with the same rank `R`, output is a tensor of rank `(R+1)`.
+
+    Given input tensors of shape :math:`(x_1, x_2, ..., x_R)`. Set the number of input tensors as `N`.
+    If :math:`dim \ge 0`, the shape of the output tensor is
+    :math:`(x_1, x_2, ..., x_{dim}, N, x_{dim+1}, ..., x_R)`.
+
+    Args:
+        tensors (Union[tuple, list]): A Tuple or list of Tensor objects with the same shape and type.
+        dim (int): Dimension to stack. The range is [-(R+1), R+1). Default: ``0`` .
+
+    Returns:
+        Tensor. A stacked Tensor with the same type as `tensors`.
+
+    Raises:
+        TypeError: If the data types of elements in `tensors` are not the same.
+        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`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> 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 = mint.stack([data1, data2], 0)
+        >>> print(output)
+        [[0. 1.]
+            [2. 3.]]
+    """
+    return stack_ext_impl(tensors, dim)
+
+
 def strided_slice(input_x, begin, end, strides, begin_mask=0, end_mask=0, ellipsis_mask=0, new_axis_mask=0, shrink_axis_mask=0):
     r"""
     Extracts a strided slice of a Tensor based on `begin/end` index and `strides`.
@@ -4598,6 +5264,52 @@ def sub(input, other):
     return sub_op(input, other)
 
 
+def tanh(input):
+    r"""
+    Computes hyperbolic tangent of input element-wise. The Tanh function is defined as:
+
+    .. math::
+
+        tanh(x_i) = \frac{\exp(x_i) - \exp(-x_i)}{\exp(x_i) + \exp(-x_i)} = \frac{\exp(2x_i) - 1}{\exp(2x_i) + 1},
+
+    where :math:`x_i` is an element of the input Tensor.
+
+    Tanh Activation Function Graph:
+
+    .. image:: ../images/Tanh.png
+        :align: center
+
+    Args:
+        input (Tensor): Input of Tanh.
+
+    Returns:
+        Tensor, with the same type and shape 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
+        >>> input = Tensor(np.array([1, 2, 3, 4, 5]), mindspore.float32)
+        >>> output = ops.tanh(input)
+        >>> print(output)
+        [0.7615941 0.9640276 0.9950547 0.9993293 0.9999092]
+    """
+    return tanh_op(input)
+
+
+def topk_ext(input, k, dim=-1, largest=True, sorted=True):
+    r"""
+    
+    """
+    return topk_ext_op(input, k, dim, largest, sorted)
+
+
 def trace(input):
     r"""
     Returns a new tensor that is the sum of the `input` main trace.
@@ -4689,6 +5401,127 @@ 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),
+    and set the other elements to zeros.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): The input tensor with shape :math:`(M, N, *)` where * means any number of additional dimensions.
+        diagonal (int, optional): An optional attribute indicates the diagonal to consider, default: ``0``,
+            indicating the main diagonal.
+
+    Returns:
+        Tensor, a tensor has the same shape and data type as input.
+
+    Raises:
+        TypeError: If `diagonal` is not an int.
+        TypeError: If `input` is not a Tensor.
+        ValueError: If the dimension of `input` 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.triu(x)
+        >>> print(result)
+        [[ 1  2  3  4]
+         [ 0  6  7  8]
+         [ 0  0 12 13]
+         [ 0  0  0 17]]
+        >>> x = Tensor(np.array([[ 1,  2,  3,  4],
+        ...                      [ 5,  6,  7,  8],
+        ...                      [10, 11, 12, 13],
+        ...                      [14, 15, 16, 17]]))
+        >>> result = ops.triu(x, diagonal=1)
+        >>> print(result)
+        [[ 0  2  3  4]
+         [ 0  0  7  8]
+         [ 0  0  0 13]
+         [ 0  0  0  0]]
+        >>> x = Tensor(np.array([[ 1,  2,  3,  4],
+        ...                      [ 5,  6,  7,  8],
+        ...                      [10, 11, 12, 13],
+        ...                      [14, 15, 16, 17]]))
+        >>> result = ops.triu(x, diagonal=-1)
+        >>> print(result)
+        [[ 1  2  3  4]
+         [ 5  6  7  8]
+         [ 0 11 12 13]
+         [ 0  0 16 17]]
+    """
+    return triu_impl(input, diagonal)
+
+
 def tuple_to_tensor(input_tuple, dtype=None):
     r"""
     
@@ -4782,5 +5615,39 @@ def weight_quant_batch_matmul(x, weight, antiquant_scale, antiquant_offset=None,
     r"""
     
     """
-    weight_quant_batch_matmul_op = _get_cache_prim(WeightQuantBatchMatmul)(transpose_x, transpose_weight, antiquant_group_size)
-    return weight_quant_batch_matmul_op(x, weight, antiquant_scale, antiquant_offset, quant_scale, quant_offset, bias)
+    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 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.
+
+    Args:
+        size (Union[tuple[int], list[int], int, Tensor]): The specified shape of output tensor. Only positive integer or
+            tuple or Tensor containing positive integers are allowed. If it is a Tensor,
+            it must be a 0-D or 1-D Tensor with int32 or int64 dtypes.
+        dtype (:class:`mindspore.dtype`, optional): The specified type of output tensor. If `dtype` is ``None`` ,
+            mindspore.float32 will be used. Default: ``None`` .
+
+    Returns:
+        Tensor, whose dtype and size are defined by input.
+
+    Raises:
+        TypeError: If `size` is neither an int nor an tuple/list/Tensor of int.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import ops
+        >>> output = ops.zeros((2, 2), mindspore.float32)
+        >>> print(output)
+        [[0. 0.]
+         [0. 0.]]
+    """
+    return zeros_op(size, dtype)