mindspore 2.6.0__cp311-cp311-win_amd64.whl → 2.7.0rc1__cp311-cp311-win_amd64.whl

mindspore/ops/function/math_func.py

@@ -3218,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)
@@ -5621,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
@@ -5782,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:
@@ -9630,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}")
 
 
@@ -9737,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):
@@ -9788,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),
@@ -10207,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):

mindspore/ops/function/nn_func.py

@@ -53,9 +53,10 @@ from mindspore.ops.auto_generate import (reflection_pad_1d_op, reflection_pad_2d
                                          upsample_nearest1d_op, upsample_nearest2d_op, upsample_nearest3d_op,
                                          upsample_linear1d_op, upsample_bilinear2d_op, upsample_bicubic2d_op,
                                          upsample_trilinear3d_impl, fill_scalar_op, floor_op, nllloss_2d_op,
-                                         masked_fill_op, masked_select, ones, flatten_ext, conv_transpose2d)
+                                         masked_fill_op, masked_select, ones, flatten_ext, conv_transpose2d,
+                                         func_max_pool2d_op)
 # 2
-
+from mindspore.ops.auto_generate.pyboost_inner_prim import grid_sampler_2d_impl, grid_sampler_3d_impl
 # 3
 
 # 4
@@ -91,10 +92,10 @@ from mindspore.ops.auto_generate import avg_pool3d_ext_op
 # 19
 
 # 20
-
+from mindspore.ops.functional_overload import conv3d as conv3d_op
 from mindspore.ops.auto_generate.gen_ops_prim import embedding_op, MaxPoolWithIndices, \
     PromptFlashAttention, MaxPoolWithMask
-from mindspore.ops.auto_generate.gen_ops_prim import conv3d_ext_op, conv3d_padding_op, conv2d_ext_op, \
+from mindspore.ops.auto_generate.gen_ops_prim import conv2d_ext_op, \
     conv2d_padding_op, conv1d_ext_op, conv1d_padding_op, speed_fusion_attention_op
 from mindspore.common.generator import default_generator
 from mindspore.ops.auto_generate import hardshrink, hardsigmoid, hardswish
@@ -4420,7 +4421,7 @@ def nll_loss_ext(input, target, weight=None, ignore_index=-100, reduction='mean'
     :math:`N` is the batch size, :math:`c` belonging to :math:`[0, C-1]` is class index,
     where :math:`C` is the number of classes.
 
-    If `reduction` is not ``'None'`` (default ``'mean'``), then
+    If `reduction` is not ``'none'`` (default ``'mean'``), then
 
     .. math::
 
@@ -4444,7 +4445,7 @@ def nll_loss_ext(input, target, weight=None, ignore_index=-100, reduction='mean'
         weight (Tensor, optional): A rescaling weight applied to the loss of each batch element.
             If not None, the shape is :math:`(C,)`.
             The data type must be float16 or float32 or bfloat16(only supported by Atlas A2 training series products).
-            It should have the same data type as `input` . Default: ``'None'`` .
+            It should have the same data type as `input` . Default: ``None`` .
         ignore_index (int, optional): Specifies a target value that is ignored
             and does not contribute to the input gradient. Default: ``-100`` .
         reduction (str, optional): Apply specific reduction method to the output: ``'none'`` , ``'mean'`` ,
@@ -4481,10 +4482,10 @@ def _nllloss_nd(input, target, weight=None, ignore_index=-100, reduction='mean')
         weight = ones(n_classes, input.dtype)
     if input_dim < 1:
         raise ValueError(f"input dim should be less than 1, but got {input_dim}")
-    if input_dim != 1 and input.shape[0] != target.shape[0]:
+    if F.isconstant(input_dim) and F.isconstant(target.ndim) and input_dim != 1 and input.shape[0] != target.shape[0]:
         raise ValueError(f"input bacth_size should be equal to target batch_size, but got {input.shape[0]} and "
                          f"{target.shape[0]}")
-    if input_dim == 1 or input_dim == 2:
+    if input_dim in [1, 2]:
         return nllloss_impl(input, target, weight, reduction, ignore_index)[0]
     if input_dim == 4:
         return nllloss_2d_op(input, target, weight, reduction, ignore_index)[0]
@@ -5365,7 +5366,7 @@ def max_pool3d(x, kernel_size, stride=None, padding=0, dilation=1, ceil_mode=Fal
     return out
 
 
-def grid_sample(input, grid, mode='bilinear', padding_mode='zeros', align_corners=False):
+def grid_sample(input, grid, mode='bilinear', padding_mode='zeros', align_corners=None):
     """
     Given an `input` and a flow-field `grid`, computes the `output` using `input` values and pixel locations from
     `grid`. Only spatial (4-D) and volumetric (5-D) `input` is supported.
@@ -5411,10 +5412,10 @@ def grid_sample(input, grid, mode='bilinear', padding_mode='zeros', align_corner
         padding_mode (str, optional): An optional string specifying the pad method.
             The optional values are "zeros", "border" or
             "reflection". Default: ``'zeros'`` .
-        align_corners (bool, optional): If set to `True`, the extrema (-1 and 1) are considered as referring to
+        align_corners (bool, optional): If set to ``True``, the extrema (-1 and 1) are considered as referring to
             the center points of the input's corner pixels. If set to `False`, they are instead considered as referring
             to the corner points of the input's corner pixels, making the sampling more resolution agnostic. Default:
-            ``False`` .
+            ``None``, which is the same as ``False`` .
 
     Returns:
         Tensor, dtype is the same as `input` and whose shape is :math:`(N, C, H_{out}, W_{out})` (4-D) and
@@ -5451,11 +5452,10 @@ def grid_sample(input, grid, mode='bilinear', padding_mode='zeros', align_corner
           [[14.5      ]
            [14.8      ]]]]
     """
+    align_corners = False if align_corners is None else align_corners
     if input.ndim == 4:
-        _grid_sampler_2d = _get_cache_prim(NN_OPS.GridSampler2D)(mode, padding_mode, align_corners)
-        return _grid_sampler_2d(input, grid)
-    _grid_sampler_3d = _get_cache_prim(NN_OPS.GridSampler3D)(mode, padding_mode, align_corners)
-    return _grid_sampler_3d(input, grid)
+        return grid_sampler_2d_impl(input, grid, mode, padding_mode, align_corners)
+    return grid_sampler_3d_impl(input, grid, mode, padding_mode, align_corners)
 
 
 @constexpr
@@ -6307,7 +6307,7 @@ def conv1d_ext(input, weight, bias=None, stride=1, padding=0, dilation=1, groups
             this 1D convolution layer also can be called 1D depthwise convolution layer. Default: ``1`` .
 
             - :math:`(C_{in} \text{ % } \text{groups} == 0)` , :math:`(C_{out} \text{ % } \text{groups} == 0)` ,
-              :math:`(C_{out} >= \text{groups})` , :math:`(\text{kernel_size[1]} = C_{in} / \text{groups})`。
+              :math:`(C_{out} >= \text{groups})` , :math:`(\text{weight[1]} = C_{in} / \text{groups})`。
 
     Returns:
         Tensor, the value that applied 1D convolution. The shape is :math:`(N, C_{out}, L_{out})`.
@@ -6372,9 +6372,9 @@ def _get_pad_info(dilation, weight):
     for i in range(2):
         d = dilation[i]
         weight_size = weight.shape[i + 2]
-        pad = d * (weight_size - 1)
-        pad_l += (int(pad / 2),)
-        pad_r += (int(pad - pad_l[i]),)
+        pad_item = d * (weight_size - 1)
+        pad_l += (int(pad_item / 2),)
+        pad_r += (int(pad_item - pad_l[i]),)
         if pad_l[i] != pad_r[i]:
             need_pad_nd = True
     return need_pad_nd, pad_l, pad_r
@@ -6477,7 +6477,7 @@ def conv2d_ext(input, weight, bias=None, stride=1, padding=0, dilation=1, groups
         groups (int, optional): Splits `input` into groups. Default: ``1`` .
 
             - :math:`(C_{in} \text{ % } \text{groups} == 0)` , :math:`(C_{out} \text{ % } \text{groups} == 0)` ,
-              :math:`(C_{out} >= \text{groups})` , :math:`(\text{kernel_size[1]} = C_{in} / \text{groups})`
+              :math:`(C_{out} >= \text{groups})` , :math:`(\text{weight[1]} = C_{in} / \text{groups})`
 
     Returns:
         Tensor, the value that applied 2D convolution. The shape is :math:`(N, C_{out}, H_{out}, W_{out})`.
@@ -6981,10 +6981,6 @@ def batch_norm_ext(input, running_mean, running_var, weight=None, bias=None, tra
         [[ 2.1621194  1.2360122]
          [14.810596  10.180061 ]]
     """
-    if weight is None:
-        weight = ops.ones([input.shape[1]], dtype=input.dtype)
-    if bias is None:
-        bias = ops.zeros([input.shape[1]], dtype=input.dtype)
     output = batch_norm_ext_op(input, weight, bias, running_mean, running_var, training, momentum, eps)
     return output[0]
 
@@ -7382,8 +7378,8 @@ def conv3d_ext(input, weight, bias=None, stride=1, padding=0, dilation=1, groups
     - :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:`(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
@@ -7450,12 +7446,7 @@ def conv3d_ext(input, weight, bias=None, stride=1, padding=0, dilation=1, groups
         (12, 26, 59, 47, 5)
     """
 
-    if isinstance(padding, (tuple, list, int)):
-        return conv3d_ext_op(input, weight, bias, stride, padding, dilation, groups)
-    if isinstance(padding, str):
-        return conv3d_padding_op(input, weight, bias, stride, padding, dilation, groups)
-    raise TypeError(f"For conv3d, the parameter 'padding' must be a tuple/list " \
-                    f"or a string, but got {type(padding)}")
+    return conv3d_op(input, weight, bias, stride, padding, dilation, groups)
 
 
 @_primexpr
@@ -7523,7 +7514,7 @@ def pixel_shuffle(input, upscale_factor):
     c, h, w = idx[-3:]
     _check_pxiel_shuffle_valid(c, upscale_factor)
     c = c // upscale_factor ** 2
-    input_perm = (pre + (c, upscale_factor, upscale_factor, h, w))
+    input_perm = pre + (c, upscale_factor, upscale_factor, h, w)
     input = reshape_(input, input_perm)
     input_perm = [i for i in range(length - 2)]
     input_perm = input_perm + [length, length - 2, length + 1, length - 1]
@@ -7587,7 +7578,7 @@ def pixel_unshuffle(input, downscale_factor):
     _check_pxiel_unshuffle_valid(h, w, downscale_factor)
     h = h // downscale_factor
     w = w // downscale_factor
-    input_perm = (pre + (c, h, downscale_factor, w, downscale_factor))
+    input_perm = pre + (c, h, downscale_factor, w, downscale_factor)
     input = reshape_(input, input_perm)
     input_perm = [i for i in range(length - 2)]
     input_perm = input_perm + [length - 1, length + 1, length - 2, length]
@@ -8912,13 +8903,7 @@ def max_pool2d_ext(input, kernel_size, stride=None, padding=0, dilation=1, ceil_
         >>> print(argmax.shape)
         (20, 16, 24, 31)
     """
-    strides = stride if (stride is not None) else kernel_size
-    if return_indices:
-        max_pool_func_ = _get_cache_prim(MaxPoolWithIndices)(kernel_size, strides, padding, dilation, ceil_mode)
-        out, indices = max_pool_func_(input)
-    else:
-        max_pool_func_ = _get_cache_prim(MaxPoolWithMask)(kernel_size, strides, padding, dilation, ceil_mode)
-        out, indices = max_pool_func_(input)
+    out, indices = func_max_pool2d_op(input, kernel_size, stride, padding, dilation, ceil_mode, return_indices)
     if return_indices:
         return out, indices
     return out

mindspore/ops/function/other_func.py

@@ -15,6 +15,7 @@
 """Defines other operators with functional form."""
 from mindspore.ops import operations as P
 from mindspore.ops.auto_generate import rotary_position_embedding
+from mindspore.ops.auto_generate import moe_distribute_dispatch, moe_distribute_combine
 from mindspore.ops.auto_generate.gen_ops_prim import moe_init_routing_v2_op
 
 partial_ = P.Partial()
@@ -268,6 +269,8 @@ __all__ = [
     'partial',
     'rotary_position_embedding',
     'move_to',
-    'moe_init_routing_v2'
+    'moe_init_routing_v2',
+    'moe_distribute_dispatch',
+    'moe_distribute_combine'
 ]
 __all__.sort()