mindspore 2.6.0rc1__cp39-none-any.whl → 2.7.0rc1__cp39-none-any.whl

mindspore/ops/function/math_func.py

@@ -56,12 +56,11 @@ from mindspore.ops.auto_generate import (minimum, maximum, mul, muls, sin, sinc,
                                          sum_ext_op, prod_ext_op, all, matrix_inverse_ext, atan2_ext, sign, acos_ext,
                                          acosh_ext, asin_ext, asinh_ext, atan_ext, tan, median_ext_op, median_dim_op,
                                          xlogy_op, xlogy_scalar_other_op, xlogy_scalar_self_op, trunc, histc_ext, roll,
-                                         bincount_ext, rotated_iou_op, cat, narrow, var_op, pow, pow_scalar_tensor_op,
+                                         bincount_ext, rotated_iou_op, cat, narrow, var_op, pow, inplace_erfinv_op,
                                          frac_ext, pow_tensor_scalar_op, not_equal_op, isinf, addmv_op, cdist,
-                                         addbmm_op, addmm_op, grouped_matmul_v2, transpose_ext, grouped_matmul_v4,
-                                         inplace_erfinv_op)
+                                         addbmm_op, addmm_op, pow_scalar_tensor_op)
 # 2
-
+from mindspore.ops.functional_overload import gmm
 # 3
 
 # 4
@@ -3219,7 +3218,7 @@ def approximate_equal(x, y, tolerance=1e-5):
         >>> import mindspore
         >>> mindspore.ops.approximate_equal(mindspore.tensor([1e6, 2e6, float("inf"), float("-inf"), float("nan")]),
         ...                                 mindspore.tensor([1e6, 2e7, float("inf"), float("-inf"), float("nan")]))
-        Tensor(shape=[6], dtype=Bool, value= [ True, False, False, False, False])
+        Tensor(shape=[5], dtype=Bool, value= [ True, False, False, False, False])
         >>>
         >>> mindspore.ops.approximate_equal(mindspore.tensor([1e6, 2e6, 3e6]),
         ...                                 mindspore.tensor([1.00001e6, 2.00002e6, 3.00009e6]), tolerance=1e3)
@@ -4860,7 +4859,7 @@ def addmv(input, mat, vec, *, beta=1, alpha=1):
 
 
 def addmv_ext(input, mat, vec, *, beta=1, alpha=1):
-    """
+    r"""
     Performs a matrix-vector product of `mat` and `vec`, and add the input vector `input` to the final result.
 
     If `mat` is a tensor of size :math:`(N, M)` , `vec` is a 1-D tensor of size :math:`M` , then `input` must be
@@ -5622,7 +5621,7 @@ def dstack(tensors):
           1-D or 2-D tensors must have the same shape.
 
     Args:
-        tensors (Union(List[Tensor], Tuple[Tensor])): The list of tensors or tuple of tensors.
+        tensors (Union(List[Tensor], tuple[Tensor])): The list of tensors or tuple of tensors.
 
     Returns:
         Tensor
@@ -5783,7 +5782,7 @@ def _diff_helper(input, n, dim):
     is_bool = (input.dtype == mstype.bool_)
     result = input
 
-    for i in range(n):  # pylint: disable=unused-variable
+    for _ in range(n):  # pylint: disable=unused-variable
         if is_bool:
             result = logical_xor(narrow(result, dim, 1, out_len), narrow(result, dim, 0, out_len))
         else:
@@ -8441,7 +8440,7 @@ def matmul(input, other):
         >>> input = mindspore.ops.arange(24, dtype=mindspore.float32).reshape(2, 3, 4)
         >>> other = mindspore.ops.arange(20, dtype=mindspore.float32).reshape(4, 5)
         >>> output = mindspore.ops.matmul(input, other)
-        >>> print(>>> output)
+        >>> print(output)
         [[[  70,   76,   82,   88,   94],
           [ 190,  212,  234,  256,  278],
           [ 310,  348,  386,  424,  462]],
@@ -9631,12 +9630,10 @@ def _einsum_convert_num_to_char(num):
     """For einsum, convert number into char."""
     if [num] == [Ellipsis]:
         return '...'
-    # pylint: disable=chained-comparison
-    if num >= 0 and num < 26:
-        return chr(num + ord('A'))
-    # pylint: disable=chained-comparison
-    if num >= 26 and num < 52:
-        return chr(num - 26 + ord('a'))
+    if 0 <= num < 26:
+        return chr(num + 65)
+    if 26 <= num < 52:
+        return chr(num + 71)
     raise ValueError(f"For Einsum, the number in sublist should be in range [0, 52), but got {num}")
 
 
@@ -9738,33 +9735,19 @@ def einsum(equation, *operands):
     return _get_cache_prim(P.Einsum)(equation)(operands)
 
 
-def _einsum_convert_sublist_to_label(num, ell_num=False):
-    """Convert sublist to label."""
-    if num == Ellipsis or ell_num and num == 52:
-        return '...'
-    if 0 <= num < 26:
-        return chr(num + ord('A'))
-    if 26 <= num < 52:
-        return chr(num + ord('a') - 26)
-    raise ValueError(
-        f'For einsum, the number in sublist must be in range [0, 52), but got {num}')
-
-
-def _einsum_convert_label_to_index(label):
-    """Convert label to index."""
-    label_num = ord(label)
-    if ord('A') <= label_num <= ord('Z'):
-        return label_num - ord('A')
-    if ord('a') <= label_num <= ord('z'):
-        return label_num - ord('a') + 26
-    if label_num == ord('.'):
-        return 52
-    raise ValueError(
-        f'For einsum, the label in equation must be in [a-zA-Z] or ., but got {label}')
-
-
-def _einsum_convert_sublist(equation, *operands):
+def _einsum_convert_sublist(equation, operands):
     """Convert the sublist to an equation operand if the received input is a sublist format."""
+    def _einsum_convert_sublist_to_label(num, ell_num=False):
+        """Convert sublist to label."""
+        if num == Ellipsis or ell_num and num == 52:
+            return '...'
+        if 0 <= num < 26:
+            return chr(num + ord('A'))
+        if 26 <= num < 52:
+            return chr(num + ord('a') - 26)
+        raise ValueError(
+            f'For einsum, the number in sublist must be in range [0, 52), but got {num}')
+
     if isinstance(equation, Tensor):
         equation_tmp = ''
         for i, lst in enumerate(operands):
@@ -9789,331 +9772,6 @@ def _einsum_convert_sublist(equation, *operands):
     return equation, operands
 
 
-def _einsum_check_inputargs(equation, operands):
-    """Check equation and operands."""
-    if not isinstance(equation, str):
-        raise TypeError(
-            f"For einsum, 'equation' must be a str, but got {type(equation)}.")
-    for operand in operands:
-        if not isinstance(operand, Tensor):
-            raise TypeError(
-                f"For einsum, members of 'operands' must be Tensor, but got {type(operand)}.")
-
-
-@constexpr
-def _einsum_parse_equation(equation):
-    """Parse equation."""
-    l_equation = ''
-    r_equation = ''
-    equation = equation.replace(' ', '')
-
-    if '->' in equation:
-        l_equation, r_equation = equation.split('->', 1)
-        if l_equation == '':
-            raise ValueError(
-                'For einsum, equation must contain characters to the left fo the arrow.')
-    else:
-        l_equation = equation
-
-    if ',' in l_equation:
-        l_equationlst = l_equation.split(",")
-    else:
-        l_equationlst = [l_equation]
-
-    l_equationlst = []
-
-    for subequation in l_equation.split(','):
-        if '.' in subequation and ('...' not in subequation or subequation.count('.') != 3):
-            raise ValueError(f"For einsum, an ellipsis in the equation must include three continuous \'.\', "
-                             f"and can only be found once.")
-        subequation_lst = [_einsum_convert_label_to_index(label) for label in subequation.replace('...', '.')]
-        l_equationlst.append(subequation_lst)
-
-    if "." in r_equation and ('...' not in r_equation or r_equation.count('.') != 3):
-        raise ValueError(f"For einsum, an ellipsis in the equation must include three continuous \'.\', "
-                         f"and can only be found once.")
-    r_equationlst = [_einsum_convert_label_to_index(label) for label in r_equation.replace('...', '.')]
-
-    return l_equationlst, r_equationlst, ('->' in equation)
-
-
-def _einsum_parse_labels(l_equationlst, operands):
-    """Parse left script of equation."""
-    align_rank = 0
-    max_labels = 53
-    ellipsis_dimnum = 0
-    labels_count = [0] * max_labels
-
-    if len(operands) != len(l_equationlst):
-        raise ValueError(f"For einsum, 'operands' is not equal to specified in the 'equation', "
-                         f"but got {len(operands)} and {len(l_equationlst)}.")
-
-    for idx, sub_equ in enumerate(l_equationlst):
-        start_dim = 0
-        label_num = 0
-        operand_shape = list(operands[idx].shape)
-        for label in sub_equ:
-            dim_num = 1
-            label_num += 1
-            end_dim = start_dim + 1
-
-            # Label is ellipsis
-            if label == 52:
-                end_dim = len(operand_shape) - len(sub_equ) + label_num
-                dim_num = end_dim - start_dim
-                if ellipsis_dimnum != 0 and ellipsis_dimnum != dim_num:
-                    raise ValueError(f"For einsum, an ellipsis in 'equation' can only represent the same numbers of "
-                                     f"dimensions in 'operands'.")
-                ellipsis_dimnum = dim_num
-            if labels_count[label] == 0:
-                align_rank += dim_num
-            labels_count[label] += 1
-            start_dim += dim_num
-        if label_num != len(sub_equ) or start_dim != len(operand_shape):
-            raise ValueError(f"For einsum, the numbers of labels specified in the 'equation' does not match "
-                             f"'operands[{idx}]'.")
-    return ellipsis_dimnum, labels_count, align_rank
-
-
-def _einsum_infer_output(r_equationlst, arrow_exist, ellipsis_dimnum, labels_count):
-    """Parse right script of equation and infer output shape."""
-    idx = 0
-    idle_idx = -1
-    output_rank = 0
-    labels_perm_idx = [idle_idx] * 53
-
-    if arrow_exist:
-        for label in r_equationlst:
-            if labels_count[label] != 0:
-                if labels_perm_idx[label] != idle_idx:
-                    raise ValueError(f"For einsum, '{_einsum_convert_sublist_to_label(label, True)}' or {label} in "
-                                     f"sublist format has appears more than once in output subscript.")
-                dimnum = 1
-                if label == 52:
-                    dimnum = ellipsis_dimnum
-                labels_perm_idx[label] = idx
-                output_rank += dimnum
-                idx += dimnum
-            else:
-                raise ValueError(f"For einsum, the label to the right of arrow in the 'equation' must appear on "
-                                 f"left, but '{_einsum_convert_sublist_to_label(label, True)}' does not.")
-    else:
-        if labels_count[52] != 0:
-            output_rank += ellipsis_dimnum
-            labels_perm_idx[52] = idx
-            idx += ellipsis_dimnum
-        for label, count in enumerate(labels_count):
-            if count == 1:
-                output_rank += 1
-                labels_perm_idx[label] = idx
-                idx += 1
-
-    for label, count in enumerate(labels_count):
-        if count != 0 and labels_perm_idx[label] == idle_idx:
-            labels_perm_idx[label] = idx
-            idx += 1
-
-    return output_rank, labels_perm_idx
-
-
-def _einsum_adjust_operands(operands, l_equationlst, ellipsis_dimnum, labels_perm_idx, align_rank):
-    """Align operands to output as possible."""
-    # Unsqueeze miss dimensions to make all operands has same rank, compute diagonal if operand has same label.
-    # Then use _labels_perm_idx to transpose all operands to align dimensions with output.
-    adjust_operands = []
-    for idx, operand in enumerate(operands):
-        idle_dim = -1
-        align_axis = [idle_dim] * align_rank
-        label_dims = [idle_dim] * 53
-        dim = 0
-
-        for label in l_equationlst[idx]:
-            if label_dims[label] != idle_dim:
-                operand = ops.diagonal(operand, 0, label_dims[label], dim)
-                diag_perm = []
-                diag_dim = 0
-                for i in range(len(operand.shape)):
-                    if i == label_dims[label]:
-                        diag_perm.append(len(operand.shape) - 1)
-                    else:
-                        diag_perm.append(diag_dim)
-                        diag_dim += 1
-                operand = permute(operand, tuple(diag_perm))
-            else:
-                label_dims[label] = dim
-                if label == 52:
-                    for ell_idx in range(ellipsis_dimnum):
-                        align_axis[labels_perm_idx[label] + ell_idx] = dim
-                        dim += 1
-                else:
-                    align_axis[labels_perm_idx[label]] = dim
-                    dim += 1
-        if len(operand.shape) < align_rank:
-            for i, axis in enumerate(align_axis):
-                if axis == idle_dim:
-                    align_axis[i] = dim
-                    dim += 1
-            missing_dims = [1] * (align_rank - len(operand.shape))
-            operand_shape = list(operand.shape) + missing_dims
-            operand = ops.reshape(operand, operand_shape)
-        operand = permute(operand, tuple(align_axis))
-        adjust_operands.append(operand)
-    return adjust_operands
-
-
-def _einsum_find_dimlastop(align_rank, operands, adjust_operands):
-    """Find dim last operand."""
-    dim_last_op = [0] * align_rank
-    has_zero_dim = False
-    for dim in range(align_rank):
-        broadcast_dim = adjust_operands[0].shape[dim]
-        for idx in range(1, len(adjust_operands)):
-            other_dim = adjust_operands[idx].shape[dim]
-            if broadcast_dim != other_dim and broadcast_dim != 1 and other_dim != 1:
-                err_msg = "For einsum, operands do not broadcast after align to output [shapes :origin -> adjust]:"
-                for i in range(len(operands)):
-                    err_msg += f" {operands[i].shape} -> {adjust_operands[i].shape}"
-                raise ValueError(err_msg)
-            if other_dim != 1:
-                dim_last_op[dim] = idx
-                broadcast_dim = other_dim
-        has_zero_dim = has_zero_dim or broadcast_dim == 0
-    return dim_last_op, has_zero_dim
-
-
-def _einsum_multiplication(sum_dims, l_tensor, r_tensor):
-    """Compute bmm for einsum."""
-    batch_dims = []
-    lonly_dims = []
-    ronly_dims = []
-    batch_size = 1
-    lonly_size = 1
-    ronly_size = 1
-    sum_size = 1
-
-    l_shape = l_tensor.shape
-    r_shape = r_tensor.shape
-
-    # Compute sum if dim is in sum_dims and get shapes for bmm
-    for i in range(len(l_shape)):
-        sum_l = l_shape[i] > 1
-        sum_r = r_shape[i] > 1
-        if i in sum_dims:
-            if sum_l and sum_r:
-                sum_size *= l_shape[i]
-            elif sum_l:
-                l_tensor = ops.auto_generate.sum_ext(l_tensor, i, True)
-            elif sum_r:
-                r_tensor = ops.auto_generate.sum_ext(r_tensor, i, True)
-        elif sum_l and sum_r:
-            batch_dims.append(i)
-            batch_size *= l_shape[i]
-        elif sum_l:
-            lonly_dims.append(i)
-            lonly_size *= l_shape[i]
-        else:
-            ronly_dims.append(i)
-            ronly_size *= r_shape[i]
-
-    # Compute the einsum bmm operators pipeline.
-    # The whole operators pipeline is transpose(in) -> reshape(in) -> bmm(in) -> reshape(out) -> transpose(out).
-    l_reshape_shape = (batch_size, lonly_size, sum_size)
-    r_reshape_shape = (batch_size, sum_size, ronly_size)
-
-    out_reshape_shape = [l_shape[dim] for dim in batch_dims]
-    out_reshape_shape += [l_shape[dim] for dim in lonly_dims]
-    out_reshape_shape += [1 for _ in sum_dims]
-    out_reshape_shape += [r_shape[dim] for dim in ronly_dims]
-
-    l_perm_axis = batch_dims + lonly_dims + sum_dims + ronly_dims
-    r_perm_axis = batch_dims + sum_dims + ronly_dims + lonly_dims
-    out_perm_axis = [-1] * len(out_reshape_shape)
-
-    out_dim = 0
-    for idx in range(len(l_perm_axis)):
-        out_perm_axis[l_perm_axis[idx]] = out_dim
-        out_dim += 1
-
-    l_tensor = permute(l_tensor, tuple(l_perm_axis))
-    l_tensor = ops.reshape(l_tensor, l_reshape_shape)
-
-    r_tensor = permute(r_tensor, tuple(r_perm_axis))
-    r_tensor = ops.reshape(r_tensor, r_reshape_shape)
-
-    output = bmm_ext(l_tensor, r_tensor)
-    output = ops.reshape(output, out_reshape_shape)
-    output = permute(output, tuple(out_perm_axis))
-
-    output_origin_shape = output.shape
-    output_squeeze_shape = []
-    for dim in range(len(output_origin_shape)):
-        if dim not in sum_dims:
-            output_squeeze_shape.append(output_origin_shape[dim])
-
-    return ops.reshape(output, output_squeeze_shape)
-
-
-def _einsum(equation, operands):
-    '''Einsum main process'''
-    _l_equationlst, _r_equationlst, _arrow_exist = _einsum_parse_equation(
-        equation)
-    _ellipsis_dimnum, _labels_count, _align_rank = _einsum_parse_labels(
-        _l_equationlst, operands)
-    _output_rank, _labels_perm_idx = _einsum_infer_output(
-        _r_equationlst, _arrow_exist, _ellipsis_dimnum, _labels_count)
-    _adjust_operands = _einsum_adjust_operands(operands, _l_equationlst, _ellipsis_dimnum, _labels_perm_idx,
-                                               _align_rank)
-    _dim_last_op, _has_zero_dim = _einsum_find_dimlastop(
-        _align_rank, operands, _adjust_operands)
-    _result = _adjust_operands[0]
-
-    # Fast path if operands has zero dim.
-    if _has_zero_dim:
-        output_shape = []
-        for dim in range(_output_rank):
-            output_shape.append(_adjust_operands[_dim_last_op[dim]].shape[dim])
-        return ops.auto_generate.zeros(output_shape, dtype=_result.dtype)
-
-    # Sum or squeeze dimensions that is 1 for all rest operands.
-    _reduce_dim = _output_rank
-    for dim in range(_output_rank, _align_rank):
-        if _dim_last_op[dim] == 0:
-            if _result.shape[_reduce_dim] == 1:
-                _result = ops.auto_generate.pyboost_inner_prim.squeeze_impl(_result, _reduce_dim)
-            else:
-                _result = ops.auto_generate.sum_ext(_result, _reduce_dim)
-        else:
-            _reduce_dim += 1
-
-    # Compute multiplication if operands are more than two.
-    for i in range(1, len(_adjust_operands)):
-        operand = _adjust_operands[i]
-        dim = _output_rank
-        sum_dims = []
-        for j in range(_output_rank, _align_rank):
-            if _dim_last_op[j] < i:
-                operand = ops.auto_generate.pyboost_inner_prim.squeeze_impl(operand, dim)
-            elif _dim_last_op[j] == i:
-                if _result.shape[dim] == 1:
-                    operand = ops.auto_generate.sum_ext(operand, dim)
-                    _result = ops.auto_generate.pyboost_inner_prim.squeeze_impl(_result, dim)
-                else:
-                    sum_dims.append(dim)
-                    dim += 1
-            else:
-                dim += 1
-
-        if sum_dims == []:
-            _result = mul_ext(_result, operand)
-        elif len(sum_dims) == len(_result.shape):
-            _result = ops.auto_generate.dot(ops.auto_generate.flatten_ext(_result),
-                                            ops.auto_generate.flatten_ext(operand))
-        else:
-            _result = _einsum_multiplication(sum_dims, _result, operand)
-
-    return _result
-
-
 def einsum_ext(equation, *operands):
     r"""
     According to the Einstein summation Convention (Einsum),
@@ -10208,14 +9866,9 @@ def einsum_ext(equation, *operands):
          [3. 6.]
          [4. 8.]]
     """
-    _equation, _operands = _einsum_convert_sublist(equation, *operands)
-    _einsum_check_inputargs(_equation, _operands)
-
-    for operand in _operands:
-        if ops.is_sequence_shape_unknown(operand.shape) or ops.is_sequence_value_unknown(operand.shape):
-            raise ValueError(f"For einsum, the element of 'operands' can't be dynamic shape or dynamic rank.")
+    _equation, _operands = _einsum_convert_sublist(equation, operands)
 
-    return _einsum(_equation, _operands)
+    return ops.functional_overload.einsum(_equation, _operands)
 
 
 def cumprod(input, dim, dtype=None):
@@ -12466,184 +12119,24 @@ def mul_ext(input, other):
     return mul(input, other)
 
 
-def _for_each_transpose(inputs):
-    inputs_t = []
-    for input_i in inputs:
-        input_i_t = transpose_ext(input_i, -1, -2)
-        inputs_t.append(input_i_t)
-    return inputs_t
-
-
-def _is_transposed(input_tensor):
-    dim = input_tensor.dim()
-    if dim < 2 or dim > 3:
-        raise ValueError("input tensor of _is_transposed should be either 2- or 3-dimensional.")
-    input_shape = input_tensor.shape
-    input_strides = input_tensor.stride()
-    if input_strides[-2] == 1 and input_strides[-1] == input_shape[-2]:
-        return True
-    return False
-
-
-def gmm(x, weight, *, bias=None, group_list=None, group_type=0):
+def gmm_backward(grad, x, weight, group_list=None, group_list_type=0):
     r"""
-    Grouping matrix multiplication.
-
-    .. warning::
-        - This is an experimental API that is subject to change or deletion.
-        - `group_type` must be constant.
-
-    .. note::
-        - When `group_type` is 2, `weight` must be a non-continuous tensor after transpose.
-        - Only when `group_type` is 0 and `bias` is None, the reverse derivative is supported，
-          which is implemented by the function gmm_backward.
-
-    Args:
-        x (tuple[Tensor]): The first tensors to be multiplied.
-        weight (tuple[Tensor]): The second tensors to be multiplied.
-
-    Keyword Args:
-        bias (tuple[Tensor], optional): Biases added to outputs. In the training scenario,
-            the bias only supoorts None. Default: ``None`` .
-
-        group_list (Union[list[int], tuple(int)], optional): Represents the index of
-            the different groups on the grouping axis.  It must be a non-negative ascending
-            sequence . Default: ``None`` .
-
-            If `group_type` is 0, the last element in `group_list` should be equal to the
-            first dimension of the tensor in `x` .
-
-            If `group_type` is 2, the last element in `group_list` should be equal to the
-            second dimension of the tensor in `x` .
-
-        group_type (int, optional): Represents the dim that need to be grouped. Default: ``0`` .
-            For example, :math: `C[m,n] = A[m,k] \times B[k,n]`.
-
-            If `group_type` is 0, it means that the m-axis is grouped, where tensors in `x`
-            should be 2-D, tensors in `weight` should be 3-D, and the tensors of result would
-            be 2-D.
-
-            If `group_type` is 2, it means that the k-axis is grouped, where each tensor in `x`
-            and `weight` should be 2-D, and the tensors of result would be 3-D.
-
-    Returns:
-        tuple[Tensor], the results of grouping matrix multiplication.
-
-    Raises:
-        TypeError: If `group_type` is not a int.
-        ValueError: If `group_type` is invalid.
-        ValueError: If the length of `x` or `weight` is not 1.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import mindspore
-        >>> 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 = [2, 6, 8, 10]
-        >>> y = ops.function.math_func.gmm([x,], [weight,], group_list=group_list)
-        >>> print(y[0].shape)
-        >>> [10, 8]
+    the grad of ops.function.math_func.gmm
     """
-    return grouped_matmul_v2(x, weight, bias=bias, group_list=group_list,
-                             split_item=3, group_type=group_type)
-
-
-def gmm_backward(grad, x, weight, *, group_list=None):
-    r"""
-    the grad of gmm
-    """
-    gradients = ops.auto_generate.gmm_backward(grad, x, weight, group_list)
+    gradients = ops.functional_overload.gmm_backward(grad, x, weight, group_list, group_list_type)
     dx = gradients[:len(x)]
     dw = gradients[-len(weight):]
     db = []
     return dx, dw, db
 
 
-def gmm_v2(x, weight, *, bias=None, group_list=None, group_type=0, group_list_type=0):
-    r"""
-    Grouping matrix multiplication.
-
-    .. warning::
-        - This is an experimental API that is subject to change or deletion.
-        - `group_type` must be constant.
-
-    .. note::
-        - When `group_type` is 2, the tensors in `weight` must be non-continuous tensors after
-          transpose.
-        - Only when `group_type` is 0 and `bias` is None, the reverse derivative is supported,
-          which is implemented by the function gmm_v2_backward.
-
-    Args:
-        x (tuple[Tensor]): The first tensors to be multiplied.
-        weight (tuple[Tensor]): The second tensors to be multiplied.
-
-    Keyword Args:
-        bias (tuple[Tensor], optional): Biases added to outputs. In the training scenario,
-            the bias only supoorts None. Default: ``None`` .
-
-        group_list (Tensor, optional): Represents the index of the different groups on
-            the grouping axis. Supported dtypes: int64. Default: ``None`` .
-
-            If `group_list_type` is 0, it must be a non-negative ascending 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 size 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, where tensors in `x`
-            should be 2-D, tensors in `weight` should be 3-D, and the tensors of result would be
-            2-D.
-
-            If `group_type` is 2, it means that the k-axis is grouped, where each tensor in `x`
-            and `weight` should be 2-D, and the tensors of result would be 3-D.
-
-        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.
-
-    Returns:
-        tuple[Tensor], the results of grouping matrix multiplication.
-
-    Raises:
-        TypeError: If `group_type` is not a int.
-        ValueError: If `group_type` is invalid.
-        ValueError: If the length of `x` or `weight` is not 1.
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        >>> import mindspore
-        >>> 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_v2([x,], [weight,], group_list=group_list, group_list_type=1)
-        >>> print(y[0].shape)
-        >>> [10, 8]
-    """
-    return grouped_matmul_v4(x, weight, bias=bias, group_list=group_list, split_item=3,
-                             group_type=group_type, group_list_type=group_list_type, act_type=0)
-
-
-def gmm_v2_backward(grad, x, weight, *, group_list=None, group_list_type=0):
+def gmm_backward_fusion(grad, weight, group_list=None, group_list_type=0):
     r"""
-    the grad of gmm_v2
+    the grad of ops.function.math_func.gmm, only dx
     """
-    gradients = ops.auto_generate.gmm_v2_backward(grad, x, weight, group_list, group_list_type)
-    dx = gradients[:len(x)]
-    dw = gradients[-len(weight):]
+    dx = ops.functional_overload.gmm_backward_fusion(grad, weight, group_list, group_list_type)
+    dw = []
     db = []
-
     return dx, dw, db