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

mindspore/mint/__init__.py

@@ -16,16 +16,15 @@
 from __future__ import absolute_import
 import mindspore.ops as ops
 from mindspore.ops.primitive import constexpr
-from mindspore.common._register_for_tensor import tensor_operator_registry_for_mint
 from mindspore.common.tensor import Tensor
-from mindspore.ops.function.array_func import gather_ext as gather, max_ext as max, min_ext as min
+from mindspore.ops.function.array_func import gather_ext as gather
 from mindspore.ops.function.nn_func import conv2d_ext as conv2d
 from mindspore.mint.nn.functional import sigmoid
 from mindspore.mint.nn import functional
 from mindspore.mint import linalg
 from mindspore.mint import special
 from mindspore.mint import distributed
-from mindspore.ops import erf, where
+from mindspore.ops import erf
 from mindspore.ops.function.math_func import linspace_ext as linspace
 from mindspore.ops.function.math_func import median_ext as median
 from mindspore.ops.function.array_func import ones_like_ext as ones_like
@@ -33,16 +32,24 @@ from mindspore.ops.function.array_func import full_ext as full
 from mindspore.ops.function.array_func import zeros_like_ext as zeros_like
 from mindspore.ops.function.array_func import unique_ext as unique
 from mindspore.ops.function.array_func import chunk_ext as chunk
+from mindspore.ops.functional_overload import empty
+from mindspore.ops.function.array_func import empty_like
 from mindspore.ops.function.math_func import isclose
 from mindspore.ops.auto_generate import abs
+from mindspore.ops.auto_generate import clone
+from mindspore.ops.function.array_func import full_like_ext as full_like
 # 1
-from mindspore.ops.function.math_func import divide, div
+from mindspore.ops.function.math_func import divide
 from mindspore.ops.auto_generate import topk_ext as topk
 from mindspore.ops.function.math_func import roll
 # 2
 from mindspore.ops.function.math_func import sin
 # 3
-from mindspore.ops.function.clip_func import clamp
+from mindspore.ops.functional_overload import clamp, where
+from mindspore.ops.functional_overload import clip
+from mindspore.ops.functional_overload import fmod
+from mindspore.ops.functional_overload import max
+from mindspore.ops.functional_overload import min
 # 4
 from mindspore.ops.auto_generate import sinc
 from mindspore.ops.auto_generate import sinh
@@ -57,19 +64,22 @@ from mindspore.ops.auto_generate import stack_ext as stack
 from mindspore.ops.function.array_func import unsqueeze
 # 8
 from mindspore.ops.auto_generate import transpose_ext as transpose
+from mindspore.ops.auto_generate import batch_norm_elemt
+from mindspore.ops.auto_generate import batch_norm_gather_stats_with_counts
+from mindspore.ops.auto_generate import batch_norm_stats
 # 9
 from mindspore.ops.auto_generate import masked_select
 from mindspore.ops.function.math_func import cross
 # 10
 from mindspore.ops.function.math_func import ne
 # 11
-
+from mindspore.ops.function.math_func import cdist as cdist_
 # 12
-from mindspore.ops.function.array_func import repeat_interleave_ext as repeat_interleave
+from mindspore.ops.functional_overload import repeat_interleave
 # 13
 from mindspore.ops.functional import flip
 # 14
-
+from mindspore.ops.auto_generate import mv
 # 15
 from mindspore.ops.auto_generate import flatten_ext as flatten
 # 16
@@ -78,17 +88,17 @@ from mindspore.ops.auto_generate import bmm_ext as bmm
 # 17
 
 # 18
-from mindspore.ops.functional import sum
+
 # 19
 from mindspore.ops.functional import log
 # 20
 
 # 21
-from mindspore.ops.functional import mul
+from mindspore.ops.function.math_func import mul_ext as mul
 # 22
-
+from mindspore.ops.functional import cumprod
 # 23
-
+from mindspore.ops.auto_generate import exp2
 # 24
 
 # 25
@@ -170,7 +180,7 @@ from mindspore.ops.functional import maximum
 # 63
 from mindspore.ops.functional import minimum
 # 64
-
+from mindspore.ops.functional import ravel
 # 65
 from mindspore.ops.functional import logical_and
 # 66
@@ -184,7 +194,7 @@ from mindspore.ops.functional import less_equal, le
 # 70
 from mindspore.ops.functional import negative, neg
 # 71
-from mindspore.ops.functional import isfinite
+
 # 72
 
 # 73
@@ -194,7 +204,7 @@ from mindspore.ops.function.array_func import sort_ext as sort
 # 75
 from mindspore.ops.functional import less, lt
 # 76
-from mindspore.ops.functional import pow
+from mindspore.ops.function.math_func import pow_ext as pow
 # 77
 
 # 78
@@ -202,13 +212,13 @@ from mindspore.ops.function import arange_ext as arange
 # 79
 
 # 80
-
+from mindspore.ops.functional_overload import div
 # 81
 from mindspore.ops.auto_generate import index_select_ext as index_select
 # 82
 from mindspore.ops.auto_generate import cummin_ext as cummin
 # 83
-from mindspore.ops.function.array_func import narrow_ext as narrow
+from mindspore.ops.auto_generate import narrow
 # 84
 
 # 85
@@ -220,19 +230,19 @@ from mindspore.ops.auto_generate import trunc
 # 88
 
 # 89
-
+from mindspore.ops.auto_generate import argsort_ext as argsort
 # 90
-
+from mindspore.ops.auto_generate import isinf
 # 91
 
 # 92
-
+from mindspore.ops.function.math_func import polar
 # 93
 
 # 94
 from mindspore.ops.function.math_func import tanh
 # 95
-
+from mindspore.ops.function.math_func import diff_ext as diff
 # 96
 
 # 97
@@ -262,7 +272,7 @@ from mindspore.ops.function.math_func import tanh
 # 109
 from mindspore.ops.auto_generate import argmin_ext as argmin
 # 110
-
+from mindspore.ops.function.nn_func import softmax_ext
 # 111
 
 # 112
@@ -282,11 +292,14 @@ from mindspore.ops.auto_generate import argmin_ext as argmin
 # 119
 
 # 120
-
+from mindspore.ops.auto_generate import isneginf_ext as isneginf
 # 121
 
 # 122
 
+# 123
+from mindspore.ops.function.math_func import var_ext as var
+
 # 151
 from mindspore.ops.function.math_func import acos_ext as acos
 from mindspore.ops.function.math_func import arccos_ext as arccos
@@ -332,12 +345,14 @@ from mindspore.ops.function.random_func import randint_like_ext as randint_like
 from mindspore.ops.auto_generate import floor
 # 231
 from mindspore.ops.function.math_func import inverse_ext as inverse
+# 239
+from mindspore.ops.functional_overload import lerp
 # 244
 from mindspore.ops.auto_generate import log1p
 # 261
 from mindspore.ops.function.random_func import multinomial_ext as multinomial
 # 275
-from mindspore.ops.function.math_func import remainder_ext as remainder
+from mindspore.ops.functional_overload import remainder
 # 285
 from mindspore.ops.function.array_func import scatter_add_ext as scatter_add
 # 289
@@ -350,6 +365,7 @@ from mindspore.ops.function.math_func import tan
 
 # 303
 from mindspore.ops.auto_generate import trace_ext as trace
+from mindspore.ops.auto_generate import gcd
 
 from mindspore.ops.function.array_func import reshape
 
@@ -357,22 +373,93 @@ from mindspore.ops.auto_generate import outer_ext as outer
 
 # 304
 from mindspore.ops.function.array_func import tril_ext as tril
+# 520
+from mindspore.ops.function.math_func import bincount_ext as bincount
 
 # 305
 from mindspore.ops import triu
 
+# 308
+from mindspore.ops.auto_generate import mm_ext as mm
+
+# 382
+from mindspore.ops.function.math_func import dstack
+
+# 501
+from mindspore.ops.function.math_func import addbmm_ext as addbmm
+
+# 502
+from mindspore.ops.function.math_func import addmm_ext as addmm
+
+# 505
+from mindspore.ops.function.math_func import addmv_ext as addmv
+
+# 510
+from mindspore.ops.function.math_func import amax_ext as amax
+
+# 511
+from mindspore.ops.function.math_func import amin_ext as amin
+
+# 521
+from mindspore.ops.functional_overload import bitwise_not
+
+# 526
+from mindspore.ops.auto_generate import dot
+
+# 533
+from mindspore.ops.function.math_func import frac_ext as frac
+
 # 538
 from mindspore.ops.function.math_func import histc_ext as histc
 
+# 552
+from mindspore.ops.auto_generate import log10_ext as log10
+
 # 553
 from mindspore.ops.auto_generate import logaddexp_ext as logaddexp
 
+# 557
+from mindspore.ops.auto_generate import logsumexp_ext as logsumexp
+
+# 582
+from mindspore.ops.function.math_func import std_mean_ext as std_mean
+
+# 588
+from mindspore.ops.function.math_func import var_mean_ext as var_mean
+
 # 610
 from mindspore.ops.function.math_func import nan_to_num
 
+# 613
+from mindspore.ops.functional_overload import nansum
+
+# 664
+from mindspore.ops.function.array_func import meshgrid_ext as meshgrid
+
 # 695
 from mindspore.ops.auto_generate import count_nonzero
 
+# 697
+from mindspore.ops.function.math_func import float_power_ext as float_power
+
+# 708
+from mindspore.ops.function.math_func import std_ext as std
+
+# 887
+from mindspore.ops.auto_generate import log2_ext as log2
+
+# 889
+from mindspore.ops.function.math_func import isnan_ext as isnan
+
+# 1007
+from mindspore.ops.auto_generate import t_ext as t
+from mindspore.ops.auto_generate.pyboost_inner_prim import squeeze_impl
+from mindspore.ops.auto_generate.gen_ops_prim import equal_ext_op
+
+
+# 1023
+from mindspore.ops.function.array_func import unbind_ext as unbind
+
 
 def add(input, other, *, alpha=1):
     r"""
@@ -399,7 +486,7 @@ def add(input, other, *, alpha=1):
             `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
 
     Keyword Args:
-        alpha (number.Number): A scaling factor applied to `other`, default 1.
+        alpha (number.Number): A scaling factor applied to `other`, default: ``1``.
 
     Returns:
         Tensor with a shape that is the same as the broadcasted shape of the input `input` and `other`,
@@ -445,7 +532,7 @@ def any(input, dim=None, keepdim=False):
         input (Tensor): Input Tensor, has the shape :math:`(N, *)` where :math:`*` means,
             any number of additional dimensions.
         dim (Union[int, tuple(int), list(int), Tensor], optional): The dimensions to reduce.
-            Suppose the rank of `input` is r, `dim` must be in the range [-rank(input), rank(input)).
+            Suppose the rank of `input` is r, `dim` must be in the range [-r,r).
             Default: ``None`` , all dimensions are reduced.
         keepdim (bool, optional): If ``True`` , keep these reduced dimensions and the length is 1.
             If ``False`` , don't keep these dimensions. Default : ``False`` .
@@ -457,7 +544,7 @@ def any(input, dim=None, keepdim=False):
           the output is a 0-D Tensor representing the "logical OR" of all elements in the input Tensor.
         - If `dim` is int, such as 2, and `keepdim` is ``False`` ,
           the shape of output is :math:`(input_1, input_3, ..., input_R)`.
-        - If `dim` is tuple(int), such as (2, 3), and `keepdim` is ``False`` ,
+        - If `dim` is tuple(int) or list(int), such as (2, 3), and `keepdim` is ``False`` ,
           the shape of output is :math:`(input_1, input_4, ..., input_R)`.
         - If `dim` is 1-D Tensor, such as [2, 3], and `keepdim` is ``False`` ,
           the shape of output is :math:`(input_1, input_4, ..., input_R)`.
@@ -494,6 +581,35 @@ def any(input, dim=None, keepdim=False):
 
 def all(input, dim=None, keepdim=False):
     r"""
+    all(input) -> Tensor
+
+    Reduces all elements of `input` by the "logical AND".
+
+    Args:
+        input (Tensor): Input Tensor, has the shape :math:`(N, *)` where :math:`*` means,
+            any number of additional dimensions.
+
+    Returns:
+        Tensor, the dtype is bool.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, mint
+        >>> x = Tensor(np.array([[True, False], [True, True]]))
+        >>> # case 1: Reduces a dimension by the "logicalAND" of all elements in the dimension.
+        >>> output = mint.all(x)
+        >>> print(output)
+        False
+
+    .. function:: all(input, dim, keepdim=False) -> Tensor
+        :noindex:
+
     Reduces a dimension of `input` by the "logical AND" of all elements in the dimension, by default. And also can
     reduce a dimension of `input` along the `dim`. Determine whether the dimensions of the output and input are the
     same by controlling `keepdim`.
@@ -504,20 +620,17 @@ def all(input, dim=None, keepdim=False):
     Args:
         input (Tensor): Input Tensor, has the shape :math:`(N, *)` where :math:`*` means,
             any number of additional dimensions.
-        dim (Union[int, tuple(int), list(int), Tensor], optional): The dimensions to reduce.
+        dim (Union[int, tuple(int), list(int), Tensor]): The dimensions to reduce.
             Suppose the rank of `input` is r, `dim` must be in the range [-rank(input), rank(input)).
-            Default: ``None`` , all dimensions are reduced.
         keepdim (bool, optional): If ``True`` , keep these reduced dimensions and the length is 1.
             If ``False`` , don't keep these dimensions. Default : ``False`` .
 
     Returns:
         Tensor, the dtype is bool.
 
-        - If `dim` is ``None`` , and `keepdim` is ``False`` ,
-          the output is a 0-D Tensor representing the "logical AND" of all elements in the input Tensor.
         - If `dim` is int, such as 2, and `keepdim` is ``False`` ,
           the shape of output is :math:`(input_1, input_3, ..., input_R)`.
-        - If `dim` is tuple(int), such as (2, 3), and `keepdim` is ``False`` ,
+        - If `dim` is tuple(int) or list(int), such as (2, 3), and `keepdim` is ``False`` ,
           the shape of output is :math:`(input_1, input_4, ..., input_R)`.
         - If `dim` is 1-D Tensor, such as [2, 3], and `keepdim` is ``False`` ,
           the shape of output is :math:`(input_1, input_4, ..., input_R)`.
@@ -534,17 +647,11 @@ def all(input, dim=None, keepdim=False):
         >>> import numpy as np
         >>> from mindspore import Tensor, mint
         >>> x = Tensor(np.array([[True, False], [True, True]]))
-        >>> # case 1: Reduces a dimension by the "logicalAND" of all elements in the dimension.
-        >>> output = mint.all(x, keepdim=True)
-        >>> print(output)
-        [[False]]
-        >>> print(output.shape)
-        (1, 1)
-        >>> # case 2: Reduces a dimension along axis 0.
+        >>> # case 1: Reduces a dimension along axis 0.
         >>> output = mint.all(x, dim=0)
         >>> print(output)
         [ True False]
-        >>> # case 3: Reduces a dimension along axis 1.
+        >>> # case 2: Reduces a dimension along axis 1.
         >>> output = mint.all(x, dim=1)
         >>> print(output)
         [False True]
@@ -552,6 +659,53 @@ def all(input, dim=None, keepdim=False):
     return ops.function.math_func.all(input, dim, keepdim)
 
 
+def allclose(input, other, rtol=1e-05, atol=1e-08, equal_nan=False):
+    """
+    Returns a new Tensor with boolean elements representing if each element of `input`
+    is “close” to the corresponding element of `other`. Closeness is defined as:
+
+    .. math::
+        |input-other| ≤ atol + rtol × |other|
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): First tensor to compare.
+            Support dtype: float16, float32, float64, int8, int16, int32, int64 and uint8.
+            On Ascend, more dtypes are support: bool and bfloat16.
+        other (Tensor): Second tensor to compare. Dtype must be same as `input`.
+        rtol (Union[float, int, bool], optional): Relative tolerance. Default: ``1e-05`` .
+        atol (Union[float, int, bool], optional): Absolute tolerance. Default: ``1e-08`` .
+        equal_nan (bool, optional): If ``True`` , then two NaNs will be considered equal. Default: ``False``.
+
+    Returns:
+        A bool Scalar.
+
+    Raises:
+        TypeError: `input` or `other` is not Tensor.
+        TypeError: `input` or `other` dtype is not support.
+        TypeError: `atol` or `rtol` is not float, int or bool.
+        TypeError: `equal_nan` is not bool.
+        TypeError: `input` and `other` have different dtypes.
+        ValueError: `input` and `other` cannot broadcast.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, ops
+        >>> input = Tensor(np.array([1.3, 2.1, 3.2, 4.1, 5.1]), mindspore.float16)
+        >>> other = Tensor(np.array([1.3, 3.3, 2.3, 3.1, 5.1]), mindspore.float16)
+        >>> output = mint.allclose(input, other)
+        >>> print(output)
+        False
+    """
+    return isclose(input, other, rtol, atol, equal_nan).all().item()
+
+
 def cat(tensors, dim=0):
     r"""
     Connect input tensors along with the given dimension.
@@ -572,7 +726,7 @@ def cat(tensors, dim=0):
             all other dimensions should be equal, that is,
             :math:`t1.shape[1] = t2.shape[1], t1.shape[2] = t2.shape[2], ..., t1.shape[R-1] = t2.shape[R-1]`,
             where :math:`R` represents the rank of tensor.
-        dim (int): The specified dimension, whose value is in range :math:`[-R, R)`. Default: ``0`` .
+        dim (int, optional): The specified dimension, whose value is in range :math:`[-R, R)`. Default: ``0`` .
 
     Returns:
         Tensor, the shape is :math:`(x_1, x_2, ..., \sum_{i=1}^Nx_{mi}, ..., x_R)`.
@@ -611,10 +765,13 @@ def cat(tensors, dim=0):
 
 def concat(tensors, dim=0):
     r"""
+    Alias for :func:`mindspore.mint.cat`.
+
     .. warning::
         This is an experimental API that is subject to change or deletion.
 
-    Alias of mint.cat().
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
     """
     return cat(tensors, dim)
 
@@ -629,6 +786,9 @@ def cummax(input, dim):
             y_{i} = \max(x_{1}, x_{2}, ... , x_{i})
         \end{array}
 
+    .. note::
+        O2 mode is not supported in Ascend.
+
     Args:
         input (Tensor): The input Tensor. Rank of `input` must be greater than 0.
         dim (int): The dimension to do the operation over. The value of `dim` must be in the range
@@ -643,9 +803,6 @@ def cummax(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``
 
@@ -670,6 +827,26 @@ def cummax(input, dim):
     return ops.auto_generate.cummax(input, dim)
 
 
+def not_equal(input, other):
+    r"""
+    Alias for :func:`mindspore.mint.ne` .
+
+    Supported Platforms:
+        ``Ascend``
+    """
+    return ne(input, other)
+
+
+def softmax(input, dim, *, dtype=None):
+    r"""
+    Alias for :func:`mindspore.mint.nn.functional.softmax`.
+
+    Supported Platforms:
+        ``Ascend``
+    """
+    return softmax_ext(input, dim, dtype)
+
+
 def _einsum_convert_sublist_to_label(num, ell_num=False):
     """Convert sublist to label."""
     if num == Ellipsis or ell_num and num == 52:
@@ -678,7 +855,8 @@ def _einsum_convert_sublist_to_label(num, ell_num=False):
         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}')
+    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):
@@ -690,7 +868,8 @@ def _einsum_convert_label_to_index(label):
         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}')
+    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):
@@ -713,18 +892,21 @@ def _einsum_convert_sublist(equation, *operands):
             operands_tmp = list([equation]) + list(operands[1::2])
         equation = equation_tmp
         operands = tuple(operands_tmp)
-    if len(operands) == 0: # pylint: disable=len-as-condition
-        raise ValueError("For einsum, the 'operands' must have at least one operand.")
+    if len(operands) == 0:  # pylint: disable=len-as-condition
+        raise ValueError(
+            "For einsum, the 'operands' must have at least one operand.")
     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)}.")
+        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)}.")
+            raise TypeError(
+                f"For einsum, members of 'operands' must be Tensor, but got {type(operand)}.")
 
 
 @constexpr
@@ -737,7 +919,8 @@ def _einsum_parse_equation(equation):
     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.')
+            raise ValueError(
+                'For einsum, equation must contain characters to the left fo the arrow.')
     else:
         l_equation = equation
 
@@ -752,13 +935,15 @@ def _einsum_parse_equation(equation):
         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('...', '.')]
+        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('...', '.')]
+    r_equationlst = [_einsum_convert_label_to_index(
+        label) for label in r_equation.replace('...', '.')]
 
     return l_equationlst, r_equationlst, ('->' in equation)
 
@@ -767,8 +952,8 @@ 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
-    labels2dimlst = [None] * max_labels
 
     if len(operands) != len(l_equationlst):
         raise ValueError(f"For einsum, 'operands' is not equal to specified in the 'equation', "
@@ -779,67 +964,70 @@ def _einsum_parse_labels(l_equationlst, operands):
         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
-            if labels2dimlst[label] is None:
-                labels2dimlst[label] = operand_shape[start_dim:end_dim]
-                align_rank += (end_dim - start_dim)
-            else:
-                if labels2dimlst[label] != operand_shape[start_dim:end_dim]:
-                    raise ValueError(f"For einsum, one label in 'equation' can only represent the same dimension "
-                                     f"in 'operands', but '{_einsum_convert_sublist_to_label(label, True)}' "
-                                     f"represented different dimensions.")
+                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 = end_dim
+            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 labels2dimlst, labels_count, align_rank
+    return ellipsis_dimnum, labels_count, align_rank
 
 
-def _einsum_infer_output(r_equationlst, arrow_exist, labels2dimlst, labels_count):
+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_shape = []
+    output_rank = 0
     labels_perm_idx = [idle_idx] * 53
 
     if arrow_exist:
         for label in r_equationlst:
             if labels_count[label] != 0:
-                output_shape += labels2dimlst[label]
                 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
-                idx += len(labels2dimlst[label])
+                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_shape += labels2dimlst[52]
+            output_rank += ellipsis_dimnum
             labels_perm_idx[52] = idx
-            idx += len(labels2dimlst[52])
+            idx += ellipsis_dimnum
         for label, count in enumerate(labels_count):
             if count == 1:
-                output_shape += labels2dimlst[label]
+                output_rank += 1
                 labels_perm_idx[label] = idx
-                idx += len(labels2dimlst[label])
+                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_shape, labels_perm_idx
+    return output_rank, labels_perm_idx
 
 
-def _einsum_adjust_operands(operands, l_equationlst, labels2dimlst, labels_perm_idx, align_rank):
+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.
@@ -865,7 +1053,7 @@ def _einsum_adjust_operands(operands, l_equationlst, labels2dimlst, labels_perm_
             else:
                 label_dims[label] = dim
                 if label == 52:
-                    for ell_idx in range(len(labels2dimlst[label])):
+                    for ell_idx in range(ellipsis_dimnum):
                         align_axis[labels_perm_idx[label] + ell_idx] = dim
                         dim += 1
                 else:
@@ -886,7 +1074,7 @@ def _einsum_adjust_operands(operands, l_equationlst, labels2dimlst, labels_perm_
 
 def _einsum_find_dimlastop(align_rank, operands, adjust_operands):
     """Find dim last operand."""
-    dim_last_op = [0 for _ in range(align_rank)]
+    dim_last_op = [0] * align_rank
     has_zero_dim = False
     for dim in range(align_rank):
         broadcast_dim = adjust_operands[0].shape[dim]
@@ -939,7 +1127,7 @@ def _einsum_multiplication(sum_dims, l_tensor, r_tensor):
             ronly_size *= r_shape[i]
 
     # Compute the einsum bmm operators pipeline.
-    # The whole operators pipline is transpose(in) -> reshape(in) -> bmm(in) -> reshape(out) -> transpose(out).
+    # 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)
 
@@ -976,37 +1164,33 @@ def _einsum_multiplication(sum_dims, l_tensor, r_tensor):
     return reshape(output, output_squeeze_shape)
 
 
-def _einsum_squeeze(operand, dim):
-    '''Will be replaced by mint.squeeze in the future'''
-    operand_shape = operand.shape
-    squeeze_shape = []
-    for idx in range(len(operand_shape)):
-        if idx != dim:
-            squeeze_shape.append(operand_shape[idx])
-    return reshape(operand, squeeze_shape)
-
-
 def _einsum(equation, operands):
     '''Einsum main process'''
-    _l_equationlst, _r_equationlst, _arrow_exist = _einsum_parse_equation(equation)
-    _labels2dimlst, _labels_count, _align_rank = _einsum_parse_labels(_l_equationlst, operands)
-    _output_shape, _labels_perm_idx = _einsum_infer_output(_r_equationlst, _arrow_exist, _labels2dimlst, _labels_count)
-    _output_rank = len(_output_shape)
-
-    _adjust_operands = _einsum_adjust_operands(operands, _l_equationlst, _labels2dimlst, _labels_perm_idx, _align_rank)
-    _dim_last_op, _has_zero_dim = _einsum_find_dimlastop(_align_rank, operands, _adjust_operands)
+    _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:
-        return zeros(_output_shape, dtype=_result.dtype)
+        output_shape = []
+        for dim in range(_output_rank):
+            output_shape.append(_adjust_operands[_dim_last_op[dim]].shape[dim])
+        return 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 = _einsum_squeeze(_result, _reduce_dim)
+                _result = squeeze(_result, _reduce_dim)
             else:
                 _result = sum(_result, _reduce_dim)
         else:
@@ -1019,11 +1203,11 @@ def _einsum(equation, operands):
         sum_dims = []
         for j in range(_output_rank, _align_rank):
             if _dim_last_op[j] < i:
-                operand = _einsum_squeeze(operand, dim)
+                operand = squeeze(operand, dim)
             elif _dim_last_op[j] == i:
                 if _result.shape[dim] == 1:
                     operand = sum(operand, dim)
-                    _result = _einsum_squeeze(_result, dim)
+                    _result = squeeze(_result, dim)
                 else:
                     sum_dims.append(dim)
                     dim += 1
@@ -1050,16 +1234,22 @@ def einsum(equation, *operands):
         The sublist format is also supported. For example, mint.einsum(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/docs/en/master/model_train/program_form/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 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.
+            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:
@@ -1138,6 +1328,81 @@ def einsum(equation, *operands):
     return _einsum(_equation, _operands)
 
 
+def equal(input, other):
+    r"""
+    Computes the equivalence between two tensors.
+
+    Note:
+        `input` and `other` comply with the implicit type conversion rules to make the data types consistent.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): The first input.
+        other (Tensor): The second input.
+
+    Returns:
+        bool.
+
+    Raises:
+        TypeError: If `input` or `other` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import Tensor, mint
+        >>> x = Tensor([1, 2, 3], mindspore.int32)
+        >>> y = Tensor([1, 2, 4], mindspore.int32)
+        >>> output = mint.equal(x, y)
+        >>> print(output)
+        False
+    """
+    result = equal_ext_op(input, other)
+    return result.item()
+
+
+def isfinite(input):
+    r"""
+    Determine which elements are finite for each position. If elements are not ``NaN`` , ``-INF`` , ``INF``,
+    they are finite.
+
+    .. math::
+        out_i = \begin{cases}
+          & \text{ if } input_{i} = \text{Finite},\ \ True \\
+          & \text{ if } input_{i} \ne \text{Finite},\ \ False
+        \end{cases}
+
+    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`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, mint
+        >>> x = Tensor(np.array([np.log(-1), 1, np.log(0)]), mindspore.float32)
+        >>> output = mint.isfinite(x)
+        >>> print(output)
+        [False True False]
+        >>> x = Tensor(2.1, mindspore.float64)
+        >>> output = mint.isfinite(x)
+        >>> print(output)
+        True
+    """
+    return ops.auto_generate.isfinite(input)
+
+
 def item(input):
     r"""
     Returns the value of this tensor as a standard Python number.
@@ -1178,6 +1443,43 @@ def item(input):
 
 def mean(input, dim=None, keepdim=False, *, dtype=None):
     r"""
+    mean(input, *, dtype=None) -> Tensor
+
+    Reduces all dimension of a tensor by averaging all elements.
+
+    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.
+
+    Keyword Args:
+        dtype (:class:`mindspore.dtype`, optional): The desired data type of returned Tensor. Default: ``None`` .
+
+    Returns:
+        Tensor.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, mint
+        >>> x = Tensor(np.array([[[2, 2, 2, 2, 2, 2], [2, 2, 2, 2, 2, 2], [2, 2, 2, 2, 2, 2]],
+        ... [[4, 4, 4, 4, 4, 4], [5, 5, 5, 5, 5, 5], [6, 6, 6, 6, 6, 6]],
+        ... [[6, 6, 6, 6, 6, 6], [8, 8, 8, 8, 8, 8], [10, 10, 10, 10, 10, 10]]]),
+        ... mindspore.float32)
+        >>> output = mint.mean(x)
+        >>> print(output)
+        5.0
+        >>> print(output.shape)
+        ()
+
+    .. function:: mean(input, dim, keepdim=False, *, dtype=None) -> Tensor
+        :noindex:
+
     Reduces all dimension of a tensor by averaging all elements in the dimension, by default.
     And reduce a dimension of `input` along the specified `dim`. `keepdim`
     determines whether the dimensions of the output and input are the same.
@@ -1188,9 +1490,8 @@ def mean(input, dim=None, keepdim=False, *, dtype=None):
     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.
-        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).
+        dim (Union[int, tuple(int), list(int), Tensor]): The dimensions to reduce.
+            Only constant value is allowed. Assume the rank of `input` is r, and the value range is [-r,r).
         keepdim (bool): If ``True`` , keep these reduced dimensions and the length is 1.
             If ``False`` , don't keep these dimensions. Default: ``False`` .
 
@@ -1200,8 +1501,6 @@ def mean(input, dim=None, keepdim=False, *, dtype=None):
     Returns:
         Tensor.
 
-        - 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 `dim` is int, set as 1, and `keepdim` is ``False`` ,
           the shape of output is :math:`(input_0, input_2, ..., input_R)`.
         - If `dim` is tuple(int) or list(int), set as (1, 2), and `keepdim` is ``False`` ,
@@ -1222,51 +1521,57 @@ def mean(input, dim=None, keepdim=False, *, dtype=None):
         >>> import mindspore
         >>> import numpy as np
         >>> from mindspore import Tensor, mint
-        >>> x = Tensor(np.random.randn(3, 4, 5, 6).astype(np.float32))
-        >>> output = mint.mean(x, 1, keepdim=True)
-        >>> result = output.shape
-        >>> print(result)
-        (3, 1, 5, 6)
-        >>> # case 1: Reduces a dimension by averaging all elements in the dimension.
         >>> x = Tensor(np.array([[[2, 2, 2, 2, 2, 2], [2, 2, 2, 2, 2, 2], [2, 2, 2, 2, 2, 2]],
         ... [[4, 4, 4, 4, 4, 4], [5, 5, 5, 5, 5, 5], [6, 6, 6, 6, 6, 6]],
         ... [[6, 6, 6, 6, 6, 6], [8, 8, 8, 8, 8, 8], [10, 10, 10, 10, 10, 10]]]),
         ... mindspore.float32)
-        >>> output = mint.mean(x)
-        >>> print(output)
-        5.0
-        >>> print(output.shape)
-        ()
-        >>> # case 2: Reduces a dimension along the axis 0
         >>> output = mint.mean(x, 0, True)
         >>> print(output)
         [[[4. 4. 4. 4. 4. 4.]
           [5. 5. 5. 5. 5. 5.]
           [6. 6. 6. 6. 6. 6.]]]
-        >>> # case 3: Reduces a dimension along the axis 1
-        >>> output = mint.mean(x, 1, True)
-        >>> print(output)
-        [[[2. 2. 2. 2. 2. 2.]]
-         [[5. 5. 5. 5. 5. 5.]]
-         [[8. 8. 8. 8. 8. 8.]]]
-        >>> # case 4: Reduces a dimension along the axis 2
-        >>> output = mint.mean(x, 2, True)
-        >>> print(output)
-        [[[ 2.]
-          [ 2.]
-          [ 2.]]
-         [[ 4.]
-          [ 5.]
-          [ 6.]]
-         [[ 6.]
-          [ 8.]
-          [10.]]]
     """
-    return ops.function.math_func.mean_ext(input, axis=dim, keep_dims=keepdim, dtype=dtype)
+    return ops.auto_generate.mean_ext(input, dim, keepdim, dtype)
 
 
 def prod(input, dim=None, keepdim=False, *, dtype=None):
     r"""
+    prod(input, *, dtype=None) -> Tensor
+
+    Multiplying all elements of input.
+
+    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.
+
+    Keyword Args:
+        dtype (:class:`mindspore.dtype`, optional): The desired data type of returned Tensor. Default: ``None`` .
+
+    Returns:
+        Tensor.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, mint
+        >>> 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 = mint.prod(x)
+        >>> print(output)
+        2.2833798e+33
+        >>> print(output.shape)
+        ()
+
+    .. function:: prod(input, dim, keepdim=False, *, dtype=None) -> Tensor
+        :noindex:
+
     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 `dim`. Determine whether the dimensions of the output and input are the
     same by controlling `keepdim`.
@@ -1274,7 +1579,7 @@ def prod(input, dim=None, keepdim=False, *, dtype=None):
     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.
-        dim (int): The dimensions to reduce. Default: ``None`` , reduce all dimensions. Only constant value is allowed.
+        dim (int): The dimensions to reduce. Only constant value is allowed.
             Assume the rank of `x` is r, and the value range is [-r,r).
         keepdim (bool): If ``True`` , keep these reduced dimensions and the length is 1.
             If ``False`` , don't keep these dimensions. Default: ``False`` .
@@ -1285,8 +1590,6 @@ def prod(input, dim=None, keepdim=False, *, dtype=None):
     Returns:
         Tensor.
 
-        - 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 `dim` is int, set as 1, and `keepdim` is ``False`` ,
           the shape of output is :math:`(input_0, input_2, ..., input_R)`.
 
@@ -1303,46 +1606,112 @@ def prod(input, dim=None, keepdim=False, *, dtype=None):
         >>> import mindspore
         >>> import numpy as np
         >>> from mindspore import Tensor, mint
-        >>> x = Tensor(np.random.randn(3, 4, 5, 6).astype(np.float32))
-        >>> output = mint.prod(x, 1, keepdim=True)
-        >>> result = output.shape
-        >>> print(result)
-        (3, 1, 5, 6)
-        >>> # case 1: Reduces a dimension by multiplying all elements in the dimension.
         >>> 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 = mint.prod(x)
-        >>> print(output)
-        2.2833798e+33
-        >>> print(output.shape)
-        ()
-        >>> # case 2: Reduces a dimension along axis 0.
         >>> output = mint.prod(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 = mint.prod(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 = mint.prod(x, 2, True)
-        >>> print(output)
-        [[[1.00000e+00]
-          [6.40000e+01]
-          [7.29000e+02]]
-         [[4.09600e+03]
-          [1.56250e+04]
-          [4.66560e+04]]
-         [[1.17649e+05]
-          [2.62144e+05]
-          [5.31441e+05]]]
     """
-    return ops.auto_generate.prod_ext(input, axis=dim, keep_dims=keepdim, dtype=dtype)
+    return ops.auto_generate.prod_ext(input, dim, keepdim, dtype)
+
+
+def sum(input, dim=None, keepdim=False, *, dtype=None):
+    r'''
+    sum(input, *, dtype=None) -> Tensor
+
+    Calculate sum of all elements in Tensor.
+
+    Args:
+        input (Tensor): The input tensor.
+
+    Keyword Args:
+        dtype (:class:`mindspore.dtype`, optional): The desired data type of returned Tensor. Default: ``None`` .
+
+    Returns:
+        A Tensor, sum of all elements in `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, mint
+        >>> from mindspore import dtype as mstype
+        >>> 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]]]), mstype.float32)
+        >>> out = mint.sum(x)
+        >>> print(out)
+        270.0
+
+    .. function:: sum(input, dim, keepdim=False, *, dtype=None) -> Tensor
+        :noindex:
+
+    Calculate sum of Tensor elements over a given dim.
+
+    Note:
+        The `dim` with tensor type is only used for compatibility with older versions and is not recommended.
+
+    Args:
+        input (Tensor): The input tensor.
+        dim (Union[int, tuple(int), list(int), Tensor]): Dimensions along which a sum is performed.
+            If the `dim` is a tuple or list of ints, a sum is performed on all the dimensions specified in the tuple.
+            Must be in the range :math:`[-input.ndim, input.ndim)` .
+        keepdim (bool): Whether the output tensor has `dim` retained or not.
+            If ``True`` , keep these reduced dimensions and the length is 1.
+            If ``False`` , don't keep these dimensions. Default: ``False`` .
+
+    Keyword Args:
+        dtype (:class:`mindspore.dtype`, optional): The desired data type of returned Tensor. Default: ``None`` .
+
+    Returns:
+        A Tensor, sum of elements over a given `dim` in `input`.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If `dim` is not an int, tulpe(int), list(int) or Tensor.
+        ValueError: If `dim` is not in the range :math:`[-input.ndim, input.ndim)` .
+        TypeError: If `keepdim` is not a bool.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, mint
+        >>> from mindspore import dtype as mstype
+        >>> 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]]]), mstype.float32)
+        >>> out = mint.sum(x)
+        >>> print(out)
+        270.0
+        >>> out = mint.sum(x, dim=2)
+        >>> print(out)
+        [[ 6. 12. 18.]
+         [24. 30. 36.]
+         [42. 48. 54.]]
+        >>> out = mint.sum(x, dim=2, keepdim=True)
+        >>> print(out)
+        [[[ 6.]
+          [12.]
+          [18.]]
+         [[24.]
+          [30.]
+          [36.]]
+         [[42.]
+          [48.]
+          [54.]]]
+    '''
+    return ops.auto_generate.sum_ext(input, dim, keepdim, dtype)
 
 
 def ones(size, *, dtype=None):
@@ -1365,7 +1734,7 @@ def ones(size, *, dtype=None):
         Tensor, whose dtype and size are defined by input.
 
     Raises:
-        TypeError: If `size` is neither an int nor an tuple/list/Tensor of int.
+        TypeError: If `size` is neither an int nor a tuple/list/Tensor of int.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -1429,7 +1798,7 @@ def split(tensor, split_size_or_sections, dim=0):
             if `tensor.shape[dim]` is not divisible by `split_size_or_sections`.
             If `split_size_or_sections` is a list type, then `tensor` will be split into len(split_size_or_sections)
             chunks with sizes `split_size_or_sections` along the given `dim`.
-        dim (int): The dim along which to split. Default: ``0`` .
+        dim (int, optional): The dim along which to split. Default: ``0`` .
 
     Returns:
         A tuple of sub-tensors.
@@ -1437,10 +1806,10 @@ def split(tensor, split_size_or_sections, dim=0):
     Raises:
         TypeError: If argument `tensor` is not Tensor.
         TypeError: If argument `dim` is not int.
-        ValueError: If argument `dim` is out of range of :[-tensor.ndim, tensor.ndim).
+        ValueError: If argument `dim` is out of range of [-tensor.ndim, tensor.ndim).
         TypeError: If each element in `split_size_or_sections` is not integer.
         TypeError: If argument `split_size_or_sections` is not int, tuple(int) or list(int).
-        ValueError: The sum of `split_size_or_sections` is not equal to x.shape[dim].
+        ValueError: The sum of `split_size_or_sections` is not equal to tensor.shape[dim].
 
     Supported Platforms:
         ``Ascend``
@@ -1490,6 +1859,56 @@ def sqrt(input):
     return ops.auto_generate.sqrt(input)
 
 
+def squeeze(input, dim):
+    r"""
+    Return the Tensor after deleting the dimension of size 1 in the specified `dim`.
+
+    If :math:`dim=()`, it will remove all the dimensions of size 1.
+    If `dim` is specified, it will remove the dimensions of size 1 in the given `dim`.
+    For example, if the dimension is not specified :math:`dim=()`, input shape is (A, 1, B, C, 1, D),
+    then the shape of the output Tensor is (A, B, C, D). If the dimension is specified, the squeeze operation
+    is only performed in the specified dimension. If input shape is (A, 1, B), when :math:`dim=0` or :math:`dim=2`,
+    the input tensor is not changed, while when :math:`dim=1`, the input tensor shape is changed to (A, B).
+
+    Note:
+        - Please note that in dynamic graph mode, the output Tensor will share data with the input Tensor,
+          and there is no Tensor data copy process.
+        - The dimension index starts at 0 and must be in the range `[-input.ndim, input.ndim]`.
+        - In GE mode, only support remove dimensions of size 1 from the shape of input tensor.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): Used to calculate Squeeze. The shape of tensor is :math:`(x_1, x_2, ..., x_R)`.
+        dim (Union[int, tuple(int)]): Specifies the dimension indexes of shape to be removed, which will
+            remove all the dimensions of size 1 in the given dim parameter. If specified, it must be int32 or int64.
+
+    Returns:
+        Tensor, the shape of tensor is :math:`(x_1, x_2, ..., x_S)`.
+
+    Raises:
+        TypeError: If `input` is not a tensor.
+        TypeError: If `dim` is not an int, tuple.
+        TypeError: If `dim` is a tuple whose elements are not all int.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, mint
+        >>> input = Tensor(np.ones(shape=[3, 2, 1]), mindspore.float32)
+        >>> output = mint.squeeze(input, 2)
+        >>> print(output)
+        [[1. 1.]
+         [1. 1.]
+         [1. 1.]]
+    """
+    return squeeze_impl(input, dim)
+
+
 def sub(input, other, *, alpha=1):
     r"""
     Subtracts scaled other value from input Tensor.
@@ -1515,7 +1934,7 @@ def sub(input, other, *, alpha=1):
             `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
 
     Keyword Args:
-        alpha (number.Number): A scaling factor applied to `other`, default 1.
+        alpha (number.Number, optional): A scaling factor applied to `other`, default ``1``.
 
     Returns:
         Tensor with a shape that is the same as the broadcasted shape of the input `input` and `other`,
@@ -1550,7 +1969,13 @@ def sub(input, other, *, alpha=1):
 
 def swapaxes(input, axis0, axis1):
     '''
-    Interchange two axes of a tensor, alias for mint.transpose()
+    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.
+
+    For more details, see :func:`mindspore.mint.transpose` .
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
     Examples:
         >>> import numpy as np
@@ -1564,6 +1989,67 @@ def swapaxes(input, axis0, axis1):
     return transpose(input, axis0, axis1)
 
 
+def unique_consecutive(input, return_inverse=False, return_counts=False, dim=None):
+    r"""
+    Returns the elements that are unique in each consecutive group of equivalent elements in the input tensor.
+
+    When `return_inverse=True` , it returns a tensor containing the indices of the elements in the input tensor
+    within the output tensor.
+
+    When `return_counts=True` , it returns a tensor representing the number of occurrences of each output element
+    in the input.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Args:
+        input (Tensor): The input tensor.
+        return_inverse (bool, optional): Whether to return the index of where the element in the original input
+            maps to the position in the output. Default: ``False`` .
+        return_counts (bool, optional): Whether to return the counts of each unique element. Default: ``False`` .
+        dim (int, optional): The dimension to apply unique. If ``None`` , the unique of the flattened input is
+            returned. If specified, it must be int32 or int64. Default: ``None`` .
+
+    Returns:
+        A tensor or a tuple of tensors containing tensor objects (`output`, `inverse_indices`, `counts`).
+
+        - **output** (Tensor): the output tensor has the same type as `input` and represents the output list of
+          unique scalar elements.
+        - **inverse_indices** (Tensor, optional): if `return_inverse` is True, there will be an additional returned
+          tensor `inverse_indices`. `inverse_indices` has the same shape as `input` and represents the index of where
+          the element in the original input maps to the position in the output.
+        - **counts** (Tensor, optional):  if `return_counts` is True, there will be an additional returned tensor
+          `counts`. `counts` has the same shape as `output` or `output.shape[dim]` if dim was specified and represents
+          the number of occurrences for each unique value or tensor.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        TypeError: If dtype of `input` is not supported.
+        TypeError: If `return_inverse` is not a bool.
+        TypeError: If `return_counts` is not a bool.
+        TypeError: If `dim` is not an int.
+        ValueError: If `dim` is not in the range of :math:`[-ndim, ndim-1]`.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor, mint
+        >>> from mindspore import dtype as mstype
+        >>> x = Tensor(np.array([1, 1, 2, 2, 3, 1, 1, 2]), mstype.int64)
+        >>> output, inverse_indices, counts = mint.unique_consecutive(x, True, True, None)
+        >>> print(output)
+        [1 2 3 1 2]
+        >>> print(inverse_indices)
+        [0 0 1 1 2 3 3 4]
+        >>> print(counts)
+        [2 2 1 2 1]
+    """
+
+    return ops.function.array_func.unique_consecutive(input, return_inverse, return_counts, dim)
+
+
 def zeros(size, *, dtype=None):
     """
     Creates a tensor filled with 0 with shape described by `size` and fills it with value 0 in type of `dtype`.
@@ -1581,7 +2067,7 @@ def zeros(size, *, dtype=None):
         Tensor, whose dtype and size are defined by input.
 
     Raises:
-        TypeError: If `size` is neither an int nor an tuple/list/Tensor of int.
+        TypeError: If `size` is neither an int nor a tuple/list/Tensor of int.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -1638,9 +2124,9 @@ def scatter(input, dim, index, src):
 
     Raises:
         TypeError: If `index` is neither int32 nor int64.
-        ValueError: If rank of any of `input` , `index` and `src` less than 1.
+        ValueError: If rank of any of `input` , `index` and `src` is less than 1.
         ValueError: If the rank of `src` is not equal to the rank of `input` .
-        TypeError: If the data type of `input` and `src` have different dtypes.
+        TypeError: If the data types of `input` and `src` have different dtypes.
         RuntimeError: If `index` has negative elements.
 
     Supported Platforms:
@@ -1680,15 +2166,71 @@ def scatter(input, dim, index, src):
     return ops.function.array_func.scatter(input, dim, index, src)
 
 
+def cdist(x1, x2, p=2.0, compute_mode='use_mm_for_euclid_dist_if_necessary'):
+    """
+    Computes p-norm distance between each pair of row vectors of two input Tensors.
+
+    .. warning::
+        This is an experimental optimizer API that is subject to change.
+
+    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`` .
+        compute_mode (string, optional): Specify the cumpute mode. Setting this parameter currently has no effect.
+            Default: ``'use_mm_for_euclid_dist_if_necessary'`` .
+
+    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]]]
+    """
+    return cdist_(x1, x2, p)
+
+
 __all__ = [
     'conv2d',
     'full',
     'ones_like',
     'zeros_like',
     'abs',
+    'clone',
     'erf',
     'where',
     'isclose',
+    'empty',
+    'empty_like',
+    'full_like',
     # 1
     'div',
     'divide',
@@ -1699,6 +2241,7 @@ __all__ = [
     # 3
     'clamp',
     'xlogy',
+    'fmod',
     # 4
     'sinc',
     'sinh',
@@ -1712,10 +2255,14 @@ __all__ = [
     # 8
     'transpose',
     'swapaxes',
+    "batch_norm_elemt",
+    "batch_norm_gather_stats_with_counts",
+    "batch_norm_stats",
     # 9
-
+    'squeeze',
     # 10
     'ne',
+    'not_equal',
     # 11
     'unsqueeze',
     # 12
@@ -1723,7 +2270,7 @@ __all__ = [
     # 13
     "flip",
     # 14
-
+    'mv',
     # 15
     'flatten',
     # 16
@@ -1740,11 +2287,11 @@ __all__ = [
     # 21
     'mul',
     # 22
-
+    'cumprod',
     # 23
-
+    'exp2',
     # 24
-
+    'cdist',
     # 25
     'greater',
     'gt',
@@ -1828,7 +2375,7 @@ __all__ = [
     # 63
     'minimum',
     # 64
-
+    'ravel',
     # 65
     'logical_and',
     # 66
@@ -1872,7 +2419,6 @@ __all__ = [
     # 83
     'narrow',
     # 84
-
     'masked_select',
 
     # 86
@@ -1883,13 +2429,13 @@ __all__ = [
     # 88
     'chunk',
     # 89
-
+    'argsort',
     # 90
-
+    'isinf',
     # 91
 
     # 92
-
+    'polar',
     # 93
 
     # 94
@@ -1925,7 +2471,7 @@ __all__ = [
     # 109
     'argmin',
     # 110
-
+    'softmax',
     # 111
 
     # 112
@@ -1945,11 +2491,14 @@ __all__ = [
     # 119
 
     # 120
-
+    'isneginf',
     # 121
 
     # 122
 
+    # 123
+    'var',
+
     # 151
     'acos',
     'arccos',
@@ -1994,7 +2543,8 @@ __all__ = [
     'erfc',
     # 208
     'eye',
-
+    # 239
+    'lerp',
     # 256
     'median',
     'randperm',
@@ -2022,6 +2572,7 @@ __all__ = [
     'tan',
     # 303
     'trace',
+    'gcd',
     'reshape',
     'outer',
     # 304
@@ -2030,41 +2581,96 @@ __all__ = [
     # 305
     'triu',
 
+    # 308
+    'mm',
+
+    # 382
+    'dstack',
+
+    # 406
+    'allclose',
+
+    # 501
+    'addbmm',
+
+    # 502
+    'addmm',
+
+    # 505
+    'addmv',
+
+    # 510
+    'amax',
+
+    # 511
+    'amin',
+
+    # 520
+    'bincount',
+
+    # 521
+    'bitwise_not',
+
+    # 526
+    'dot',
+
+    # 533
+    'frac',
+
     # 538
     'histc',
 
+    # 552
+    'log10',
+
     # 553
     'logaddexp',
 
+    # 557
+    'logsumexp',
+
+    # 582
+    'std_mean',
+
+    # 588
+    'var_mean',
+
+    # 586
+    'unique_consecutive',
+
     # 610
     'nan_to_num',
 
+    # 613
+    'nansum',
+
+    # 664
+    'meshgrid',
+
     # 695
     'count_nonzero',
-]
 
-setattr(tensor_operator_registry_for_mint, 'add', add)
-setattr(tensor_operator_registry_for_mint, 'all', all)
-setattr(tensor_operator_registry_for_mint, 'any', any)
-setattr(tensor_operator_registry_for_mint, 'log', log)
-setattr(tensor_operator_registry_for_mint, 'ceil', ceil)
-setattr(tensor_operator_registry_for_mint, 'clamp', clamp)
-setattr(tensor_operator_registry_for_mint, 'cos', cos)
-setattr(tensor_operator_registry_for_mint, 'flatten', flatten)
-setattr(tensor_operator_registry_for_mint, 'item', item)
-setattr(tensor_operator_registry_for_mint, 'max', max)
-setattr(tensor_operator_registry_for_mint, 'mean', mean)
-setattr(tensor_operator_registry_for_mint, 'min', min)
-setattr(tensor_operator_registry_for_mint,
-        'repeat_interleave', repeat_interleave)
-setattr(tensor_operator_registry_for_mint, 'ne', ne)
-setattr(tensor_operator_registry_for_mint, 'round', round)
-setattr(tensor_operator_registry_for_mint, 'sin', sin)
-setattr(tensor_operator_registry_for_mint, 'split', split)
-setattr(tensor_operator_registry_for_mint, 'sqrt', sqrt)
-setattr(tensor_operator_registry_for_mint, 'square', square)
-setattr(tensor_operator_registry_for_mint, 'sub', sub)
-setattr(tensor_operator_registry_for_mint, 'sum', sum)
+    # 697
+    'float_power',
+
+    # 708
+    'std',
+
+    # 887
+    'log2',
+
+    # 889
+    'isnan',
+
+    # 1007
+    't',
+
+    # 1023
+    'unbind',
+
+    # 1100
+    'diff',
+]
 
 __all__.extend(functional.__all__)
 __all__.extend(nn.__all__)