mindspore 2.4.1__cp39-none-any.whl → 2.5.0__cp39-none-any.whl

mindspore/ops/auto_generate/gen_ops_def.py

@@ -239,6 +239,13 @@ def adaptive_avg_pool2d_grad_ext(grad_output, x):
     return adaptive_avg_pool2d_grad_ext_op(grad_output, x)
 
 
+def adaptive_avg_pool3d_ext(input, output_size):
+    r"""
+    
+    """
+    return adaptive_avg_pool3d_ext_op(input, output_size)
+
+
 def add_ext(input, other, alpha=1):
     r"""
     Adds scaled other value to input Tensor.
@@ -370,11 +377,60 @@ def add(input, other):
     return add_op(input, other)
 
 
-def addmm(input, mat1, mat2, beta, alpha):
+def add_rms_norm(x1, x2, gamma, epsilon=1e-6):
     r"""
-    
+    The AddRmsNorm is a fusion operator that fusing RmsNorm and its preceding Add operator, reducing the time for
+    moving data in and out.
+    It computes the following expression:
+
+    .. math::
+        \begin{array}{ll} \\
+            x_i = x1_i + x2_i \\
+            y_i=RmsNorm(x_i)=\frac{x_i}{\sqrt{\frac{1}{n}\sum_{i=1}^{n}{ x_i^2}+\varepsilon}}\gamma_i
+        \end{array}
+
+    .. 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:
+        x1 (Tensor): Input data of AddRmsNorm. Support data type: float16, float32, bfloat16.
+        x2 (Tensor): Input data of AddRmsNorm. 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 `x1`.
+        - Tensor, with the float data type, denotes the reciprocal of the input standard deviation, used by gradient
+          calculation.
+        - Tensor, the sum of `x1` and `x2`.
+
+    Raises:
+        TypeError: If data type of `x1` or `x2` is not one of the following: float16, float32, bfloat16.
+        TypeError: If data type of `gamma` is not one of the following: float16, float32, bfloat16.
+        ValueError: If `epsilon` is not a float between 0 and 1.
+        ValueError: If the rank of `gamma` is greater than the rank of `x1` or `x2`.
+        RuntimeError: If the shapes of `x1` and `x2` are not same.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> x1 = Tensor(np.array([[0.5, 1.0, 1.5], [0.5, 1.0, 1.5]]), mindspore.float32)
+        >>> x2 = Tensor(np.array([[0.5, 1.0, 1.5], [0.5, 1.0, 1.5]]), mindspore.float32)
+        >>> gamma = Tensor(np.ones([3]), mindspore.float32)
+        >>> y, rstd = ops.add_rms_norm(x1, x2, gamma)
+        >>> print(y)
+        [[0.46290997  0.92581993  1.3887299]
+         [0.46290997  0.92581993  1.3887299]]
+        >>> print(rstd)
+        [[0.46290997]
+         [0.46290997]]
     """
-    return addmm_op(input, mat1, mat2, beta, alpha)
+    return add_rms_norm_op(x1, x2, gamma, epsilon)
 
 
 def addn(x):
@@ -451,14 +507,38 @@ def apply_rotary_pos_emb_(query, key, cos, sin, position_ids, cos_format=0):
 
 def argmax_ext(input, dim=None, keepdim=False):
     r"""
+    argmax(input) -> Tensor
+
+    Return the indices of the maximum values of a tensor.
+
+    Args:
+        input (Tensor): Input tensor.
+
+    Returns:
+        Tensor.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor
+        >>> from mindspore import ops
+        >>> x = Tensor(np.array([[1, 20, 5], [67, 8, 9], [130, 24, 15]]).astype(np.float32))
+        >>> output = ops.auto_generate.argmax_ext(x)
+        >>> print(output)
+        6
+
+    .. function:: argmax(input, dim, keepdim=False) -> Tensor
+        :noindex:
+
     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`` .
+        dim (int): The dimension to reduce. 
         keepdim (bool, optional): Whether the output tensor retains the specified
-            dimension. Ignored if `dim` is None. Default: ``False`` .
+            dimension. Default: ``False`` .
 
     Returns:
         Tensor, indices of the maximum values across a dimension.
@@ -515,6 +595,48 @@ def argmin_ext(input, dim=None, keepdim=False):
     return argmin_ext_op(input, dim, keepdim)
 
 
+def argsort_ext(input, dim=-1, descending=False):
+    r"""
+    Sorts the input tensor along the given dimension in specified order and return the sorted indices.
+
+    .. warning::
+            This is an experimental optimizer API that is subject to change.
+
+    Args:
+        input(Tensor): The input tensor to sort.
+        dim (int, optional): The dim to sort along. Default: ``-1`` , means the last dimension.
+            The Ascend backend only supports sorting the last dimension.
+        descending (bool, optional): The sort order. If `descending` is ``True`` then the elements
+            are sorted in descending order by value. Otherwise sort in ascending order. Default: ``False`` .
+
+    Returns:
+        Tensor, the indices of sorted input tensor. Data type is int64.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor
+        >>> import mindspore.mint as mint
+        >>> x = Tensor(np.array([[8, 2, 1], [5, 9, 3], [4, 6, 7]]), mindspore.float16)
+        >>> sort = mint.argsort(x)
+        >>> print(sort)
+        [[2 1 0]
+        [2 0 1]
+        [0 1 2]]
+    """
+    return argsort_op(input, dim, descending)
+
+
+def as_strided(input, size, stride, storage_offset=0):
+    r"""
+    
+    """
+    return as_strided_op(input, size, stride, storage_offset)
+
+
 def asin_ext(input):
     r"""
     Computes arcsine of input tensors element-wise.
@@ -648,7 +770,7 @@ def asinh(input):
 
 def assign_add(variable, value):
     r"""
-    Updates a `Parameter` by adding a value to it.
+    Updates a `Parameter` or `Tensor` by adding a value to it.
 
     Args of `variable` and `value` comply with the implicit type conversion rules to make the data types consistent.
     If they have different data types, the lower priority data type will be converted to
@@ -657,15 +779,16 @@ def assign_add(variable, value):
     and the data type is consistent with the Tensor data type involved in the operation.
 
     Note:
-        Since `variable` is a data type Parameter, the data type cannot be changed,
+        Since `variable` is a data type Parameter or Tensor, the data type cannot be changed,
         so only the type of `value` is allowed to be promoted to the type of `variable`.
         And the conversion type supported by different devices will be different,
         it is recommended to use the same data type when using this operator.
 
     Args:
-        variable (Parameter): The `Parameter`.
+        variable (Union[Parameter, Tensor]): The `Parameter` or `Tensor`.
             :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
-        value (Tensor): The value to be added to the `variable`.
+        value (Union[Tensor, Number]): The value to be added to the `variable`.
+            If `value` is a number, the number is automatically converted to Tensor.
             It must have the same shape as `variable`.
             it is recommended to use the same data type when using this operator.
 
@@ -674,8 +797,8 @@ def assign_add(variable, value):
 
     Raises:
         TypeError: If `value` is neither Number nor Tensor.
-        RuntimeError: If the data type of `variable` and `value` conversion of Parameter
-                    is required when data type conversion of Parameter is not supported.
+        RuntimeError: If the data type of `variable` and `value` conversion of Parameter or Tensor
+                    is required when data type conversion of Parameter or Tensor is not supported.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -696,14 +819,14 @@ def assign_add(variable, value):
 
 def assign(variable, value):
     r"""
-    Assigns `Parameter` with a value.
+    Assigns `Parameter` or `Tensor` with a value.
 
     Args of `variable` and `value` comply with the implicit type conversion rules to make the data types consistent.
     If they have different data types, the lower priority data type will be converted to
     the relatively highest priority data type.
 
     Args:
-        variable (Parameter): The `Parameter`. :math:`(N,*)` where :math:`*` means,
+        variable (Union[Parameter, Tensor]): The `Parameter` or `Tensor`. :math:`(N,*)` where :math:`*` means,
             any number of additional dimensions.
         value (Tensor): The value to be assigned, has the same shape with `variable`.
 
@@ -711,9 +834,9 @@ def assign(variable, value):
         Tensor, has the same data type and shape as original `variable`.
 
     Raises:
-        TypeError: If `variable` is not a Parameter.
+        TypeError: If `variable` is neither a Parameter nor a Tensor.
         TypeError: If `value` is not a Tensor.
-        RuntimeError: If the data type of `variable` and `value` conversion of Parameter
+        RuntimeError: If the data type of `variable` and `value` conversion of Parameter or Tensor
                       is required when data type conversion of Parameter is not supported.
 
     Supported Platforms:
@@ -731,6 +854,53 @@ def assign(variable, value):
     return assign_op(variable, value)
 
 
+def assign_sub(variable, value):
+    r"""
+    Updates a `Parameter` or `Tensor` by subtracting a value from it.
+
+    Args of `variable` and `value` comply with the implicit type conversion rules to make the data types consistent.
+    If they have different data types, the lower priority data type will be converted to
+    the relatively highest priority data type.
+    If `value` is a number, the number is automatically converted to Tensor,
+    and the data type is consistent with the Tensor data type involved in the operation.
+
+    Note:
+        Since `variable` is a data type Parameter or Tensor, the data type cannot be changed,
+        so only the type of `value` is allowed to be promoted to the type of `variable`.
+        And the conversion type supported by different devices will be different,
+        it is recommended to use the same data type when using this operator.
+
+    Args:
+        variable (Union[Parameter, Tensor]): The `Parameter` or `Tensor`.
+            :math:`(N,*)` where :math:`*` means, any number of additional dimensions.
+        value (Tensor): The value to be subtracted from the `variable`.
+            It must have the same shape as `variable`.
+            it is recommended to use the same data type when using this operator.
+
+    Returns:
+        Tensor, has the same data type and shape as `variable`.
+
+    Raises:
+        TypeError: If `value` is neither Number nor Tensor.
+        RuntimeError: If the type conversion between `variable` and `value` is not supported.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> from mindspore.common.initializer import initializer
+        >>> variable = mindspore.Parameter(initializer(1, [1], mindspore.int32), name="global_step")
+        >>> value = Tensor(np.ones([1]).astype(np.int32) * 100)
+        >>> ops.assign_sub(variable, value)
+        >>> print(variable.asnumpy())
+        [-99]
+    """
+    return assign_sub_op(variable, value)
+
+
 def atan2_ext(input, other):
     r"""
     Returns arctangent of input/other element-wise.
@@ -919,6 +1089,56 @@ def atanh(input):
     return atanh_op(input)
 
 
+def avg_pool1d_ext(input, kernel_size, stride=None, padding=0, ceil_mode=False, count_include_pad=True):
+    r"""
+    Applies a 1D average pooling over an input Tensor which can be regarded as a composition of 1D input planes.
+
+    Typically the input is of shape :math:`(N_{in}, C_{in}, L_{in})`, avg_pool1d outputs regional average in the
+    :math:`(L_{in})`-dimension. Given kernel size as :math:`ks = l_{ker}` and `stride` as :math:`s = s_0`, the
+    operation is as follows.
+
+    .. math::
+        \text{output}(N_i, C_j, l) = \frac{1}{l_{ker}} \sum_{n=0}^{l_{ker}-1}
+        \text{input}(N_i, C_j, s_0 \times l + n)
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): Tensor of shape :math:`(N, C_{in}, L_{in})`.
+        kernel_size (Union(int, tuple[int])): The size of kernel window used to take the average value.
+        stride (Union(int, tuple[int]), optional): The distance of kernel moving. `stride` can either be an int
+            number or a tuple of one int number. Default: ``None``, the same value as `kernel_size`.
+        padding (Union(int, tuple[int]), optional): The pad length to be filled. `padding` can either be an integer
+            or a tuple of one integer. Default: ``0`` .
+        ceil_mode (bool, optional): If True, apply ceil instead of floor to compute the output shape. Default: ``False``.
+        count_include_pad (bool, optional): If True, include the zero-padding in the averaging calculation. Default: ``True`` .
+
+    Returns:
+        Tensor of shape :math:`(N, C_{in}, L_{out})`.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `kernel_size` or `stride` is not an int.
+        TypeError: If `ceil_mode` or `count_include_pad` is not a bool.
+        ValueError: If `kernel_size` or `stride` is less than `1`.
+        ValueError: If `kernel_size` or `stride` or `padding` is not int nor a tuple whose length is greater than `1`.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, mint
+        >>> input_x = Tensor(np.random.randint(0, 10, [1, 3, 6]), mindspore.float32)
+        >>> output = mint.nn.functional.avg_pool1d(input_x, kernel_size=6, stride=1)
+        >>> print(output.shape)
+        (1, 3, 1)
+    """
+    return avg_pool1d_op(input, kernel_size, stride, padding, ceil_mode, count_include_pad)
+
+
 def baddbmm(input, batch1, batch2, beta, alpha):
     r"""
     The result is the sum of the input and a batch matrix-matrix product of matrices in batch1 and batch2.
@@ -963,6 +1183,73 @@ def baddbmm(input, batch1, batch2, beta, alpha):
     return baddbmm_op(input, batch1, batch2, beta, alpha)
 
 
+def batch_norm_elemt(input, weight=None, bias=None, mean=None, invstd=None, eps=1e-5):
+    r"""
+    
+    """
+    return batch_norm_elemt_op(input, weight, bias, mean, invstd, eps)
+
+
+def batch_norm_gather_stats_with_counts(input, mean, invstd, running_mean=None, running_var=None, momentum=1e-1, eps=1e-5, counts=None):
+    r"""
+    
+    """
+    return batch_norm_gather_stats_with_counts_op(input, mean, invstd, running_mean, running_var, momentum, eps, counts)
+
+
+def batch_norm_stats(input, eps):
+    r"""
+    
+    """
+    return batch_norm_stats_op(input, eps)
+
+
+def bincount_ext(input, weights=None, minlength=0):
+    r"""
+    Count the occurrences of each value in the input.
+
+    If `minlength` is not specified, the length of the output Tensor is the maximum value in the input plus one.
+    If `minlength` is specified, the length of the output Tensor is the maximum value between `minlength` or
+    the maximum value in the input plus one.
+
+    Each value in the output Tensor represents the number of occurrences of that index value in the input.
+    If `weights` is specified, the output results are weighted, 
+    i.e., :math:`out[n] += weight[i]` instead of :math:`out[n] += 1`.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): A one-dimensional Tensor.
+        weights (Tensor, optional): Weights with the same shape as the input. Default: ``None``.
+        minlength (int, optional): The minimum length of output Tensor. Should be non-negative. Default: ``0``.
+
+    Returns:
+        Tensor, If input is non-empty, the output shape is :math:`(max(max(input)+1, minlength), )`,
+        otherwise the shape is :math:`(0, )`.
+
+    Raises:
+        TypeError: If `input` or `weights` is not a Tensor.
+        ValueError: If `input` contains negative values.
+        ValueError: If `input` is not one-dimensional or `input` and `weights` do not have the same shape.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> from mindspore import mint
+        >>> print(mint.bincount(np.arange(5)))
+        [1. 1. 1. 1. 1.]
+        >>> print(mint.bincount(np.array([0, 1, 1, 3, 2, 1, 7])))
+        [1. 3. 1. 1. 0. 0. 0. 1.]
+        >>> w = np.array([0.3, 0.5, 0.2, 0.7, 1., -0.6]) # weights
+        >>> x = np.array([0, 1, 1, 2, 2, 2])
+        >>> print(mint.bincount(x,  weights=w, minlength=5))
+        [0.3 0.7 1.1 0.0 0.0]
+    """
+    return bincount_ext_op(input, weights, minlength)
+
+
 def bmm_ext(input, mat2):
     r"""
     Performs batch matrix-matrix multiplication of two three-dimensional tensors.
@@ -1120,6 +1407,54 @@ def cast(input, dtype):
     return cast_op(input, dtype)
 
 
+def cdist(x1, x2, p=2.0):
+    r"""
+    Computes p-norm distance between each pair of row vectors of two input Tensors.
+
+    Note:
+        On Ascend, the supported dtypes are float16 and float32.
+        On CPU, the supported dtypes are float16 and float32.
+        On GPU, the supported dtypes are float32 and float64.
+
+    Args:
+        x1 (Tensor): Input tensor of shape :math:`(B, P, M)`.
+            Letter :math:`B` represents 0 or positive int number.
+            When :math:`B` is equal to 0, it means this dimension can be ignored,
+            i.e. shape of the tensor is :math:`(P, M)`.
+        x2 (Tensor): Input tensor of shape :math:`(B, R, M)`, has the same dtype as `x1`.
+        p (float, optional): P value for the p-norm distance to calculate between each
+            vector pair, P >= 0. Default: ``2.0`` .
+
+    Returns:
+        Tensor, p-norm distance, has the same dtype as `x1`, its shape is :math:`(B, P, R)`.
+
+    Raises:
+        TypeError: If `x1` or `x2` is not Tensor.
+        TypeError: If dtype of `x1` or `x2` is not listed in the "Note" above.
+        TypeError: If `p` is not float32.
+        ValueError: If `p` is negative.
+        ValueError: If dimension of `x1` is not the same as `x2`.
+        ValueError: If dimension of `x1` or `x2` is neither 2 nor 3.
+        ValueError: If the batch dim of `x1` and `x2` can not broadcast.
+        ValueError: If the number of columns of `x1` is not the same as that of `x2`.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor(np.array([[[1.0, 1.0], [2.0, 2.0]]]).astype(np.float32))
+        >>> y = Tensor(np.array([[[3.0, 3.0], [3.0, 3.0]]]).astype(np.float32))
+        >>> output = ops.cdist(x, y, 2.0)
+        >>> print(output)
+        [[[2.8284273 2.8284273]
+          [1.4142137 1.4142137]]]
+    """
+    cdist_op = _get_cache_prim(Cdist)(p)
+    return cdist_op(x1, x2)
+
+
 def ceil(input):
     r"""
     Rounds a tensor up to the closest integer element-wise.
@@ -1322,6 +1657,42 @@ def clamp_tensor(input, min=None, max=None):
     return clamp_tensor_op(input, min, max)
 
 
+def clone(input):
+    r"""
+    Returns a copy of the input tensor.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Note:
+        This function is differentiable, and gradients will flow back directly from the calculation
+        result of the function to the `input`.
+
+    Args:
+        input (Tensor): A tensor to be copied.
+
+    Returns:
+        Tensor, with the same data, shape and type as `input`.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.ones((3,3)).astype("float32"))
+        >>> output = ops.auto_generate.clone(input)
+        >>> print(output)
+        [[1. 1. 1.]
+         [1. 1. 1.]
+         [1. 1. 1.]]
+    """
+    return clone_op(input)
+
+
 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.
@@ -1500,11 +1871,72 @@ def contiguous(input):
     return contiguous_op(input)
 
 
-def copy_ext(variable, value):
+def conv_transpose2d(input, weight, bias=None, stride=1, padding=0, output_padding=0, groups=1, dilation=1):
+    r"""
+    Applies a 2D transposed convolution operator over an input image composed of several input planes,
+    sometimes also called deconvolution (although it is not an actual deconvolution).
+
+    Refer to :class:`mindspore.mint.nn.ConvTranspose2d` for more details.
+
+    .. warning::
+        - This is an experimental API that is subject to change or deletion.
+        - In the scenario where inputs are non-contiguous, `output_padding` must be less than `stride` .
+        - For Atlas training products, when the dtype of input is float32, the `groups` only supports 1.
+
+    Args:
+        input (Tensor): input tensor of shape :math:`(minibatch, in\_channels, iH, iW)` or :math:`(in\_channels, iH, iW)` .
+        weight (Tensor): filters of shape :math:`(in\_channels, \frac{out\_channels}{\text{groups}}, kH, kW)` .
+        bias (Tensor, optional): bias of shape :math:`(out\_channels)` . Default: ``None`` .
+        stride (Union[int, tuple(int), list[int]], optional): the stride of the convolving kernel. Can be a single number or a
+            tuple :math:`(sH, sW)` . Default: ``1`` .
+        padding (Union[int, tuple(int), list[int]], optional): :math:`dilation * (kernel\_size - 1) - padding` zero-padding will
+            be added to both sides of each dimension in the input. Can be a single number or a tuple :math:`(padH, padW)` .
+            Default: ``0`` .
+        output_padding (Union[int, tuple(int), list[int]], optional): additional size added to one side of each dimension in the
+            output shape. Can be a single number or a tuple :math:`(out\_padH, out\_padW)` . The value of `output_padding` must
+            be less than `stride` or `dilation` . Default: ``0`` .
+        groups (int, optional): split input into groups, :math:`in\_channels` should be divisible by the
+            number of groups. Default: ``1`` .
+        dilation (Union[int, tuple(int), list[int]], optional): the spacing between kernel elements. Can be a single number or
+            a tuple :math:`(dH, dW)` . Default: ``1`` .
+
+    Returns:
+        Tensor of shape :math:`(minibatch, out\_channels, oH, oW)` or :math:`(out\_channels, oH, oW)` , where
+
+        .. math::
+            oH = (iH - 1) \times sH - 2 \times padH + dH \times (kH - 1) + out\_padH + 1
+        .. math::
+            oW = (iW - 1) \times sW - 2 \times padW + dW \times (kW - 1) + out\_padW + 1
+
+    Raises:
+        TypeError: If `stride`, `padding`, `output_padding` or `dilation` is neither an int nor a tuple or a list.
+        TypeError: If `groups` is not an int.
+        ValueError: If the shape of `bias` is not :math:`(out\_channels)` .
+        ValueError: If `stride` or `dilation` is less than 1.
+        ValueError: If `padding` or `output_padding` is less than 0.
+        ValueError: If `stride`, `padding`, `output_padding` or `dilation` is a tuple whose length is not equal to 2.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor(np.ones([1, 4, 5, 5]), mindspore.float32)
+        >>> weight = Tensor(np.ones([4, 8, 3, 3]), mindspore.float32)
+        >>> output = ops.conv_transpose2d(x, weight)
+        >>> print(output.shape)
+        (1, 8, 7, 7)
+    """
+    return conv_transpose2d_op(input, weight, bias, stride, padding, output_padding, groups, dilation)
+
+
+def convolution(input, weight, bias=None, stride=1, padding=0, dilation=1, transposed=False, output_padding=0, groups=1):
     r"""
     
     """
-    return copy_ext_op(variable, value)
+    return convolution_op(input, weight, bias, stride, padding, dilation, transposed, output_padding, groups)
 
 
 def copy(input):
@@ -1665,7 +2097,7 @@ def count_nonzero(input, dim=None):
     Args:
         input (Tensor): Input data is used to count non-zero numbers. With shape
             :math:`(*)` where :math:`*` means, any number of additional dimensions.
-        dim (Union[int, tuple(int), list(int)], optional): The dimension to reduce. Default value: ``None``, which indicates that the number of non-zero elements is calculated. If `dim` is ``None``, all elements in the tensor are summed up.
+        dim (Union[None, int, tuple(int), list(int)], optional): The dimension to reduce. Default value: ``None``, which indicates that the number of non-zero elements is calculated. If `dim` is ``None``, all elements in the tensor are summed up.
             
     Returns:
         Tensor, number of nonzero element across dim specified by `dim`.
@@ -1764,8 +2196,11 @@ def cummin_ext(input, dim):
             y_{i} = \min(x_{1}, x_{2}, ... , x_{i})
         \end{array}
 
-    Args:
-        input (Tensor): The input Tensor, The dimension must be greater than 0.
+    .. note::
+        O2 mode is not supported in Ascend.
+
+    Args:
+        input (Tensor): The input Tensor, The dimension must be greater than 0.
         dim (int): Operation dimension. The value of `dim` must be in the range `[-input.ndim, input.ndim - 1]`.
 
     Returns:
@@ -1778,9 +2213,6 @@ def cummin_ext(input, dim):
         TypeError: If `dim` is not an int.
         ValueError: If `dim` is out the range of `[-input.ndim, input.ndim - 1]`.
 
-    .. note::
-        O2 mode is not supported in Ascend.
-
     Supported Platforms:
         ``Ascend``
 
@@ -1909,7 +2341,7 @@ def dense(input, weight, bias=None):
 
     .. warning::
         - This is an experimental API that is subject to change or deletion.
-        - In PYNATIVE mode, if `bias` is not 1D, the `input` cannot be greater than 6D.
+        - In PyNative mode, if `bias` is not 1D, the `input` cannot be greater than 6D.
 
     Args:
         input (Tensor): Input Tensor of shape :math:`(*, in\_channels)`,
@@ -1926,7 +2358,7 @@ def dense(input, weight, bias=None):
         TypeError: If `input` is not Tensor.
         TypeError: If `weight` is not Tensor.
         TypeError: If `bias` is not Tensor.
-        RuntimeError: If `bias` is not 1D and `input` is greater than 6D in PYNATIVE mode.
+        RuntimeError: If `bias` is not 1D and `input` is greater than 6D in PyNative mode.
 
     Supported Platforms:
         ``Ascend`` ``GPU``  ``CPU``
@@ -2028,9 +2460,48 @@ def diagonal(input, offset=0, dim1=0, dim2=1):
     return diagonal_op(input)
 
 
-def dot(input, other):
+def divs(input, other):
     r"""
     
+    """
+    return divs_op(input, other)
+
+
+def dot(input, other):
+    r"""
+    Computes the dot product of two 1D tensor.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): The first input in the dot product, must be 1D.
+        other (Tensor): The second input in the dot product, must be 1D.
+
+    Returns:
+        Tensor, the shape is [] and the data type is same as `input`.
+
+    Raises:
+        TypeError: If dtype of `input`, `other` is not tensor.
+        TypeError: If dtype of `input`, `other` are not in float16, float32 or bfloat16.
+        RuntimeError: If dtypes of `input` and `other` are not same.
+        RuntimeError: If shapes of `input` and `other` are not same.
+        RuntimeError: If shapes of `input` and `other` are not 1D.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, mint
+        >>> x = Tensor([2.0, 3.0], mindspore.float32)
+        >>> y = Tensor([2.0, 1.0], mindspore.float32)
+        >>> dot = mint.dot()
+        >>> output = dot(x, y)
+        >>> print(output)
+        [7.        ]
+        >>> print(output.dtype)
+        Float32
     """
     return dot_op(input, other)
 
@@ -2293,14 +2764,14 @@ def erf(input):
 
     .. math::
 
-        erf(x)=\frac{2} {\sqrt{\pi}} \int\limits_0^{x} e^{-t^{2}} dt
+        \text{erf}(x)=\frac{2} {\sqrt{\pi}} \int\limits_0^{x} e^{-t^{2}} dt
 
     Args:
         input (Tensor): The input tensor of Gaussian error function. :math:`x` in the following formula.
             Supported dtypes: 
 
             - GPU/CPU: float16, float32, float64.
-            - Ascend: float16, float32, float64, int64, bool.
+            - Ascend: float16, float32, float64, int64, bool, bfloat16.
 
     Returns:
         Tensor, has the same shape as the `input`. 
@@ -2310,7 +2781,7 @@ def erf(input):
     :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.
+            * Ascend: If dtype of `input` is not float16, float32, float64, int64, bool, bfloat16.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -2333,7 +2804,7 @@ def erfc(input):
 
     .. math::
 
-        erfc(x) = 1 - \frac{2} {\sqrt{\pi}} \int\limits_0^{x} e^{-t^{2}} dt
+        \text{erfc}(x) = 1 - \frac{2} {\sqrt{\pi}} \int\limits_0^{x} e^{-t^{2}} dt
 
     Args:
         input (Tensor): The input tensor of the complementary error function, :math:`x` in the above formula. 
@@ -2409,6 +2880,38 @@ def erfinv(input):
     return erfinv_op(input)
 
 
+def exp2(input):
+    r"""
+    Calculates the base-2 exponent of the Tensor `input` element by element.
+
+    .. math::
+
+        out_i = 2^{input_i}
+
+    Args:
+        input (Tensor): The input Tensor.
+
+    Returns:
+        Tensor, which has the same 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
+        >>> x = Tensor(np.array([0.0, 1.0, 2.0, 4.0]), mindspore.float32)
+        >>> output = ops.exp2(x)
+        >>> print(output)
+        [ 1. 2. 4. 16.]
+    """
+    return exp2_op(input)
+
+
 def exp(input):
     r"""
     Returns exponential of a tensor element-wise.
@@ -2440,6 +2943,41 @@ def exp(input):
     return exp_op(input)
 
 
+def expand_as(input, other):
+    r"""
+    Broadcast the shape of the input tensor to be the same as the another input tensor. The dim of the
+    input shape must be smaller than or equal to that of another and the broadcast rules must be met.
+
+    Args:
+        input (Tensor): The input Tensor.
+        other (Tensor): The target Tensor. It's shape is the target shape that input tensor need to be broadcasted.
+
+    Returns:
+        Tensor, with the given shape of `other` and the same data type as `input`.
+
+    Raises:
+        TypeError: If `other` is not a tensor.
+        ValueError: If the shape of `other` and `input` are incompatible.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor
+        >>>  from mindspore.ops.function.array_func import expand_as
+        >>> x = Tensor(np.array([[1, 2, 3], [1, 2, 3]]).astype(np.float32))
+        >>> other = Tensor(np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]]).astype(np.float32))
+        >>> output = expand_as(x, other)
+        >>> print(output)
+        [[1. 2. 3.]
+         [1. 2. 3.]
+         [1. 2. 3.]]
+        >>> shape = (3, 3)
+    """
+    return expand_as_op(input, other)
+
+
 def expand_dims(input_x, axis):
     r"""
     Adds an additional dimension to `input_x` at the given axis, the dimension
@@ -3033,6 +3571,40 @@ def floor(input):
     return floor_op(input)
 
 
+def frac_ext(input):
+    r"""
+    Calculates the fractional part of each element in the input.
+
+    .. math::
+        out_i = input_i - \lfloor |input_i| \rfloor * sgn(input_i)
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): The input Tensor.
+
+    Returns:
+        Tensor, has the same shape and type as input.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor([2, 4.2, -2.5], mindspore.float16)
+        >>> output = ops.frac_ext(x)
+        >>> print(output)
+          [ 0.      0.1992 -0.5   ]
+    """
+    return frac_op(input)
+
+
 def gather_d(x, dim, index):
     r"""
     Gathers elements along an axis specified by dim.
@@ -3107,7 +3679,7 @@ def gather(input_params, input_indices, axis, batch_dims=0):
 
     The following figure shows the calculation process of Gather commonly:
 
-    .. image:: Gather.png
+    .. image:: ../images/Gather.png
 
     where params represents the input `input_params`, and indices represents the index to be sliced `input_indices`.
 
@@ -3188,8 +3760,7 @@ def gather(input_params, input_indices, axis, batch_dims=0):
 def gcd(input, other):
     r"""
     Computes greatest common divisor of input tensors element-wise.
-    The shape of two inputs should be broadcastable, and data type of them should be
-    one of: int32, int64.
+    The shape of two inputs should be broadcastable, and data types should be one of: int16 (supported when using the Ascend backend, Graph mode is only supported when the graph compilation level is O0), int32, int64.
 
     .. warning::
         This is an experimental API that is subject to change or deletion.
@@ -3265,6 +3836,20 @@ def geqrf(input):
     return geqrf_op(input)
 
 
+def gmm_backward(grad, x, weight, group_list=None):
+    r"""
+    
+    """
+    return gmm_backward_op(grad, x, weight, group_list)
+
+
+def gmm_v2_backward(grad, x, weight, group_list=None, group_list_type=0):
+    r"""
+    
+    """
+    return gmm_v2_backward_op(grad, x, weight, group_list, group_list_type)
+
+
 def greater_equal(input, other):
     r"""
     Given two Tensors, compares them element-wise to check if each element in the first
@@ -3330,6 +3915,13 @@ def greater(input, other):
     return greater_op(input, other)
 
 
+def hardtanh(input, min_val=-1, max_val=1):
+    r"""
+    
+    """
+    return hardtanh_op(input, min_val, max_val)
+
+
 def hfft2(input, s=None, dim=(-2, -1), norm=None):
     r"""
     Calculates the two dimensional discrete Fourier transform of of a Hermitian symmetric `input`.
@@ -3564,9 +4156,9 @@ def hardshrink(input, lambd=0.5):
         0, & \text{ otherwise }
         \end{cases}
 
-    HShrink Activation Function Graph:
+    HardShrink Activation Function Graph:
 
-    .. image:: ../images/HShrink.png
+    .. image:: ../images/Hardshrink.png
         :align: center
 
     Args:
@@ -3608,16 +4200,16 @@ def hardsigmoid(input):
     Hard Sigmoid is defined as:
 
     .. math::
-        \text{Hardswish}(input) =
+        \text{HardSigmoid}(input) =
         \begin{cases}
         0, & \text{ if } input \leq -3, \\
         1, & \text{ if } input \geq +3, \\
         input/6 + 1/2, & \text{ otherwise }
         \end{cases}
 
-    HSigmoid Activation Function Graph:
+    HardSigmoid Activation Function Graph:
 
-    .. image:: ../images/HSigmoid.png
+    .. image:: ../images/Hardsigmoid.png
         :align: center
 
     Args:
@@ -3652,16 +4244,16 @@ def hardswish(input):
     Hard swish is defined as:
 
     .. math::
-        \text{Hardswish}(input) =
+        \text{HardSwish}(input) =
         \begin{cases}
         0, & \text{ if } input \leq -3, \\
         input, & \text{ if } input \geq +3, \\
         input*(input + 3)/6, & \text{ otherwise }
         \end{cases}
 
-    HSwish Activation Function Graph:
+    HardSwish Activation Function Graph:
 
-    .. image:: ../images/HSwish.png
+    .. image:: ../images/Hardswish.png
         :align: center
 
     Args:
@@ -4178,6 +4770,70 @@ def unfold_ext(input, kernel_size, dilation=1, padding=0, stride=1):
     return im2col_ext_op(input, kernel_size, dilation, padding, stride)
 
 
+def index_fill_scalar(input, dim, index, value):
+    r"""
+    
+    """
+    return index_fill_scalar_op(input, dim, index, value)
+
+
+def index_fill_tensor(input, dim, index, value):
+    r"""
+    
+    """
+    return index_fill_tensor_op(input, dim, index, value)
+
+
+def index(input, indices):
+    r"""
+    Index the Tensor using an `indices`.
+
+    .. warning::
+        This is an experimental optimizer API that is subject to change.
+
+    Args:
+        input (Tensor): The input Tensor.
+        indices (tuple[Tensor], list[Tensor]): the indices of type is bool, uint8, int32 or int64, used to index into the `input`.
+            The size of indices should <= the rank of `input` and the tensors in indices should be broadcastable.
+            When the tensor types are bool and uint8, shape will match the input dimensions in turn. For example: the first tensor of `indices` is of type bool, 
+            Shape(x, y), `input` Shape(a, b, c), and (x, y) needs to match (a, b).
+
+
+    Returns:
+        Tensor, has the same dtype as input Tensor.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If the dtype of `indices` is not tuple[Tensor], list[Tensor].
+        TypeError: If the dtype of tensors in `indices` is not bool, uint8, int32 or int64.
+        ValueError: If the tensors in `indices` is not be broadcastable.
+        ValueError: If size(`indices`) > rank(`input`).
+        ValueError: If rank of `input` = 0.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> import mindspore
+        >>> from mindspore import Tensor, ops
+        >>> input1 = Tensor(np.array([[1, 2, 3], [4, 5, 6]]), mindspore.int32)
+        >>> indices1 = Tensor(np.array([0, 1, 1]), mindspore.int32)
+        >>> indices2 = Tensor(np.array([1, 2, 1]), mindspore.int32)
+        >>> output = ops.auto_generate.index(input1, [indices1, indices2])
+        >>> print(output)
+        [2 6 5]
+        >>> input2 = Tensor(np.arange(4 * 3 * 3).reshape(4, 3, 3), mindspore.int32)
+        >>> indices3 = Tensor(np.array([1, 0]), mindspore.int32)
+        >>> indices4 = Tensor(np.array([1, 1, 0]), mindspore.bool_)
+        >>> output2 = ops.auto_generate.index(input2, [indices3, indices4])
+        >>> print(output2)
+        [[ 9 10 11]
+         [ 3  4  5]]
+    """
+    return index_op(input, indices)
+
+
 def index_select_ext(input, dim, index):
     r"""
     Generates a new Tensor that accesses the values of `input` along the specified `dim` dimension
@@ -4231,18 +4887,241 @@ def inplace_add_ext(input, other, alpha=1):
     return inplace_add_ext_op(input, other, alpha)
 
 
-def inplace_addmm(input, mat1, mat2, beta=1, alpha=1):
+def inplace_adds_ext(input, other, alpha=1):
     r"""
     
     """
-    return inplace_addmm_op(input, mat1, mat2, beta, alpha)
+    return inplace_adds_ext_op(input, other, alpha)
 
 
-def inplace_adds_ext(input, other, alpha=1):
+def inplace_clamp_scalar(input, min=None, max=None):
     r"""
     
     """
-    return inplace_adds_ext_op(input, other, alpha)
+    return inplace_clamp_scalar_op(input, min, max)
+
+
+def inplace_clamp_tensor(input, min=None, max=None):
+    r"""
+    
+    """
+    return inplace_clamp_tensor_op(input, min, max)
+
+
+def inplace_copy(variable, value):
+    r"""
+    
+    """
+    return inplace_copy_op(variable, value)
+
+
+def div_tensor_(input, other):
+    r"""
+    
+    """
+    return inplace_div_op(input, other)
+
+
+def divmod_tensor_(input, other, rounding_mode=None):
+    r"""
+    
+    """
+    return inplace_divmod_op(input, other, rounding_mode)
+
+
+def divmod_scalar_(input, other, rounding_mode=None):
+    r"""
+    
+    """
+    return inplace_divmods_op(input, other, rounding_mode)
+
+
+def div_scalar_(input, other):
+    r"""
+    
+    """
+    return inplace_divs_op(input, other)
+
+
+def inplace_fill_scalar(input, value):
+    r"""
+    
+    """
+    return inplace_fill_scalar_op(input, value)
+
+
+def inplace_fill_tensor(input, value):
+    r"""
+    
+    """
+    return inplace_fill_tensor_op(input, value)
+
+
+def floor_(input):
+    r"""
+    
+    """
+    return inplace_floor_op(input)
+
+
+def inplace_hardtanh(input, min_val=-1, max_val=1):
+    r"""
+    Update the `input` tensor in-place by computing the hardtanh activation function `input`, The activation 
+    function is defined as:
+
+    .. math::
+        \text{hardtanh}(input) = \begin{cases}
+         max\_val, & \text{ if } input > max\_val \\
+         min\_val, & \text{ if } input < min\_val \\
+         input, & \text{ otherwise. }
+        \end{cases}
+
+    Linear region range :math:`[min\_val, max\_val]` can be adjusted using `min_val` and `max_val`.
+
+    Hardtanh Activation Function Graph:
+
+    .. image:: ../images/Hardtanh.png
+        :align: center
+
+    .. warning::
+        This is an experimental optimizer API that is subject to change.
+
+    Args:
+        input (Tensor): Input Tensor.
+        min_val (Union[bool, int, float], optional): Minimum value of the linear region range. Default: ``-1.0`` .
+        max_val (Union[bool, int, float], optional): Maximum value of the linear region range. Default: ``1.0`` .
+
+    Returns:
+        Tensor.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If dtype of `input` is not one of: int8, int16, int32, int64, uint8, float16, float32, bfloat16.
+        TypeError: If dtype of `min_val` is neither float nor int.
+        TypeError: If dtype of `max_val` is neither float nor int.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, mint
+        >>> x = Tensor([-1, -2, 0, 2, 1], mindspore.float16)
+        >>> mint.hardtanh_(x, min_val=-1.0, max_val=1.0)
+        >>> print(x)
+        [-1. -1.  0.  1.  1.]
+    """
+    return inplace_hardtanh_op(input, min_val, max_val)
+
+
+def index_put_(input, indices, values, accumulate=False):
+    r"""
+    Based on the indices in `indices`, replace the corresponding elements in Tensor `self` with the values
+    in `values`. The expression `Tensor.index_put_(indices, values)` is equivalent to `tensor[indices] = values`.
+    Update and return `self`.
+
+    .. warning::
+        The behavior is unpredictable in the following scenario:
+
+        - If `accumulate` is `False` and `indices` contains duplicate elements.
+
+    Args:
+        indices (tuple[Tensor], list[Tensor]): the indices of type is bool, uint8, int32 or int64,
+            used to index into the `self`. The size of indices should <=  the rank of `self`
+            and the tensors in indices should be broadcastable.
+        values (Tensor): Tensor with the same type as `self`. If size == 1, it will be broadcastable.
+        accumulate (bool, optional): If `accumulate` is `True`, the elements in `values` will be added to `self`,
+            otherwise the elements in `values` will replace the corresponding elements in the `self`.
+            Default: ``False``.
+
+    Returns:
+        Tensor `self`.
+
+    Raises:
+        TypeError: If the dtype of the `self` is not equal to the dtype of `values`.
+        TypeError: If the dtype of `indices` is not tuple[Tensor], list[Tensor].
+        TypeError: If the dtype of tensors in `indices` are not bool, uint8, int32 or int64.
+        TypeError: If the dtypes of tensors in `indices` are inconsistent.
+        TypeError: If the dtype of `accumulate` is not bool.
+        ValueError: If size(`values`) is not 1 or max size of the tensors in `indices` when
+            rank(`self`) == size(`indices`).
+        ValueError: If size(`values`) is not 1 or `self`.shape[-1] when rank(`self`) > size(`indices`).
+        ValueError: If the tensors in `indices` is not be broadcastable.
+        ValueError: If size(`indices`) > rank(`self`).
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> import mindspore
+        >>> from mindspore import Tensor
+        >>> x = Tensor(np.array([[1, 2, 3], [4, 5, 6]]).astype(np.int32))
+        >>> values = Tensor(np.array([3]).astype(np.int32))
+        >>> indices = [Tensor(np.array([0, 1, 1]).astype(np.int32)), Tensor(np.array([1, 2, 1]).astype(np.int32))]
+        >>> accumulate = True
+        >>> output = x.index_put_(indices, values, accumulate)
+        >>> print(output)
+        [[1 5 3]
+         [4 8 9]]
+    """
+    return inplace_index_put_op(input, indices, values, accumulate)
+
+
+def masked_fill_scalar_(input, mask, value):
+    r"""
+    
+    """
+    return inplace_masked_fill_scalar_op(input, mask, value)
+
+
+def masked_fill_tensor_(input, mask, value):
+    r"""
+    
+    """
+    return inplace_masked_fill_tensor_op(input, mask, value)
+
+
+def inplace_mul(input, other):
+    r"""
+    
+    """
+    return inplace_mul_op(input, other)
+
+
+def inplace_muls(input, other):
+    r"""
+    
+    """
+    return inplace_muls_op(input, other)
+
+
+def inplace_scatter_add(input, dim, index, src):
+    r"""
+    
+    """
+    return inplace_scatter_add_op(input, dim, index, src)
+
+
+def sub_tensor_(input, other, alpha=1):
+    r"""
+    
+    """
+    return inplace_sub_ext_op(input, other, alpha)
+
+
+def sub_scalar_(input, other, alpha=1):
+    r"""
+    
+    """
+    return inplace_sub_scalar_op(input, other, alpha)
+
+
+def tanh_(input):
+    r"""
+    
+    """
+    return inplace_tanh_op(input)
 
 
 def zero_(input):
@@ -4418,7 +5297,7 @@ def irfftn(input, s=None, dim=None, norm=None):
     return irfftn_op(input, s, dim, norm)
 
 
-def isfinite(x):
+def isfinite(input):
     r"""
     Determine which elements are finite for each position. If elements are not ``NaN`` , ``-INF`` , ``INF``,
     they are finite.
@@ -4431,13 +5310,13 @@ def isfinite(x):
         \end{cases}
 
     Args:
-      x (Tensor): The input tensor.
+      input (Tensor): The input tensor.
 
     Returns:
         Tensor, has the same shape of input, and the dtype is bool.
 
     Raises:
-        TypeError: If x is not a Tensor.
+        TypeError: If `input` is not a Tensor.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -4455,7 +5334,83 @@ def isfinite(x):
         >>> print(output)
         True
     """
-    return isfinite_op(x)
+    return isfinite_op(input)
+
+
+def isinf(input):
+    r"""
+    Determines which elements are inf or -inf for each position.
+
+    .. math::
+
+        out_i = \begin{cases}
+          & \ True,\ \text{ if } x_{i} = \text{Inf} \\
+          & \ False,\ \text{ if } x_{i} \ne  \text{Inf}
+        \end{cases}
+
+    where Inf means value is infinite.
+
+    .. warning::
+        - This is an experimental API that is subject to change.
+        - For Ascend, it is only supported on platforms above Atlas A2.
+
+    Args:
+        input (Tensor): The input tensor.
+
+    Returns:
+        Tensor, has the same shape of input, and the dtype is bool.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend`` ``CPU`` ``GPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor(np.array([np.log(-1), 1, np.log(0)]), mindspore.float32)
+        >>> output = ops.isinf(x)
+        >>> print(output)
+        [False False True]
+        >>> x = Tensor(2.1, mindspore.float64)
+        >>> output = ops.isinf(x)
+        >>> print(output)
+        False
+    """
+    return isinf_op(input)
+
+
+def isneginf_ext(input):
+    r"""
+    Determines which elements are -inf for each position.
+
+    .. warning::
+        - This is an experimental API that is subject to change.
+        - This API can be used only on the Atlas A2 training series.
+
+    Args:
+        input (Tensor): Input Tensor.
+
+    Returns:
+        Tensor with the same shape as the input, where elements are `True` if the corresponding element in the `input` is negative infinity, and `False` otherwise.
+
+    Raises:
+        TypeError: If the input is not a tensor.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> from mindspore import ops, Tensor
+        >>> from mindspore import dtype as mstype
+        >>> output = ops.isneginf(Tensor([[-float("inf"), float("inf")], [1, -float("inf")]], mstype.float32))
+        >>> print(output)
+        [[ True False]
+         [False  True]]
+    """
+    return isneginf_op(input)
 
 
 def l1_loss_ext(input, target, reduction='mean'):
@@ -4539,7 +5494,7 @@ def leaky_relu_ext(input, negative_slope=0.01):
 
     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.
+        negative_slope (Union[int, float], optional): Slope of the activation function when the element of `input` is less than 0.
           Default: ``0.01`` .
 
     Returns:
@@ -4564,6 +5519,62 @@ def leaky_relu_ext(input, negative_slope=0.01):
     return leaky_relu_ext_op(input, negative_slope)
 
 
+def lerp(input, end, weight):
+    r"""
+    Does a linear interpolation of two tensors start and end based on a float or tensor weight.
+
+    If `weight` is a tensor, the shapes of three inputs need to be broadcast;
+    If `weight` is a float, the shapes of `input` and `end` need to be broadcast.
+    If `weight` is a float and platform is Ascend, the types of `input` and `end` need to be float32.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    .. math::
+        output_{i} = input_{i} + weight_{i} * (end_{i} - input_{i})
+
+    Args:
+        input (Tensor): The tensor with the starting points. Data type must be float16 or float32.
+        end (Tensor): The tensor with the ending points. Data type must be the same as `input`.
+        weight (Union[float, Tensor]): The weight for the interpolation formula. Must be a float scalar
+            or a tensor with float16 or float32 data type.
+
+    Returns:
+        Tensor, has the same type and shape as input `input`.
+
+    Raises:
+        TypeError: If `input` or `end` is not a tensor.
+        TypeError: If `weight` is neither scalar(float) nor tensor.
+        TypeError: If dtype of `input` or `end` is neither float16 nor float32.
+        TypeError: If dtype of `weight` is neither float16 nor float32 when it is a tensor.
+        TypeError: If `input` and `end` have different data types.
+        TypeError: If `input`, `end` and `weight` have different data types when `weight` is a tensor.
+        ValueError: If `end` could not be broadcast to a tensor with shape of `input`.
+        ValueError: If `weight` could not be broadcast to tensors with shapes of `input` and `end` when it is a tensor.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> start = Tensor(np.array([1., 2., 3., 4.]), mindspore.float32)
+        >>> end = Tensor(np.array([10., 10., 10., 10.]), mindspore.float32)
+        >>> output = ops.lerp(start, end, 0.5)
+        >>> print(output)
+        [5.5 6. 6.5 7. ]
+    """
+    return lerp_op(input, end, weight)
+
+
+def lerp_scalar(input, end, weight):
+    r"""
+    
+    """
+    return lerp_scalar_op(input, end, weight)
+
+
 def less_equal(input, other):
     r"""
     Computes the boolean value of :math:`input <= other` element-wise.
@@ -4648,6 +5659,45 @@ def less(input, other):
     return less_op(input, other)
 
 
+def log10_ext(input):
+    r"""
+    Returns the logarithm to the base 10 of a tensor element-wise.
+
+    .. math::
+        y_i = \log_{10}(x_i)
+
+    .. warning::
+        - This is an experimental API that is subject to change or deletion.
+        - If the input value of operator Log10 is within the range (0, 0.01] or [0.95, 1.05], the output accuracy
+          may be affacted.
+
+    Args:
+        input (Tensor): Input Tensor of any dimension. The value must be greater than 0.
+
+    Returns:
+        Tensor, has the same shape as the `input`, and the dtype changes according to the `input.dtype`.
+        
+        - if `input.dtype` is in [float16, float32, float64, bfloat16], the output dtype is the same as the `input.dtype`.
+        - if `input.dtype` is integer or boolean type, the output dtype is float32.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, mint
+        >>> x = Tensor(np.array([3.0, 5.0, 7.0]), mindspore.float32)
+        >>> output = mint.log10(x)
+        >>> print(output)
+        [0.47712136 0.69897    0.845098  ]
+    """
+    return log10_op(input)
+
+
 def log1p(input):
     r"""
     Returns the natural logarithm of one plus the input tensor element-wise.
@@ -4679,6 +5729,45 @@ def log1p(input):
     return log1p_op(input)
 
 
+def log2_ext(input):
+    r"""
+    Returns the logarithm to the base 2 of a tensor element-wise.
+
+    .. math::
+        y_i = \log_2(x_i)
+
+    .. warning::
+        - This is an experimental API that is subject to change or deletion.
+        - If the input value of operator Log2 is within the range (0, 0.01] or [0.95, 1.05], the output accuracy
+          may be affacted.
+
+    Args:
+        input (Tensor): Input Tensor of any dimension. The value must be greater than 0.
+
+    Returns:
+        Tensor, has the same shape as the `input`, and the dtype changes according to the `input.dtype`.
+        
+        - if `input.dtype` is in [float16, float32, float64, bfloat16], the output dtype is the same as the `input.dtype`.
+        - if `input.dtype` is integer or boolean type, the output dtype is float32.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, mint
+        >>> x = Tensor(np.array([3.0, 5.0, 7.0]), mindspore.float32)
+        >>> output = mint.log2(x)
+        >>> print(output)
+        [1.5849625 2.321928  2.807355 ]
+    """
+    return log2_op(input)
+
+
 def log(input):
     r"""
     Returns the natural logarithm of a tensor element-wise.
@@ -4837,11 +5926,58 @@ def logaddexp_ext(input, other):
     return logaddexp_op(input, other)
 
 
-def logsigmoid_grad(dy, input, buffer):
-    r"""
-    
+def logsigmoid_grad(dy, input, buffer):
+    r"""
+    
+    """
+    return logsigmoid_grad_op(dy, input, buffer)
+
+
+def logsumexp_ext(input, dim, keepdim=False):
+    r"""
+    Computes the logarithm of the sum of exponentiations of all elements along the specified `dim` dimension of the `input` (with numerical stabilization), and retains the dimension based on the `keepdim` parameter.
+
+    .. math::
+
+        logsumexp(input) = \log(\sum(e^{input-input_{max}})) + input_{max}
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): Input Tensor.
+        dim (Union[int, tuple(int), list(int)], optional): The dimension to be reduced (the value should be within `[0, len(input.shape) - 1]`), when the `dim` is `()`, all dimensions are reduced.
+        keepdim (bool, optional): Whether the output tensor retains the dimension `dim`, default: `False`.
+
+    Returns:
+        Tensor, the dtype changes according to the `input.dtype`, and the shape changes according to the values of `dim` and `keepdim`.
+
+        - If `input.dtype` is in [float16, float32, bfloat16], the output dtype is the same as the `input.dtype`.
+        - If `input.dtype` is an integer or boolean type, the output dtype is float32.
+        - If `dim` is (), and `keepdim` is False, the output is a 0-D tensor representing the logarithm of the sum of exponentiations of all elements in the `input` tensor.
+        - If `dim` is `1`, and `keepdim` is False, the shape of output is :math:`(input.shape[0], input.shape[2], ..., input.shape[n])`.
+        - If `dim` is `(1, 2)`, and `keepdim` is False, the shape of output is :math:`(input.shape[0], input.shape[3], ..., input.shape[n])`.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If dtype of `input` is not one of: bool, int8, int16, int32, int64, uint8, float16, float32, bfloat16.
+        TypeError: If `dim` is not an int or tuple(int) or list(list).
+        TypeError: If `keepdim` is not a bool.
+        ValueError: If the value of any elements of `dim` is not in the range `[0, len(input.shape) - 1]`.
+        RuntimeError: If any element of `dim` is repeated.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor(np.random.randn(3, 4, 5, 6).astype(np.float32))
+        >>> output = ops.auto_generate.logsumexp_ext(x, 1, keepdim=True)
+        >>> print(output.shape)
+        (3, 1, 5, 6)
     """
-    return logsigmoid_grad_op(dy, input, buffer)
+    return logsumexp_op(input, dim, keepdim)
 
 
 def masked_fill(input_x, mask, value):
@@ -4864,7 +6000,7 @@ def masked_fill(input_x, mask, value):
         ValueError: If the shapes of `input_x` and `mask` could not be broadcast.
         TypeError: If dtype of `input_x` or `value` is not one of bool, uint8, int8, int16, int32,
             int64, float16, float32, float64, complex64, complex128.
-        TypeError: If dtype of `value` is different from that of `input_x`.
+        TypeError: If dtype of `value` is different from that of `input_x` in CPU and GPU.
         TypeError: If `value` is neither float number nor Tensor.
 
     Supported Platforms:
@@ -4915,11 +6051,11 @@ def masked_select(input, mask):
     return masked_select_op(input, mask)
 
 
-def matmul_ext(input, mat2):
+def matmul_ext(input, other):
     r"""
     
     """
-    return matmul_ext_op(input, mat2)
+    return matmul_ext_op(input, other)
 
 
 def matrix_exp(input):
@@ -5001,6 +6137,57 @@ def max_(input):
     return max_op(input)
 
 
+def max_unpool2d_ext(input, indices, kernel_size, stride=None, padding=0, output_size=None):
+    r"""
+    Computes the inverse of `max_pool2d`.
+
+    `max_unpool2d` keeps the maximal value and set all position of non-maximal values to zero. Typically the input is of shape :math:`(N, C, H_{in}, W_{in})` or :math:`(C, H_{in}, W_{in})`, and the output is of shape :math:`(N, C, H_{out}, W_{out})` or :math:`(C, H_{out}, W_{out})`. The operation is as follows.
+
+    .. math::
+        \begin{array}{ll} \\
+        H_{out} = (H_{in} - 1) \times stride[0] - 2 \times padding[0] + kernel\_size[0] \\
+        W_{out} = (W_{in} - 1) \times stride[1] - 2 \times padding[1] + kernel\_size[1] \\
+        \end{array}
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): The input Tensor to invert. Tensor of shape :math:`(N, C, H_{in}, W_{in})` or :math:`(C, H_{in}, W_{in})`.
+        indices (Tensor): Max values' index represented by the indices. Tensor of shape must be same with input 'input'. Values of indices must belong to :math:`[0, H_{in} \times W_{in} - 1]`. Data type must be in int32 or int64.
+        kernel_size (Union[int, tuple[int]]): The size of kernel used to take the maximum value, an int number that represents height and width of the kernel, or a tuple of two int numbers that represent height and width respectively.
+        stride (Union[int, tuple[int]], optional): The distance of kernel moving, an int number that represents the height and width of movement are both stride, or a tuple of two int numbers that represent height and width of movement respectively. Default: ``None`` , which indicates the moving step is `kernel_size` .
+        padding (Union[int, tuple[int]], optional): The pad value to be filled. Default: ``0`` . If `padding` is an integer, the paddings of height and width are the same, equal to padding. If `padding` is a tuple of two integers, the padding of height and width equal to padding[0] and padding[1] correspondingly.
+        output_size (tuple[int], optional): The target output size. Default: ``None`` . If output_size == (), then the shape of output computed by `kernel_size`, `stride` and `padding`. If output_size != (), then output_size must be :math:`(N, C, H, W)` , :math:`(C, H, W)` or :math:`(H, W)` and output_size must belong to :math:`[(N, C, H_{out} - stride[0], W_{out} - stride[1]), (N, C, H_{out} + stride[0], W_{out} + stride[1])]`.
+
+    Returns:
+        Tensor, with shape :math:`(N, C, H_{out}, W_{out})` or :math:`(C, H_{out}, W_{out})`, with the same data type with `input`.
+
+    Raises:
+        TypeError: If data type of `input` or `indices` is not supported.
+        TypeError: If `kernel_size`, `stride` or `padding` is neither an int nor a tuple.
+        ValueError: If numbers in `stride`, `padding` or `kernel_size` are not positive.
+        ValueError: If the shapes of `input` and `indices` are different.
+        ValueError: If the length of `input` is not 3 or 4.
+        ValueError: If the type of `output_size` is not tuple.
+        ValueError: If `output_size` is not close to output size computed by attr `kernel_size`, `stride`, `padding`.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([[[[0, 1], [8, 9]]]]).astype(np.float32))
+        >>> indices = Tensor(np.array([[[[0, 1], [2, 3]]]]).astype(np.int64))
+        >>> output = ops.max_unpool2d_ext(input, indices, 1, stride=1, padding=0)
+        >>> print(output.asnumpy())
+        [[[[0. 1.]
+           [8. 9.]]]]
+    """
+    return max_unpool2d_ext_op(input, indices, kernel_size, stride, padding, output_size)
+
+
 def maximum(input, other):
     r"""
     Computes the maximum of input tensors element-wise.
@@ -5019,8 +6206,8 @@ def maximum(input, other):
         - If one of the elements being compared is a NaN, then that element is returned.
 
     .. warning::
-        If all inputs are scalar of integers. In GRAPH mode, the output will be Tensor of int32, while in
-        PYNATIVE mode, the output will be Tensor of int64.
+        If all inputs are scalar of integers. In Graph mode, the output will be Tensor of int32, while in
+        PyNative mode, the output will be Tensor of int64.
 
     Args:
         input (Union[Tensor, Number, bool]): The first input is a number or
@@ -5059,42 +6246,42 @@ def maximum(input, other):
     return maximum_op(input, other)
 
 
-def mean_ext(input, axis=None, keep_dims=False, dtype=None):
+def mean_ext(input, dim=None, keepdim=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`
+    And reduce a dimension of `input` along the specified `dim`. `keepdim`
     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.
+        The `dim` 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`` ,
+        dim (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.
+        keepdim (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`` ,
+        - If `dim` is ``None`` , and `keepdim` 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`` ,
+        - If `dim` is int, set as 1, and `keepdim` 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`` ,
+        - If `dim` is tuple(int), set as (1, 2), and `keepdim` 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`` ,
+        - If `dim` is 1-D Tensor, set as [1, 2], and `keepdim` 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.
+        TypeError: If `dim` is not one of the following: int, tuple, list or Tensor.
+        TypeError: If `keepdim` is not a bool.
+        ValueError: If `dim` is out of range.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -5104,7 +6291,7 @@ def mean_ext(input, axis=None, keep_dims=False, dtype=None):
         >>> 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)
+        >>> output = ops.mean_ext(x, 1, keepdim=True)
         >>> result = output.shape
         >>> print(result)
         (3, 1, 5, 6)
@@ -5113,25 +6300,25 @@ def mean_ext(input, axis=None, keep_dims=False, dtype=None):
         ... [[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)
+        >>> output = ops.mean_ext(x)
         >>> print(output)
         5.0
         >>> print(output.shape)
         ()
-        >>> # case 2: Reduces a dimension along the axis 0
-        >>> output = ops.mean(x, 0, True)
+        >>> # case 2: Reduces a dimension along the dim 0
+        >>> output = ops.mean_ext(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)
+        >>> # case 3: Reduces a dimension along the dim 1
+        >>> output = ops.mean_ext(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)
+        >>> # case 4: Reduces a dimension along the dim 2
+        >>> output = ops.mean_ext(x, 2, True)
         >>> print(output)
         [[[ 2.]
         [ 2.]
@@ -5143,7 +6330,7 @@ def mean_ext(input, axis=None, keep_dims=False, dtype=None):
         [ 8.]
         [10.]]]
     """
-    return mean_ext_op(input, axis, keep_dims, dtype)
+    return mean_ext_op(input, dim, keepdim, dtype)
 
 
 def min_(input):
@@ -5159,6 +6346,9 @@ def minimum(input, other):
     r"""
     Computes the minimum of input tensors element-wise.
 
+    .. math::
+        output_i = \min(input_i, other_i)
+
     Note:
         - Inputs of `input` and `other` comply with the implicit type conversion rules to make the data types
           consistent.
@@ -5167,9 +6357,6 @@ def minimum(input, other):
         - Shapes of them are supposed to be broadcast.
         - If one of the elements being compared is a NaN, then that element is returned.
 
-    .. math::
-        output_i = \min(input_i, other_i)
-
     Args:
         input (Union[Tensor, Number, bool]): The first input is a number or
             a bool or a tensor whose data type is number or bool.
@@ -5253,6 +6440,50 @@ def mish_ext(input):
     return mish_ext_op(input)
 
 
+def mm_ext(input, mat2):
+    r"""
+    Returns the matrix product of two arrays.
+    If `input` is a :math:`(n \times m)` Tensor, `mat2` is a
+    :math:`(m \times p)` Tensor, `out` will be a :math:`(n \times p)` Tensor.
+
+    Note:
+        This function cannot support broadcasting.
+        Refer to :func:`mindspore.ops.matmul` instead if you need a broadcastable function.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): The first matrix of matrix multiplication.
+            The last dimension of `input` must be the same size as the first dimension of `mat2`.
+        mat2 (Tensor): The second matrix of matrix multiplication.
+            The last dimension of `input` must be the same size as the first dimension of `mat2`.
+
+    Returns:
+        Tensor, the matrix product of the inputs.
+
+    Raises:
+        ValueError: If the last dimension of `input` is not the same size as the
+            second-to-last dimension of `mat2`.
+        TypeError: If `input` or `mat2` is not a Tensor.
+        TypeError: If dtype of `input` or `mat2` is not float16, float32 or bfloat16.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> from mindspore import ops
+        >>> import numpy as np
+        >>> x1 = ms.Tensor(np.random.rand(2, 3), ms.float32)
+        >>> x2 = ms.Tensor(np.random.rand(3, 4), ms.float32)
+        >>> out = ops.mm_ext(x1, x2)
+        >>> print(out.shape)
+        (2, 4)
+    """
+    return mm_ext_op(input, mat2)
+
+
 def mse_loss_ext(input, target, reduction='mean'):
     r"""
     Calculates the mean squared error between the predicted value and the label value.
@@ -5356,7 +6587,38 @@ def muls(input, other):
 
 def mv(input, vec):
     r"""
-    
+    Multiply matrix `input` and vector `vec`.
+    If `input` is a tensor with shape :math:`(N, M)` and `vec` is a tensor with shape :math:`(M,)`,
+    The output is a 1-D tensor which shape is :math:`(N,)`.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): The input matrix which shape is :math:`(N,M)` and the rank must be 2-D.
+        vec (Tensor): The input vector which shape is :math:`(M,)` and the rank is 1-D.
+
+    Returns:
+        Tensor, the shape is :math:`(N,)`.
+
+    Raises:
+        TypeError: If `input` or `vec` is not a tensor.
+        TypeError: If the dtype of `input` or `vec` is not float16 or float32.
+        TypeError: If the dtypes of `input` and `vec` are different.
+        ValueError: If the `input` is not a 2-D tensor or the `vec` is not a 1-D tensor.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, mint
+        >>> input = Tensor(np.array([[3., 4.], [1., 6.], [1., 3.]]).astype(np.float32))
+        >>> vec = Tensor(np.array([1., 2.]).astype(np.float32))
+        >>> output = mint.mv(input, vec)
+        >>> print(output)
+        [11. 13. 7.]
     """
     return mv_op(input, vec)
 
@@ -5399,6 +6661,46 @@ def nan_to_num(input, nan=None, posinf=None, neginf=None):
     return nan_to_num_impl(input, nan, posinf, neginf)
 
 
+def narrow(input, dim, start, length):
+    r"""
+    Obtains a tensor of a specified length at a specified start position along a specified axis.
+
+    Args:
+        input (Tensor): the tensor to narrow.
+        dim (int): the axis along which to narrow.
+        start (Union[int, Tensor[int]]): the starting dimension.
+        length (int): the distance to the ending dimension.
+
+    Returns:
+        output (Tensors) - The narrowed tensor.
+
+    Raises:
+        ValueError: the rank of `input` is 0.
+        ValueError: the value of `dim` is out the range [-input.ndim, input.ndim).
+        ValueError: the value of `start` is out the range [-input.shape[dim], input.shape[dim]].
+        ValueError: the value of `length` is out the range [0, input.shape[dim]-start].
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import mint
+        >>> from mindspore import Tensor
+        >>> x = Tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], mindspore.int32)
+        >>> output = mint.narrow(x, 0, 0, 2)
+        >>> print(output)
+        [[ 1 2 3]
+         [ 4 5 6]]
+        >>> output = mint.narrow(x, 1, 1, 2)
+        >>> print(output)
+        [[ 2 3]
+         [ 5 6]
+         [ 8 9]]
+    """
+    return narrow_op(input, dim, start, length)
+
+
 def neg(input):
     r"""
     Returns a tensor with negative values of the input tensor element-wise.
@@ -5439,10 +6741,6 @@ def nextafter(input, other):
     then the next representable of :math:`a` towards :math:`b` is :math:`a+eps`,
     the next representable of :math:`b` towards :math:`a` is :math:`b-eps`.
 
-    .. math::
-
-        out_{i} =  nextafter({input_{i}, other_{i}})
-
     For more detailed information, refer to `A Self Regularized Non-Monotonic Neural Activation Function <https://arxiv.org/abs/1908.08681>`_.
 
     Args:
@@ -5662,34 +6960,34 @@ def prelu(input, weight):
     return prelu_op(input, weight)
 
 
-def prod_ext(input, axis=None, keep_dims=False, dtype=None):
+def prod_ext(input, dim=None, keepdim=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`.
+    reduce a dimension of `input` along the `dim`. Determine whether the dimensions of the output and input are the
+    same by controlling `keepdim`.
 
     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.
+        dim (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.
+        keepdim (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`` ,
+        - If `dim` is ``None`` , and `keepdim` 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`` ,
+        - If `dim` is int, set as 1, and `keepdim` 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.
+        TypeError: If `dim` is not one of the following: int or None.
+        TypeError: If `keepdim` is not a bool.
+        ValueError: If `dim` is out of range.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -5699,7 +6997,7 @@ def prod_ext(input, axis=None, keep_dims=False, dtype=None):
         >>> 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)
+        >>> output = ops.prod_ext(x, 1, keepdim=True)
         >>> result = output.shape
         >>> print(result)
         (3, 1, 5, 6)
@@ -5707,25 +7005,25 @@ def prod_ext(input, axis=None, keep_dims=False, dtype=None):
         >>> 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)
+        >>> output = ops.prod_ext(x)
         >>> print(output)
         2.2833798e+33
         >>> print(output.shape)
         ()
-        >>> # case 2: Reduces a dimension along axis 0.
-        >>> output = ops.ProdExt()(x, 0, True)
+        >>> # case 2: Reduces a dimension along dim 0.
+        >>> output = ops.prod_ext(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)
+        >>> # case 3: Reduces a dimension along dim 1.
+        >>> output = ops.prod_ext(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)
+        >>> # case 4: Reduces a dimension along dim 2.
+        >>> output = ops.prod_ext(x, 2, True)
         >>> print(output)
         [[[1.00000e+00]
         [6.40000e+01]
@@ -5737,7 +7035,7 @@ def prod_ext(input, axis=None, keep_dims=False, dtype=None):
         [2.62144e+05]
         [5.31441e+05]]]
     """
-    return prod_ext_op(input, axis, keep_dims, dtype)
+    return prod_ext_op(input, dim, keepdim, 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'):
@@ -6043,6 +7341,7 @@ def relu(input):
 
     Args:
         input (Tensor): The input Tensor.
+        inplace (bool, optional): Whether to use inplace mode, Defaults to ``False``.
 
     Returns:
         Tensor, with the same dtype and shape as the `input`.
@@ -6723,7 +8022,6 @@ def select_ext(input, dim, index):
         >>> from mindspore import Tensor, mint
         >>> input = Tensor([[2, 3, 4, 5],[3, 2, 4, 5]])
         >>> y = mint.select(input, 0, 0)
-        >>> y = Tensor([1,2], mindspore.float32)
         >>> print(y)
         [2 3 4 5]
         
@@ -6952,7 +8250,7 @@ def sign(input):
         >>> print(output)
         [[-1  0  1  1  1]
          [ 1  1  1 -1  0]]
-        >>> ms.set_context(device_target="CPU")
+        >>> ms.set_device(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)
@@ -7380,7 +8678,7 @@ def stack_ext(tensors, dim=0):
 
     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`` .
+        dim (int, optional): Dimension to stack. The range is [-(R+1), R+1). Default: ``0`` .
 
     Returns:
         Tensor. A stacked Tensor with the same type as `tensors`.
@@ -7388,7 +8686,7 @@ 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);
-                    or if the shapes of elements in tensors are not the same.
+                    or if the shapes of elements in `tensors` are not the same.
 
     Supported Platforms:
         ``Ascend``
@@ -7670,6 +8968,19 @@ def sub(input, other):
     return sub_op(input, other)
 
 
+def sum_ext(input, dim=None, keepdim=False, dtype=None):
+    r"""
+    Alias for :func:`mindspore.mint.transpose` . The `input` corresponds to the `input` in the reference interface,
+    and the parameters `axis0` and `axis1` correspond to `dim0` and `dim1` in the reference interface respectively.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Refer to :func:`mindspore.mint.transpose` for more details.
+    """
+    return sum_ext_op(input, dim, keepdim, dtype)
+
+
 def swiglu_grad(grad_output, input, dim=-1):
     r"""
     
@@ -7682,6 +8993,9 @@ def swiglu(input, dim=-1):
     Computes SwiGLU (Swish-Gated Linear Unit activation function) of input tensor.
     SwiGLU is a variant of the :class:`mindspore.ops.GLU` activation function, it is defined as:
 
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
     .. math::
         {SwiGLU}(a, b)= Swish(a) \otimes b
 
@@ -7715,6 +9029,41 @@ def swiglu(input, dim=-1):
     return swiglu_op(input, dim)
 
 
+def t_ext(input):
+    r"""
+    Transpose the input tensor.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): The input tensor.
+
+    Returns:
+        Tensor, transpose 2D tensor, return 1D tensor as it is.
+
+    Raises:
+        ValueError: If the dimension of `input` is greater than 2.
+        ValueError: If `input` is empty.
+        TypeError: If `input` is not a tensor.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([[1, 2, 3], [4, 5, 6]]), mindspore.float32)
+        >>> output = ops.t_ext(input)
+        >>> print(output)
+        [[ 1. 4.]
+         [ 2. 5.]
+         [ 3. 6.]]
+    """
+    return t_ext_op(input)
+
+
 def tan(input):
     r"""
     Computes tangent of `input` element-wise.
@@ -8071,7 +9420,7 @@ def triu(input, diagonal=0):
         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.
+        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.
 
@@ -8157,6 +9506,49 @@ def tuple_to_tensor(input_tuple, dtype=None):
     """
     return tuple_to_tensor_op(input_tuple, dtype)
 
+type_as_op=TypeAs()
+
+def type_as(input, other):
+    r"""
+    Returns input cast to the type of the with the other.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Note:
+        When converting complex numbers to boolean type, the imaginary part of the complex number is not
+        taken into account. As long as the real part is non-zero, it returns True; otherwise, it returns False.
+
+    Args:
+        input (Tensor): The shape of tensor is :math:`(x_0, x_1, ..., x_R)`. The tensor whose data type is to be converted.
+        other (Tensor): The shape of tensor is :math:`(x_0, x_1, ..., x_R)`. The tensor whose data type is specified.
+
+    Returns:
+        Tensor, the shape of tensor is the same as `input`, :math:`(x_0, x_1, ..., x_R)`.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `other` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input_np = np.random.randn(2, 3, 4, 5).astype(np.float32)
+        >>> input = Tensor(input_np)
+        >>> other_np = np.random.randn(2, 3, 4).astype(np.int32)
+        >>> other = Tensor(other_np)
+        >>> output = ops.type_as(input, other)
+        >>> print(output.dtype)
+        Int32
+        >>> print(output.shape)
+        (2, 3, 4, 5)
+    """
+    return type_as_op(input, other)
+
 
 def unsorted_segment_sum(input_x, segment_ids, num_segments):
     r"""
@@ -8216,6 +9608,41 @@ def unsorted_segment_sum(input_x, segment_ids, num_segments):
     return unsorted_segment_sum_op(input_x, segment_ids, num_segments)
 
 
+def view_as(input, other):
+    r"""
+    Change the shape of the input tensor based on the shape of other.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): The input tensor.
+        other (Tensor): The shape of return tensor is same as the shape of other.
+
+    Returns:
+        Tensor, which has the same shape of other.
+
+    Raises:
+        TypeError: If `input` is not a tensor.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([[1, 2, 3], [2, 3, 4]], dtype=np.float32))
+        >>> other = Tensor(np.array([[1, 2], [3, 4], [5, 6]], dtype=np.float32))
+        >>> output = ops.view_as(input, other)
+        >>> print(output)
+        [[1. 2.]
+         [3. 2.]
+         [3. 4.]]
+    """
+    return view_as_op(input, other)
+
+
 def view(input, shape):
     r"""
     Reshape the tensor according to the input shape. It's the same as :func:`mindspore.Tensor.reshape`,
@@ -8289,6 +9716,10 @@ def grouped_matmul(x, weight, bias=None, scale=None, offset=None, antiquant_scal
     .. math::
             y_i = x_i\times (weight_i + antiquant\_offset_i) * antiquant\_scale_i + bias_i
 
+    .. note::
+        Only when `bias` , `scale` , `offset` , `antiquant_scale` and `antiquant_offset` are all None, `group_type` is 0,
+        and `split_item` is 3, the reverse derivative is supported.
+
     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].
@@ -8365,7 +9796,8 @@ def grouped_matmul(x, weight, bias=None, scale=None, offset=None, antiquant_scal
         ...         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)
+        >>> ms.set_device(device_target="Ascend")
+        >>> context.set_context(mode=ms.GRAPH_MODE)
         >>> x = [ms.Tensor(np.array([[0, 0, 0, 0],
         ...                          [1, 1, 1, 1],
         ...                          [2, 2, 2, 2],
@@ -8392,6 +9824,20 @@ def grouped_matmul(x, weight, bias=None, scale=None, offset=None, antiquant_scal
     return grouped_matmul_impl(x, weight, bias, scale, offset, antiquant_scale, antiquant_offset, group_list, split_item, group_type)
 
 
+def grouped_matmul_v2(x, weight, bias=None, scale=None, offset=None, antiquant_scale=None, antiquant_offset=None, group_list=None, split_item=0, group_type=-1):
+    r"""
+    
+    """
+    return grouped_matmul_v2_op(x, weight, bias, scale, offset, antiquant_scale, antiquant_offset, group_list, split_item, group_type)
+
+
+def grouped_matmul_v4(x, weight, bias=None, scale=None, offset=None, antiquant_scale=None, antiquant_offset=None, pre_token_scale=None, group_list=None, activation_input=None, activation_quant_scale=None, activation_quant_offset=None, split_item=0, group_type=-1, group_list_type=0, act_type=0):
+    r"""
+    
+    """
+    return grouped_matmul_v4_op(x, weight, bias, scale, offset, antiquant_scale, antiquant_offset, pre_token_scale, group_list, activation_input, activation_quant_scale, activation_quant_offset, split_item, group_type, group_list_type, act_type)
+
+
 def kv_cache_scatter_update(var, indices, updates, axis, reduce='none'):
     r"""
     Update var with updates and indices along sequence axis.
@@ -8427,6 +9873,41 @@ def kv_cache_scatter_update(var, indices, updates, axis, reduce='none'):
     return kv_cache_scatter_update_op(var, indices, updates, axis, reduce)
 
 
+def moe_compute_expert_tokens(sorted_experts, num_expert):
+    r"""
+    In MoE calculation, Search for the last index processed by each expert through binary search.
+
+    .. math::
+        expert_tokens_{i} = BinarySearch(sorted_experts, num_expert)
+
+    Inputs:
+        - **sorted_experts** (Tensor) - A tensor which represent sorted experts, must be 1D tensor.
+          Supported type: Int32.
+        - **num_expert** (int) - The number of experts, must be greater than 0.
+
+    Outputs:
+        Tensor, have the same dtype with sorted_experts.
+
+    Raises:
+        TypeError: if `sorted_experts` is not a tensor.
+        ValueError: if `num_expert` is less than 0.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> from mindspore.ops.auto_generate import MoeComputeExpertTokens
+        >>> sorted_experts = ms.Tensor([0, 0, 1, 2, 2], dtype=ms.int32)
+        >>> num_expert = 5
+        >>> net = MoeComputeExpertTokens()
+        >>> expert_tokens = net(sorted_experts, num_expert)
+        >>> print(expert_tokens)
+        [2, 3, 5]
+    """
+    return moe_compute_expert_tokens_op(sorted_experts, num_expert)
+
+
 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.
@@ -8484,7 +9965,8 @@ def moe_finalize_routing(expanded_x, x1, x2=None, bias=None, scales=None, expand
         ...         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)
+        >>> ms.set_device(device_target="Ascend")
+        >>> context.set_context(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],
@@ -8517,6 +9999,30 @@ def moe_finalize_routing(expanded_x, x1, x2=None, bias=None, scales=None, expand
     return moe_finalize_routing_op(expanded_x, x1, x2, bias, scales, expanded_row_idx, expanded_expert_idx)
 
 
+def moe_init_routing(x, row_idx, expert_idx, active_num):
+    r"""
+    Performs routing on the computation result of MoeGatingTopKSoftmax.
+
+    Inputs:
+        - **x** (Tensor) - 2D tensor, which contains input feature tokens. The shape is (NUM_ROWS, H).
+        - **row_idx** (Tensor) - Original row ID of each position. The shape must be the same as that of expertForSourceRow.
+        - **expert_idx** (Tensor) - 2D tensor, indicating k experts corresponding to each row of features in the output of aclnnMoeGatingTopKSoftmax. The shape is (NUM_ROWS, K). 
+        active_num (int64): maximum number of rows that can be processed, that is, the maximum number of rows that are valid in expandedXOut.
+
+    Outputs:
+        - **expanded_x** (Tensor) - 2D tensor, indicating features extended based on expertIdx. The shape is (min(NUM_ROWS, activeNum) * k, H).
+        - **expanded_row_idx** (Tensor) - 1D tensor, indicating mapping between expandedX and x. The shape is (NUM_ROWS*K).
+        - **expanded_expert_idx** (Tensor) - sorted result of expertIdx.
+
+    Raises:
+        ShapeError: If the shape of input Tensor does not match the description in args.
+
+    Supported Platforms:
+        ``Ascend``
+    """
+    return moe_init_routing_op(x, row_idx, expert_idx, active_num)
+
+
 def quant_batch_matmul(x1, x2, scale, offset=None, bias=None, pertokenScaleOptional=None, transpose_x1=False, transpose_x2=False, dtype=mstype.float16):
     r"""