mindspore 2.6.0rc1__cp39-cp39-win_amd64.whl → 2.7.0rc1__cp39-cp39-win_amd64.whl

mindspore/ops/functional_overload.py

@@ -16,14 +16,22 @@
 from mindspore._c_expression import _add_instance
 from mindspore._c_expression import _addcdiv_instance
 from mindspore._c_expression import _all_gather_matmul_instance
+from mindspore._c_expression import _any_instance
 from mindspore._c_expression import _bitwise_not_instance
 from mindspore._c_expression import _clamp_instance
+from mindspore._c_expression import _conv3d_instance
 from mindspore._c_expression import _div_instance
+from mindspore._c_expression import _einsum_instance
 from mindspore._c_expression import _empty_instance
+from mindspore._c_expression import _empty_like_instance
 from mindspore._c_expression import _floor_divide_instance
 from mindspore._c_expression import _fmod_instance
 from mindspore._c_expression import _gelu_instance
+from mindspore._c_expression import _gmm_instance
+from mindspore._c_expression import _gmm_backward_instance
+from mindspore._c_expression import _gmm_backward_fusion_instance
 from mindspore._c_expression import _greater_equal_instance
+from mindspore._c_expression import _index_add_instance
 from mindspore._c_expression import _kthvalue_instance
 from mindspore._c_expression import _lerp_instance
 from mindspore._c_expression import _matmul_reduce_scatter_instance
@@ -31,8 +39,10 @@ from mindspore._c_expression import _max_instance
 from mindspore._c_expression import _min_instance
 from mindspore._c_expression import _nansum_instance
 from mindspore._c_expression import _pixel_shuffle_instance
+from mindspore._c_expression import _quant_matmul_instance
 from mindspore._c_expression import _remainder_instance
 from mindspore._c_expression import _repeat_interleave_instance
+from mindspore._c_expression import _rmod_instance
 from mindspore._c_expression import _sub_instance
 from mindspore._c_expression import _where_instance
 from mindspore._c_expression import _xlogy_instance
@@ -261,6 +271,52 @@ def all_gather_matmul(*args, **kwargs):
     return _all_gather_matmul_instance(*args, **kwargs)
 
 
+def any(*args, **kwargs):
+    r"""
+    any(input) -> Tensor
+
+    Check if ``True`` is present in `input` .
+
+    Args:
+        input (Tensor): The input tensor.
+
+    Returns:
+        Tensor
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> input = mindspore.tensor([[True, False], [True, True]])
+        >>> mindspore.ops.functional_overload.any(input)
+        Tensor(shape=[], dtype=Bool, value= True)
+
+    .. function:: any(input, dim, keepdim=False) -> Tensor
+        :noindex:
+
+    Check if ``True`` is present in the specified dimension of `input` .
+
+    Args:
+        input (Tensor): The input tensor.
+        dim (int): The dimensions to reduce.
+        keepdim (bool, optional): Whether the output tensor has dim retained or not. Default ``False`` .
+
+    Returns:
+        Tensor
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> input = mindspore.tensor([[True, False], [True, True]])
+        >>> mindspore.ops.functional_overload.any(input, dim=1)
+        Tensor(shape=[2], dtype=Bool, value= [ True,  True])
+    """
+    return _any_instance(*args, **kwargs)
+
+
 def bitwise_not(*args, **kwargs):
     r"""
     bitwise_not(input) -> Tensor
@@ -373,6 +429,143 @@ def clip(*args, **kwargs):
     return _clamp_instance(*args, **kwargs)
 
 
+def conv3d(*args, **kwargs):
+    r"""
+    conv3d(input, weight, bias=None, stride=1, padding=0, dilation=1, groups=1) -> Tensor
+
+    Applies a 3D convolution over an input tensor. The input tensor is typically of
+    shape :math:`(N, C_{in}, D_{in}, H_{in}, W_{in})` or :math:`(C_{in}, D_{in}, H_{in}, W_{in})`,
+    where :math:`N` is batch size, :math:`C` is channel number, :math:`D, H, W` are the depth,
+    height and width of the feature graph, respectively.
+
+    The output is calculated based on formula:
+
+    .. math::
+
+        \text{out}(N_i, C_{\text{out}_j}) = \text{bias}(C_{\text{out}_j}) +
+        \sum_{k = 0}^{C_{in} - 1} \text{ccor}({\text{weight}(C_{\text{out}_j}, k), \text{X}(N_i, k)})
+
+    where :math:`bias` is the output channel bias, :math:`ccor` is
+    the `cross-correlation <https://en.wikipedia.org/wiki/Cross-correlation>`_
+    , :math:`weight` is the convolution kernel value and :math:`X` represents the input feature map.
+
+    Here are the indices' meanings:
+
+    - :math:`i` corresponds to the batch number, the range is :math:`[0, N-1]`,
+      where :math:`N` is the batch size of the input.
+
+    - :math:`j` corresponds to the output channel, the range is :math:`[0, C_{out}-1]`,
+      where :math:`C_{out}` is the number of
+      output channels, which is also equal to the number of kernels.
+
+    - :math:`k` corresponds to the input channel, the range is :math:`[0, C_{in}-1]`,
+      where :math:`C_{in}` is the number of
+      input channels, which is also equal to the number of channels in the convolutional kernels.
+
+    Therefore, in the above formula, :math:`{bias}(C_{\text{out}_j})` represents the bias of the :math:`j`-th
+    output channel, :math:`{weight}(C_{\text{out}_j}, k)` represents the slice of the :math:`j`-th convolutional
+    kernel in the :math:`k`-th channel, and :math:`{X}(N_i, k)` represents the slice of the :math:`k`-th input
+    channel in the :math:`i`-th batch of the input feature map.
+
+    The shape of the convolutional kernel is given by :math:`(kd, kh, kw)` where :math:`kd` , :math:`kd` and\
+    :math:`kw` are the depth, height and width of the kernel, respectively.
+    If we consider the input and output channels as well as the `group` parameter, the complete kernel shape
+    will be :math:`(C_{out}, C_{in} / \text{group}, kd, kh, kw)`,
+    where `group` is the number of groups dividing `x`'s input channel when applying group convolution.
+
+    For more details about convolution layer, please refer to `Gradient Based Learning Applied to Document Recognition
+    <http://vision.stanford.edu/cs598_spring07/papers/Lecun98.pdf>`_.
+
+    The following lists some of the limitations of the parameters.
+
+    - input -- The input to the conv3d. The input must have each dimension size within the range [1, int32_max].
+    - weight -- Filters of shape :math:`(C_{out}, C_{in} / groups, kd, kh, kw)`. The value of :math:`kh`
+      and :math:`kw` is in the range [1, 511]. The remaining values are in the range [1, int32_max].
+      And :math:`kh*kw*k0` is less 65536 (k0 is 16. If data type is float32, k0 is 8).
+    - bias -- Bias Tensor with shape :math:`(C_{out})`. The shape must equal to the first dimension of the weight.
+    - stride -- The distance of kernel moving. It can be an int number or
+      tuple (noted by :math:`(stride_d, stride_h, stride_w)`). stride_h and stride_w are in the range [1, 63].
+      stride_d is in the range [1, 255].
+    - padding -- If padding is an int number, it is in the range [0, 255].
+    - dilation -- The value is in the range [1, 255].
+    - groups -- The value is in the range [1, 65535].
+    - :math:`C_{in} \% \text{groups} == 0 \quad \text{and} \quad C_{out} \% \text{groups} == 0` .
+    - :math:`weight[1] == C_{in} / groups` .
+    - :math:`H_{in} + PadUp + PadDown >= (kh - 1) * DilationH + 1` .
+    - :math:`W_{in} + PadLeft + PadRight >= (kw - 1) * DilationW + 1` .
+    - :math:`D_{in} + PadFront + PadBack >= (kd - 1) * DilationD + 1` .
+    - :math:`H_{out} = (H_{in} + PadUp + PadDown - ((kh - 1) * DilationH + 1)) / StrideH + 1` .
+    - :math:`W_{out} = (W_{in} + PadLeft + PadRight - ((kw - 1) * DilationW + 1)) / StrideW + 1` .
+    - :math:`D_{out} = (D_{in} + PadFront + PadBack - ((kd - 1) * DilationD + 1)) / StrideD + 1` .
+    - :math:`(D_{in}+PadFront+PadBack - ((kd-1)*DilationD+1)) \% StrideD <= PadBack` .
+    - :math:`(H_{in}+PadUp+PadDown - ((kh-1)*Dilationh+1)) \% StrideH <= PadDown` .
+    - :math:`stride_d <= kernel_d` .
+    - :math:`PadUp < kh` and :math:`PadDown < kh` . When `padding` = ``'valid'``, both PadUp and PadDown are zeros.
+      When `padding` = ``'same'``, pad can be calculated by
+      :math:`floor(((H_{out}-1) * strideH + (kh - 1) * DilationH + 1 - H_{in}) / 2)` for high dimension.
+      It is similar way to calculate the padding for depth and width dimension. And the depth and width
+      dimensions also have the same constraints.
+    - :math:`((kh - 1) * DilationH - PadUp)` should be in [0, 255]. It is the same constraint for depth
+      and width dimension.
+    - If `padding` is ``'same'``, `stride` must be 1.
+
+    .. warning::
+        It is only supported on Atlas A2 Training Series Products.
+
+    Args:
+        input (Tensor): Tensor of shape :math:`(N, C_{in}, D_{in}, H_{in}, W_{in})`.
+        weight (Tensor): Set size of kernel is :math:`(kd, kh,
+            kw)`, then the shape is :math:`(C_{out}, C_{in} / groups, kd, kh, kw)`.
+        bias (Tensor, optional): Bias Tensor with shape :math:`(C_{out})`.
+            When bias is ``None`` , zeros will be used. Default: ``None`` .
+        stride (Union(int, tuple[int], list[int]), optional): The distance of kernel moving, an int
+            number that represents the depth, the height and width of movement are both strides, or a
+            tuple of triple int numbers that
+            represent the depth, height and width of movement respectively. Default: ``1`` .
+        padding (Union(int, tuple[int], list[int], str), optional): Implicit paddings on both sides of the input `x`.
+            Can be a string, one integer or a tuple/list with 3 integers.
+            If `padding` is a string, the optional values are ``"same"`` , ``"valid"``.
+
+            - same: Adopts the way of completion. The height and width of the output will be equal to
+              the input `x` divided by stride. The padding will be evenly calculated in top and bottom,
+              left and right possiblily. Otherwise, the last extra padding will be calculated from the bottom
+              and the right side. If this mode is set, `stride` must be 1.
+
+            - valid: Adopts the way of discarding. The possible largest height and width of output will be returned
+              without padding. Extra pixels will be discarded.
+
+            If `padding` is one integer, the paddings of top, bottom, left and right are the same, equal to padding.
+            If `padding` is a tuple/list with 3 integers, the padding of head, tail, top, bottom,
+            left and right equal to pad[0], pad[0], pad[1], pad[1], pad[2] and pad[2] correspondingly. Default: ``0`` .
+        dilation (Union[int, tuple[int], list[int]], optional): Controlling the space between the kernel points.
+            Default: ``1`` .
+        groups (int, optional): Splits `input` into groups. Default: ``1`` .
+
+    Returns:
+        Tensor, the same dtype as the `input`, with the shape :math:`(N, C_{out}, D_{out}, H_{out}, W_{out})`
+        or :math:`(C_{out}, D_{out}, H_{out}, W_{out})`.
+
+    Raises:
+        TypeError: If `stride`, `padding` or `dilation` is neither an int nor a tuple.
+        TypeError: `groups` is not an int.
+        TypeError: If `bias` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import mint
+        >>> x = mindspore.Tensor(np.random.randn(12, 1, 60, 50, 8), mindspore.float16)
+        >>> w = mindspore.Tensor(np.random.randn(26, 1, 2, 4, 4), mindspore.float16)
+        >>> out = mint.nn.functional.conv3d(x, w)
+        >>> print(out.shape)
+        (12, 26, 59, 47, 5)
+    """
+    return _conv3d_instance(*args, **kwargs)
+
+
 def div(*args, **kwargs):
     r"""
     div(input, other, *, rounding_mode=None) -> Tensor
@@ -438,9 +631,106 @@ def divide(*args, **kwargs):
     return _div_instance(*args, **kwargs)
 
 
+def einsum(*args, **kwargs):
+    r"""
+    According to the Einstein summation Convention (Einsum),
+    the product of the input tensor elements is summed along the specified dimension.
+    You can use this operator to perform diagonal, reducesum, transpose, matmul, mul, inner product operations, etc.
+
+    Note:
+        The sublist format is also supported. For example, einsum_ext(op1, sublist1, op2, sublist2, ..., sublist_out).
+        In this format, equation can be derived by the sublists which are made up of Python's Ellipsis and list of
+        integers in [0, 52). Each operand is followed by a sublist and an output sublist is at the end.
+        Dynamic shape, dynamic rank input is not supported in `graph mode (mode=mindspore.GRAPH_MODE)
+        <https://www.mindspore.cn/tutorials/en/master/compile/static_graph.html>`_.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        equation (str): Notation based on the Einstein summation convention, represent the operation you want to do.
+            the value can contain only letters, commas, ellipsis and arrow. The letters(must be in [a-zA-Z]) represent
+            input tensor dimension, commas(,) represent separate tensors, ellipsis indicates the tensor dimension that
+            you do not care about, the left of the arrow indicates the input tensors, and the right of it indicates the
+            desired output dimension. If there are no arrows in the equation, the letters that appear exactly once in
+            the equation will be part of the output, sorted in increasing alphabetical order. The output is computed by
+            multiplying the input operands element-wise, with their dimensions aligned based on the letters, and then
+            summing out the dimensions whose letters are not part of the output. If there is one arrow in the equation,
+            the output letters must appear at least once for some input operand and at most once for the output.
+        operands (Tensor): Input tensor used for calculation. The dtype of the tensor must be the same.
+
+    Returns:
+        Tensor, the shape of it can be obtained from the `equation` , and the dtype is the same as input tensors.
+
+    Raises:
+        TypeError: If `equation` is invalid, or the `equation` does not match the input tensor.
+        ValueError: If the number in sublist is not in [0, 52) in sublist format.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor(np.array([1.0, 2.0, 4.0]), mindspore.float32)
+        >>> equation = "i->"
+        >>> output = ops.einsum_ext(equation, x)
+        >>> print(output)
+        7.0
+        >>> x = Tensor(np.array([1.0, 2.0, 4.0]), mindspore.float32)
+        >>> y = Tensor(np.array([2.0, 4.0, 3.0]), mindspore.float32)
+        >>> equation = "i,i->i"
+        >>> output = ops.einsum_ext(equation, x, y)
+        >>> print(output)
+        [ 2. 8. 12.]
+        >>> x = Tensor(np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]), mindspore.float32)
+        >>> y = Tensor(np.array([[2.0, 3.0], [1.0, 2.0], [4.0, 5.0]]), mindspore.float32)
+        >>> equation = "ij,jk->ik"
+        >>> output = ops.einsum_ext(equation, x, y)
+        >>> print(output)
+        [[16. 22.]
+         [37. 52.]]
+        >>> x = Tensor(np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]), mindspore.float32)
+        >>> equation = "ij->ji"
+        >>> output = ops.einsum_ext(equation, x)
+        >>> print(output)
+        [[1. 4.]
+         [2. 5.]
+         [3. 6.]]
+        >>> x = Tensor(np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]), mindspore.float32)
+        >>> equation = "ij->j"
+        >>> output = ops.einsum_ext(equation, x)
+        >>> print(output)
+        [5. 7. 9.]
+        >>> x = Tensor(np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]), mindspore.float32)
+        >>> equation = "...->"
+        >>> output = ops.einsum_ext(equation, x)
+        >>> print(output)
+        21.0
+        >>> x = Tensor(np.array([1.0, 2.0, 3.0]), mindspore.float32)
+        >>> y = Tensor(np.array([2.0, 4.0, 1.0]), mindspore.float32)
+        >>> equation = "j,i->ji"
+        >>> output = ops.einsum_ext(equation, x, y)
+        >>> print(output)
+        [[ 2. 4. 1.]
+         [ 4. 8. 2.]
+         [ 6. 12. 3.]]
+        >>> x = mindspore.Tensor([1, 2, 3, 4], mindspore.float32)
+        >>> y = mindspore.Tensor([1, 2], mindspore.float32)
+        >>> output = ops.einsum_ext(x, [..., 1], y, [..., 2], [..., 1, 2])
+        >>> print(output)
+        [[1. 2.]
+         [2. 4.]
+         [3. 6.]
+         [4. 8.]]
+    """
+    return _einsum_instance(*args, **kwargs)
+
+
 def empty(*args, **kwargs):
     r"""
-    empty(*size, dtype=None, device=None) -> Tensor
+    empty(*size, *, dtype=None, device=None) -> Tensor
 
     Creates a tensor with uninitialized data, whose shape, dtype and device are described by the argument `size`,
     `dtype` and `device` respectively.
@@ -450,22 +740,23 @@ def empty(*args, **kwargs):
 
     Args:
         size (Union[tuple[int], list[int], int]): The specified shape of output tensor. Can be variable numbers of
-            positive integers or tupled or list containing positive integers.
+            positive integers or tuple or list containing positive integers.
 
     Keyword Args:
         dtype (:class:`mindspore.dtype`, optional): The specified type of output tensor. If `dtype` is ``None`` ,
             `mindspore.float32` will be used. Default: ``None`` .
-        device (string, optional): The specified device of the output tensor. Support ``CPU`` and ``Ascend``. If
-            `device = None`, `mindspore.context.device_target` will be used. Default ``None``.
+        device (string, optional): The specified device of the output tensor. In PyNative mode, ``"Ascend"``, ``"npu"``,
+            ``"cpu"`` and ``"CPU"`` are supported. In graph mode O0, ``"Ascend"`` and ``"npu"`` are supported. If `device = None`,
+            `mindspore.context.device_target` will be used. Default ``None``.
 
     Returns:
-        Tensor, whose dtype and size are defined by input.
+        Tensor, whose shape, dtype and device are defined by input.
 
     Raises:
         TypeError:  If `size` is neither an int nor a tuple or list of int.
 
     Supported Platforms:
-        ``Ascend``
+        ``Ascend`` ``CPU``
 
     Examples:
         >>> import mindspore
@@ -478,8 +769,55 @@ def empty(*args, **kwargs):
     return _empty_instance(*args, **kwargs)
 
 
+def empty_like(*args, **kwargs):
+    r"""
+    empty_like(input, *, dtype=None, device=None) -> Tensor
+
+    Returns an uninitialized Tensor with the same shape as the `input`. Its dtype is specified by `dtype` and its
+    device is specified by `device`.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): Tensor of any dimension.
+
+    Keyword Args:
+        dtype (:class:`mindspore.dtype`, optional): The specified dtype of the output tensor. If `dtype = None`, the
+            tensor will have the same dtype as input `input`. Default ``None``.
+        device (string, optional): The specified device of the output tensor. In PyNative mode, ``"Ascend"``, ``"npu"``,
+            ``"cpu"`` and ``"CPU"`` are supported. In graph mode O0, ``"Ascend"`` and ``"npu"`` are supported. If `device = None`,
+            the value set by :func:`mindspore.set_device` will be used. Default ``None``.
+
+    Returns:
+        Tensor, has the same shape, type and device as `input` but with uninitialized data (May be a random value).
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import ops, Tensor
+        >>> x = Tensor([[1, 2, 3], [4, 5, 6]])
+        >>> output1 = ops.empty_like(x)
+        >>> print(output1)
+        [[0 0 0]
+         [0 0 0]]
+        >>> output2 = ops.empty_like(x, dtype=mindspore.float64)
+        >>> print(output2)
+        [[0. 0. 0.]
+         [0. 0. 0.]]
+    """
+    return _empty_like_instance(*args, **kwargs)
+
+
 def floor_divide(*args, **kwargs):
     r"""
+    floor_divide(input, other) -> Tensor
+
     Divides the first input tensor by the second input tensor element-wise and round down to the closest integer.
 
     Inputs of `input` and `other` comply with the implicit type conversion rules to make the data types consistent.
@@ -641,6 +979,108 @@ def gelu(*args, **kwargs):
     return _gelu_instance(*args, **kwargs)
 
 
+def gmm(*args, **kwargs):
+    r"""
+    gmm(x, weight, bias=None, group_list=None, group_type=0, group_list_type=0) -> tuple[Tensor]
+
+    Grouping matrix multiplication.
+
+    .. warning::
+        - This is an experimental API that is subject to change or deletion.
+        - `group_type` must be a constant.
+        - Only support on Atlas A2 training series.
+        - When the type of `group_list` is tuple[int] or list[int], it should a non-negative non-decreasing sequence,
+          indicating indexes of each group along the split axis. In this scenario, the arg `group_list_type` is useless.
+
+    .. note::
+        - When `group_type` is 2, the tensors in `x` must be non-continuous tensors which has
+          been transposed.
+        - Only when `group_type` is 0 and `bias` is None, the reverse derivative is supported,
+          which is implemented by ops.function.math_func.gmm_backward or through automatic differentiation.
+
+    Args:
+        x (tuple[Tensor]): The first tensors to be multiplied, whose num should be 1.
+        weight (tuple[Tensor]): The second tensors to be multiplied, whose num should be 1.
+        bias (tuple[Tensor], optional): Biases added to outputs, whose num should be 1.
+            The shape of each tensor in `bias` should be :math: `(group_list.shape[0], n)`
+            or :math: `(len(group_list), n)`. In the training scenario, the bias only supports None.
+            Default: ``None`` .
+        group_list (Union[Tensor, list[int], tuple[int]], optional): 1-D Tensor, list[int]
+            or tuple[int], indicating indexes or sizes of each group along the split axis.
+            When `group_list` is list[int] or tuple[int], it's length should be less than or equal to 128.
+            When `group_list` is a Tensor, it's size should be less than or equal to 1024.
+            Supported dtypes: int64.
+            Default: ``None`` .
+
+            - If `group_list_type` is 0, it must be  a non-negative non-decreasing sequence.
+              And when `group_type` is 0, the last element in `group_list` should be equal to
+              the first dimension of the tensor in `x` . When `group_type` is 2, the last element
+              in `group_list` should be equal to the second dimension of the tensor in `x` .
+
+            - If `group_list_type` is 1, the value in `group_list` are the sizes of each group.
+        group_type (int, optional): Represents the axes that need to be grouped. For example,
+            :math: `C[m,n] = A[m,k] \times B[k,n]`. Default: ``0`` .
+
+            - If `group_type` is 0, it means that the m-axis is grouped, meaning that the shape
+              of each tensor in `x` should be :math: `(m, k)` , the shape of each tensor in `weight`
+              should be :math: `(group_list.shape[0], k, n)` or :math: `(len(group_list), k, n)`,
+              and the shape of each tensor in result would be :math: `(m, n)` .
+
+            - If `group_type` is 2, it means that the k-axis is grouped, meaning that
+              the shape of each tensor in `x` should be :math: `(m, k)`, the shape of each
+              tensor in `weight` should be :math: `(k, n)`, and the shape of each tensor
+              in result would be :math: `(group_list.shape[0], m, n)` or :math: `(len(group_list), m, n)`.
+        group_list_type (int, optional): If it's 0, the value in `group_list` are the cumsum
+            result of the size of each group. If it's 1, the value in `group_list` are the size
+            of each group. Default: ``0`` .
+
+    `x` , `weight` and `bias` only support the following 3 type combinations:
+
+    - x: float16, weight: float16, bias: float16
+    - x: bfloat16, weight: bfloat16, bias: float32
+    - x: float32, weight: float32, bias: float32
+
+    Returns:
+        tuple[Tensor], the results of grouping matrix multiplication.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> x = Tensor(np.random.uniform(0,1, (10, 20)).astype(np.float32))
+        >>> weight = Tensor(np.random.uniform(0,1, (4, 20, 8)).astype(np.float32))
+        >>> group_list = Tensor([2, 4, 2, 2])
+        >>> y = ops.function.math_func.gmm([x,], [weight,], group_list=group_list, group_list_type=1)
+        >>> print(y[0].shape)
+        >>> (10, 8)
+        >>> group_list = [2, 6, 8, 10]
+        >>> y = ops.function.math_func.gmm([x,], [weight,], group_list=group_list, group_list_type=0)
+        >>> print(y[0].shape)
+        >>> (10, 8)
+    """
+    return _gmm_instance(*args, **kwargs)
+
+
+def gmm_backward(*args, **kwargs):
+    r"""
+    gmm_backward(grad, x, weight, *, group_list=None, group_list_type=0) -> tuple[tuple[Tensor]]
+
+    the grad of ops.function.math_func.gmm
+    """
+    return _gmm_backward_instance(*args, **kwargs)
+
+
+def gmm_backward_fusion(*args, **kwargs):
+    r"""
+    gmm_backward_fusion(grad, weight, *, group_list=None, group_list_type=0) -> tuple[tuple[Tensor]]
+
+    the grad of ops.function.math_func.gmm, only dx
+    """
+    return _gmm_backward_fusion_instance(*args, **kwargs)
+
+
 def greater_equal(*args, **kwargs):
     r"""
     greater_equal(input, other) -> Tensor
@@ -707,6 +1147,60 @@ def ge(*args, **kwargs):
     return _greater_equal_instance(*args, **kwargs)
 
 
+def index_add(*args, **kwargs):
+    r"""
+    index_add(input, dim, index, source, *, alpha=1) -> Tensor
+
+    Accumulate the elements of `alpha` times `source` into the `input` by adding to the index in the order given in `index`. For example, if ``dim == 0`` , ``index[i] == j`` , and ``alpha = -1`` , then the `i` th row of `source` is subtracted from the `j` th row of `input` . The `dim` th dimension of `source` must have the same size as the length of `index` , and all other dimensions must match `input`, or an error will be raised. For a 3-D tensor, the output is defined as follows:
+
+    .. math::
+        \begin{array}{ll}
+        input[index[i],\ :,\ :]\ +=\ alpha * source[i,\ :,\ :]  \qquad \#if\ dim == 0 \\
+        input[:,\ \ index[i],\ :]\ +=\ alpha * source[:,\ \ i,\ :]  \qquad \#if\ dim == 1 \\
+        input[:,\ :,\ \ index[i]]\ +=\ alpha * source[:,\ :,\ \ i]  \qquad\#if\ dim == 2 \\
+        \end{array}
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): The input Tensor.
+        dim (int): The dimension along which to index.
+        index (Tensor): Add the value of "input Tensor" and `source` along the dimension of the `dim` according to the specified index value, with data type int32. The `index` must be 1D with the same size as the size of `source` in the `dim` dimension. The values of `index` should be in [0, b), where the b is the size of "input Tensor" in the `dim` dimension.
+        source (Tensor): The input tensor with the value to add. Must have same data type as "input Tensor". The shape must be the same as "input Tensor" except the `dim` th dimension.
+
+    Keyword Args:
+        alpha (number, optional): The scalar multiplier for source. Default: ``1``.
+
+    Returns:
+        Tensor, has the same shape and dtype as `input`.
+
+    Raises:
+        TypeError: If neither `index` nor `source` is a Tensor.
+        ValueError: If the value of `dim` is out of the dimension range of `source` shape.
+        ValueError: If `index` rank is not the same as `source` rank.
+        ValueError: If shape of `index` is not 1D or size of `index` is not equal to dimension of source[dim].
+        ValueError: If the shape of `source` is not the same as that of `input` except the `dim` axis.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> import mindspore
+        >>> from mindspore import Tensor, mint
+        >>> x = Tensor(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), mindspore.float32)
+        >>> index = Tensor(np.array([0, 2]), mindspore.int32)
+        >>> y = Tensor(np.array([[0.5, 1.0], [1.0, 1.5], [2.0, 2.5]]), mindspore.float32)
+        >>> output = mint.index_add(x, 1, index, y, alpha=1)
+        >>> print(output)
+        [[ 1.5  2.   4. ]
+         [ 5.   5.   7.5]
+         [ 9.   8.  11.5]]
+    """
+    return _index_add_instance(*args, **kwargs)
+
+
 def kthvalue(*args, **kwargs):
     r"""
     Calculates the kth smallest value along given dim specified by `dim` of the input
@@ -1151,6 +1645,60 @@ def pixel_shuffle(*args, **kwargs):
     return _pixel_shuffle_instance(*args, **kwargs)
 
 
+def quant_matmul(*args, **kwargs):
+    r"""
+    quant_matmul(x1, x2, scale, *, offset=None, pertoken_scale=None, bias=None, output_dtype=None, x1_dtype=None, x2_dtype=None, pertoken_scale_dtype=None, scale_dtype=None, group_sizes=None) -> Tensor
+
+    Used for quantized matrix multiplication.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+        Only support on David training series.
+
+    Args:
+        x1 (Tensor): Tensor of shape :math:`(*, M, K)` . The dimension of `input` should be in [2, 6].
+        x2 (Tensor): Tensor of shape :math:`(*, K, N)` . The dimension of `input` should be in [2, 6].
+        scale (Tensor): Tensor of shape :math:`(T,)` . T should be equal to 1 or N, N is the last dimension of `x2`.
+
+    Keyword Args:
+        offset (Tensor, optional): Tensor of shape :math:`(T,)` . T should be equal to 1 or N, N is the last dimension of `x2`. Default: ``None`` .
+        pertoken_scale (Tensor, optional): Tensor of shape :math:`(M,)` . M is second-to-last dimension of `x1`. Default: ``None`` .
+            A valid Tensor must deliver to `pertoken_scale` , ``None`` will cause unexpected error.
+        bias (Tensor, optional): Tensor of shape :math:`(N,)` or :math:`(B, 1, N)` , N is the last dimension of `x2`.
+            If dimension of `output` is 2, 4, 5 or 6, `bias` must has shape :math:`(N,)` . Default: ``None`` .
+        output_dtype (:class:`mindspore.dtype`, optional): the dtype of `output`. Default: ``None`` .
+        x1_dtype (:class:`mindspore.dtype`, optional): Cast `x1` to `x1_dtype` before calculation. Default: ``None`` .
+        x2_dtype (:class:`mindspore.dtype`, optional): Cast `x2` to `x2_dtype` before calculation. Default: ``None`` .
+        pertoken_scale_dtype (:class:`mindspore.dtype`, optional): Cast `pertoken_scale` to `pertoken_scale_dtype` before calculation. Default: ``None`` .
+        scale_dtype (:class:`mindspore.dtype`, optional): Cast `scale` to `scale_dtype` before calculation. Default: ``None`` .
+        group_sizes (Union[tuple(int), list(int)], optional): A sequence of int elements. Must have 3 elements. Default: ``None`` .
+
+    Returns:
+        Tensor of shape :math:`(*, M, N)` .
+
+    Raises:
+        ValueError: If dtype of `x1` is int8 or int32.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> import mindspore as ms
+        >>> from mindspore import ops, Tensor
+        >>> x1 = Tensor(np.random.randn(2, 3, 4), ms.float8_e4m3)
+        >>> x2 = Tensor(np.random.randn(2, 4, 5), ms.float8_e4m3)
+        >>> scale = Tensor(np.random.randn(1,), ms.float32)
+        >>> pertoken_scale = Tensor(np.random.randn(3,), ms.float32)
+        >>> output = ops.auto_generate.quant_matmul(x1, x2, scale, pertoken_scale=pertoken_scale, output_dtype=ms.bfloat16)
+        >>> print(output.shape)
+        (2, 3, 5)
+        >>> print(output.dtype)
+        BFloat16
+    """
+    return _quant_matmul_instance(*args, **kwargs)
+
+
 def remainder(*args, **kwargs):
     r"""
     remainder(input, other) -> Tensor
@@ -1242,6 +1790,13 @@ def repeat_interleave(*args, **kwargs):
     return _repeat_interleave_instance(*args, **kwargs)
 
 
+def rmod(*args, **kwargs):
+    r"""
+    rmod(input, other) -> Tensor
+    """
+    return _rmod_instance(*args, **kwargs)
+
+
 def sub(*args, **kwargs):
     r"""
     sub(input, other, *, alpha=1) -> Tensor
@@ -1413,17 +1968,25 @@ __all__ = [
     "__add__",
     "addcdiv",
     "all_gather_matmul",
+    "any",
     "bitwise_not",
     "clamp",
     "clip",
+    "conv3d",
     "div",
     "divide",
+    "einsum",
     "empty",
+    "empty_like",
     "floor_divide",
     "fmod",
     "gelu",
+    "gmm",
+    "gmm_backward",
+    "gmm_backward_fusion",
     "greater_equal",
     "ge",
+    "index_add",
     "kthvalue",
     "lerp",
     "matmul_reduce_scatter",
@@ -1431,8 +1994,10 @@ __all__ = [
     "min",
     "nansum",
     "pixel_shuffle",
+    "quant_matmul",
     "remainder",
     "repeat_interleave",
+    "rmod",
     "sub",
     "__sub__",
     "where",