mindspore 2.3.0__cp39-cp39-win_amd64.whl → 2.4.1__cp39-cp39-win_amd64.whl

mindspore/mint/__init__.py

@@ -15,45 +15,57 @@
 """mint module."""
 from __future__ import absolute_import
 import mindspore.ops as ops
-from mindspore.ops.extend import gather, conv2d, max, min
-from mindspore.ops.extend import array_func, math_func, nn_func
-from mindspore.mint.nn.functional import *
+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.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.ops import erf, where, triu
+from mindspore.mint import special
+from mindspore.mint import distributed
+from mindspore.ops import erf, where
 from mindspore.ops.function.math_func import linspace_ext as linspace
-from mindspore.ops.function.array_func import full_ext as full
+from mindspore.ops.function.math_func import median_ext as median
 from mindspore.ops.function.array_func import ones_like_ext as ones_like
+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.function.math_func import isclose
 from mindspore.ops.auto_generate import abs
 # 1
 from mindspore.ops.function.math_func import divide, div
 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
 # 4
-
+from mindspore.ops.auto_generate import sinc
+from mindspore.ops.auto_generate import sinh
+from mindspore.ops.auto_generate import cosh
+from mindspore.ops.function.math_func import xlogy_ext as xlogy
 # 5
 from mindspore.ops.auto_generate import cumsum_ext as cumsum
 # 6
 from mindspore.ops.auto_generate import stack_ext as stack
 
 # 7
-
+from mindspore.ops.function.array_func import unsqueeze
 # 8
-
+from mindspore.ops.auto_generate import transpose_ext as transpose
 # 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
 
 # 12
-
+from mindspore.ops.function.array_func import repeat_interleave_ext as repeat_interleave
 # 13
 from mindspore.ops.functional import flip
 # 14
@@ -122,13 +134,13 @@ from mindspore.ops.functional import cos
 # 45
 
 # 46
-
+from mindspore.ops.function.math_func import bitwise_and_ext as bitwise_and
 # 47
-
+from mindspore.ops.function.math_func import bitwise_or_ext as bitwise_or
 # 48
-
+from mindspore.ops.function.math_func import bitwise_xor_ext as bitwise_xor
 # 49
-
+from mindspore.ops.function.math_func import baddbmm_ext as baddbmm
 # 50
 from mindspore.ops.functional import tile
 # 51
@@ -142,7 +154,7 @@ from mindspore.ops.function.random_func import normal_ext as normal
 # 55
 
 # 56
-
+from mindspore.ops.function.math_func import norm_ext as norm
 # 57
 from mindspore.ops.functional import broadcast_to
 # 58
@@ -166,7 +178,7 @@ from mindspore.ops.functional import logical_not
 # 67
 from mindspore.ops.functional import logical_or
 # 68
-
+from mindspore.ops.functional import logical_xor
 # 69
 from mindspore.ops.functional import less_equal, le
 # 70
@@ -194,7 +206,7 @@ from mindspore.ops.function import arange_ext as arange
 # 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
 # 84
@@ -204,9 +216,9 @@ from mindspore.mint import nn, optim
 # 86
 
 # 87
-
+from mindspore.ops.auto_generate import trunc
 # 88
-from mindspore.ops.function.array_func import chunk_ext as chunk
+
 # 89
 
 # 90
@@ -231,24 +243,135 @@ from mindspore.ops.function.math_func import tanh
 
 # 100
 
+# 101
+
+# 102
+
+# 103
+
+# 104
+
+# 105
+
+# 106
+
+# 107
+
+# 108
+
+# 109
+from mindspore.ops.auto_generate import argmin_ext as argmin
+# 110
+
+# 111
+
+# 112
+
+# 113
+
+# 114
+
+# 115
+
+# 116
+
+# 117
+
+# 118
+
+# 119
+
+# 120
+
+# 121
+
 # 122
 
+# 151
+from mindspore.ops.function.math_func import acos_ext as acos
+from mindspore.ops.function.math_func import arccos_ext as arccos
+# 152
+from mindspore.ops.function.math_func import acosh_ext as acosh
+from mindspore.ops.function.math_func import arccosh_ext as arccosh
+# 172
+from mindspore.ops.function.math_func import asin_ext as asin
+from mindspore.ops.function.math_func import arcsin_ext as arcsin
+# 173
+from mindspore.ops.function.math_func import asinh_ext as asinh
+from mindspore.ops.function.math_func import arcsinh_ext as arcsinh
+# 174
+from mindspore.ops.function.math_func import atan_ext as atan
+from mindspore.ops.function.math_func import arctan_ext as arctan
+# 175
+from mindspore.ops.function.math_func import atanh
+from mindspore.ops.function.math_func import arctanh
 # 176
 from mindspore.ops.function.math_func import atan2_ext as atan2
 from mindspore.ops.function.math_func import arctan2_ext as arctan2
 
+# 177
+from mindspore.ops.function.math_func import round
 
+# 182
+from mindspore.ops.function.math_func import bernoulli_ext as bernoulli
+
+# 204
+from mindspore.ops.auto_generate import erfc
+# 207
+from mindspore.ops.auto_generate import expm1
 # 208
 from mindspore.ops.function.array_func import eye
+from mindspore.ops.function.random_func import randperm_ext as randperm
 from mindspore.ops.function.random_func import rand_ext as rand
 from mindspore.ops.function.random_func import rand_like_ext as rand_like
+from mindspore.ops.function.random_func import randn_ext as randn
+from mindspore.ops.function.random_func import randn_like_ext as randn_like
+from mindspore.ops.function.random_func import randint_ext as randint
+from mindspore.ops.function.random_func import randint_like_ext as randint_like
 # 210
 from mindspore.ops.auto_generate import floor
 # 231
 from mindspore.ops.function.math_func import inverse_ext as inverse
-
+# 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
 # 285
 from mindspore.ops.function.array_func import scatter_add_ext as scatter_add
+# 289
+from mindspore.ops.auto_generate import sign
+
+from mindspore.ops.auto_generate import select_ext as select
+
+# 301
+from mindspore.ops.function.math_func import tan
+
+# 303
+from mindspore.ops.auto_generate import trace_ext as trace
+
+from mindspore.ops.function.array_func import reshape
+
+from mindspore.ops.auto_generate import outer_ext as outer
+
+# 304
+from mindspore.ops.function.array_func import tril_ext as tril
+
+# 305
+from mindspore.ops import triu
+
+# 538
+from mindspore.ops.function.math_func import histc_ext as histc
+
+# 553
+from mindspore.ops.auto_generate import logaddexp_ext as logaddexp
+
+# 610
+from mindspore.ops.function.math_func import nan_to_num
+
+# 695
+from mindspore.ops.auto_generate import count_nonzero
 
 
 def add(input, other, *, alpha=1):
@@ -268,12 +391,12 @@ def add(input, other, *, alpha=1):
     Args:
         input (Union[Tensor, number.Number, bool]): The first input is a number.Number or
             a bool or a tensor whose data type is
-            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         other (Union[Tensor, number.Number, bool]): The second input, is a number.Number or
             a bool or a tensor whose data type is
-            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
+            `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.
@@ -429,7 +552,6 @@ def all(input, dim=None, keepdim=False):
     return ops.function.math_func.all(input, dim, keepdim)
 
 
-
 def cat(tensors, dim=0):
     r"""
     Connect input tensors along with the given dimension.
@@ -487,6 +609,573 @@ def cat(tensors, dim=0):
     return ops.auto_generate.cat(tensors, dim)
 
 
+def concat(tensors, dim=0):
+    r"""
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Alias of mint.cat().
+    """
+    return cat(tensors, dim)
+
+
+def cummax(input, dim):
+    r"""
+    Returns a tuple (values, indices) where `values` is the cumulative maximum value of input Tensor `input`
+    along the dimension `dim`, and `indices` is the index location of each maximum value.
+
+    .. math::
+        \begin{array}{ll} \\
+            y_{i} = \max(x_{1}, x_{2}, ... , x_{i})
+        \end{array}
+
+    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
+            `[-input.ndim, input.ndim - 1]`.
+
+    Returns:
+        tuple [Tensor], tuple of 2 Tensors, containing the cumulative maximum of elements and the index.
+        The shape of each output tensor is the same as that of input `input`.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        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``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor
+        >>> from mindspore import ops
+        >>> x = Tensor(np.array([[3, 4, 6, 10], [1, 6, 7, 9], [4, 3, 8, 7], [1, 3, 7, 9]]).astype(np.float32))
+        >>> output = mint.cummax(x, dim=0)
+        >>> print(output[0])
+        [[ 3.  4.  6. 10.]
+         [ 3.  6.  7. 10.]
+         [ 4.  6.  8. 10.]
+         [ 4.  6.  8. 10.]]
+        >>> print(output[1])
+        [[0 0 0 0]
+         [0 1 1 0]
+         [2 1 2 0]
+         [2 1 2 0]]
+    """
+    return ops.auto_generate.cummax(input, dim)
+
+
+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):
+    """Convert the sublist to an equation operand if the received input is a sublist format."""
+    if isinstance(equation, Tensor):
+        equation_tmp = ''
+        for i, lst in enumerate(operands):
+            if i % 2 == 0:
+                for _, num in enumerate(lst):
+                    equation_tmp += _einsum_convert_sublist_to_label(num)
+                if i in (len(operands) - 1, len(operands) - 2):
+                    continue
+                equation_tmp += ','
+        if len(operands) % 2 == 0:
+            equation_tmp += '->'
+            for _, num in enumerate(operands[-1]):
+                equation_tmp += _einsum_convert_sublist_to_label(num)
+            operands_tmp = list([equation]) + list(operands[1:-1:2])
+        else:
+            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.")
+    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
+    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', "
+                         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:
+            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.")
+            labels_count[label] += 1
+            start_dim = end_dim
+        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
+
+
+def _einsum_infer_output(r_equationlst, arrow_exist, labels2dimlst, labels_count):
+    """Parse right script of equation and infer output shape."""
+    idx = 0
+    idle_idx = -1
+    output_shape = []
+    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.")
+                labels_perm_idx[label] = idx
+                idx += len(labels2dimlst[label])
+            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]
+            labels_perm_idx[52] = idx
+            idx += len(labels2dimlst[52])
+        for label, count in enumerate(labels_count):
+            if count == 1:
+                output_shape += labels2dimlst[label]
+                labels_perm_idx[label] = idx
+                idx += len(labels2dimlst[label])
+
+    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
+
+
+def _einsum_adjust_operands(operands, l_equationlst, labels2dimlst, 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(len(labels2dimlst[label])):
+                        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 = 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 for _ in range(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 = sum(l_tensor, i, True)
+            elif sum_r:
+                r_tensor = sum(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 pipline 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 = reshape(l_tensor, l_reshape_shape)
+
+    r_tensor = permute(r_tensor, tuple(r_perm_axis))
+    r_tensor = reshape(r_tensor, r_reshape_shape)
+
+    output = bmm(l_tensor, r_tensor)
+    output = 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 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)
+    _result = _adjust_operands[0]
+
+    # Fast path if operands has zero dim.
+    if _has_zero_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)
+            else:
+                _result = sum(_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 = _einsum_squeeze(operand, dim)
+            elif _dim_last_op[j] == i:
+                if _result.shape[dim] == 1:
+                    operand = sum(operand, dim)
+                    _result = _einsum_squeeze(_result, dim)
+                else:
+                    sum_dims.append(dim)
+                    dim += 1
+            else:
+                dim += 1
+
+        if sum_dims == []:
+            _result = mul(_result, operand)
+        elif len(sum_dims) == len(_result.shape):
+            _result = ops.auto_generate.dot(flatten(_result), flatten(operand))
+        else:
+            _result = _einsum_multiplication(sum_dims, _result, operand)
+
+    return _result
+
+
+def einsum(equation, *operands):
+    r"""
+    According to the Einstein summation Convention (Einsum),
+    the product of the input tensor elements is summed along the specified dimension.
+    You can use this operator to perform diagonal, reducesum, transpose, matmul, mul, inner product operations, etc.
+
+    Note:
+        The sublist format is also supported. For example, 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.
+
+    .. 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.
+        operands (Tensor): Input tensor used for calculation. The dtype of the tensor must be the same.
+
+    Returns:
+        Tensor, the shape of it can be obtained from the `equation` , and the dtype is the same as input tensors.
+
+    Raises:
+        TypeError: If `equation` is invalid, or the `equation` does not match the input tensor.
+        ValueError: If the number in sublist is not in [0, 52) in sublist format.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, mint
+        >>> x = Tensor(np.array([1.0, 2.0, 4.0]), mindspore.float32)
+        >>> equation = "i->"
+        >>> output = mint.einsum(equation, x)
+        >>> print(output)
+        [7.]
+        >>> x = Tensor(np.array([1.0, 2.0, 4.0]), mindspore.float32)
+        >>> y = Tensor(np.array([2.0, 4.0, 3.0]), mindspore.float32)
+        >>> equation = "i,i->i"
+        >>> output = mint.einsum(equation, x, y)
+        >>> print(output)
+        [ 2. 8. 12.]
+        >>> x = Tensor(np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]), mindspore.float32)
+        >>> y = Tensor(np.array([[2.0, 3.0], [1.0, 2.0], [4.0, 5.0]]), mindspore.float32)
+        >>> equation = "ij,jk->ik"
+        >>> output = mint.einsum(equation, x, y)
+        >>> print(output)
+        [[16. 22.]
+         [37. 52.]]
+        >>> x = Tensor(np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]), mindspore.float32)
+        >>> equation = "ij->ji"
+        >>> output = mint.einsum(equation, x)
+        >>> print(output)
+        [[1. 4.]
+         [2. 5.]
+         [3. 6.]]
+        >>> x = Tensor(np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]), mindspore.float32)
+        >>> equation = "ij->j"
+        >>> output = mint.einsum(equation, x)
+        >>> print(output)
+        [5. 7. 9.]
+        >>> x = Tensor(np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]]), mindspore.float32)
+        >>> equation = "...->"
+        >>> output = mint.einsum(equation, x)
+        >>> print(output)
+        [21.]
+        >>> x = Tensor(np.array([1.0, 2.0, 3.0]), mindspore.float32)
+        >>> y = Tensor(np.array([2.0, 4.0, 1.0]), mindspore.float32)
+        >>> equation = "j,i->ji"
+        >>> output = mint.einsum(equation, x, y)
+        >>> print(output)
+        [[ 2. 4. 1.]
+         [ 4. 8. 2.]
+         [ 6. 12. 3.]]
+        >>> x = mindspore.Tensor([1, 2, 3, 4], mindspore.float32)
+        >>> y = mindspore.Tensor([1, 2], mindspore.float32)
+        >>> output = mint.einsum(x, [..., 1], y, [..., 2], [..., 1, 2])
+        >>> print(output)
+        [[1. 2.]
+         [2. 4.]
+         [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.")
+
+    return _einsum(_equation, _operands)
+
+
+def item(input):
+    r"""
+    Returns the value of this tensor as a standard Python number.
+
+    Note:
+        This only works for tensors with one element.
+
+    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.
+
+    Returns:
+        number.
+
+    Raises:
+        TypeError: If `input` is not a Tensor.
+        RuntimeError: If the number of `input` elements is not 1.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> import numpy as np
+        >>> from mindspore import Tensor, mint
+        >>> x = Tensor(np.array([1]).astype(np.float32))
+        >>> result = mint.item(x)
+        >>> print(result)
+        1.0
+    """
+    if not isinstance(input, Tensor):
+        raise TypeError(f"the input must be a Tensor, but got {type(input)}")
+    if input.size != 1:
+        raise RuntimeError(
+            "a Tensor with {} elements cannot be converted to Scalar".format(input.size))
+    return input.asnumpy().item()
+
+
 def mean(input, dim=None, keepdim=False, *, dtype=None):
     r"""
     Reduces all dimension of a tensor by averaging all elements in the dimension, by default.
@@ -818,12 +1507,12 @@ def sub(input, other, *, alpha=1):
     Args:
         input (Union[Tensor, number.Number, bool]): The first input is a number.Number or
             a bool or a tensor whose data type is
-            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
+            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
         other (Union[Tensor, number.Number, bool]): The second input, is a number.Number or
             a bool or a tensor whose data type is
-            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_ or
-            `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore.html#mindspore.dtype>`_.
+            `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
+            `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.
@@ -859,6 +1548,22 @@ def sub(input, other, *, alpha=1):
     return ops.auto_generate.sub_ext(input, other, alpha)
 
 
+def swapaxes(input, axis0, axis1):
+    '''
+    Interchange two axes of a tensor, alias for mint.transpose()
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import mint
+        >>> from mindspore import Tensor
+        >>> input = Tensor(np.ones((2,3,4), dtype=np.float32))
+        >>> output = mint.swapaxes(input, 0, 2)
+        >>> print(output.shape)
+        (4, 3, 2)
+    '''
+    return transpose(input, axis0, axis1)
+
+
 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`.
@@ -892,25 +1597,112 @@ def zeros(size, *, dtype=None):
     return ops.auto_generate.zeros(size, dtype)
 
 
+def fix(input):
+    """
+    Alias for :func:`mindspore.mint.trunc` .
+
+    For more details, see :func:`mindspore.mint.trunc` .
+
+    Supported Platforms:
+        ``Ascend``
+    """
+    return trunc(input)
+
+
+def scatter(input, dim, index, src):
+    """
+    Update the value in `src` to `input` according to the specified index.
+    For a 3-D tensor, the output will be:
+
+    .. code-block::
+
+        output[index[i][j][k]][j][k] = src[i][j][k]  # if dim == 0
+
+        output[i][index[i][j][k]][k] = src[i][j][k]  # if dim == 1
+
+        output[i][j][index[i][j][k]] = src[i][j][k]  # if dim == 2
+
+    .. note::
+        The backward is supported only for the case `src.shape == index.shape` when `src` is a tensor.
+
+    Args:
+        input (Tensor): The target tensor. The rank of `input` must be at least 1.
+        dim (int): Which axis to scatter. Accepted range is [-r, r) where r = rank(input).
+        index (Tensor): The index to do update operation whose data must be positive number with type of mindspore.int32
+            or mindspore.int64. Same rank as `input` . And accepted range is [-s, s) where s is the size along axis.
+        src (Tensor, float): The data doing the update operation with `input`. Can be a tensor with the same data type
+            as `input` or a float number to scatter.
+
+    Returns:
+        Tensor, has the same shape and type as `input` .
+
+    Raises:
+        TypeError: If `index` is neither int32 nor int64.
+        ValueError: If rank of any of `input` , `index` and `src` 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.
+        RuntimeError: If `index` has negative elements.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> import mindspore as ms
+        >>> from mindspore import Tensor, mint
+        >>> input = Tensor(np.array([[1, 2, 3, 4, 5]]), dtype=ms.float32)
+        >>> src = Tensor(np.array([[8, 8]]), dtype=ms.float32)
+        >>> index = Tensor(np.array([[2, 4]]), dtype=ms.int64)
+        >>> out = mint.scatter(input=input, dim=1, index=index, src=src)
+        >>> print(out)
+        [[1. 2. 8. 4. 8.]]
+        >>> input = Tensor(np.zeros((5, 5)), dtype=ms.float32)
+        >>> src = Tensor(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), dtype=ms.float32)
+        >>> index = Tensor(np.array([[0, 0, 0], [2, 2, 2], [4, 4, 4]]), dtype=ms.int64)
+        >>> out = mint.scatter(input=input, dim=0, index=index, src=src)
+        >>> print(out)
+        [[1. 2. 3. 0. 0.]
+        [0. 0. 0. 0. 0.]
+        [4. 5. 6. 0. 0.]
+        [0. 0. 0. 0. 0.]
+        [7. 8. 9. 0. 0.]]
+        >>> input = Tensor(np.zeros((5, 5)), dtype=ms.float32)
+        >>> src = Tensor(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), dtype=ms.float32)
+        >>> index = Tensor(np.array([[0, 2, 4], [0, 2, 4], [0, 2, 4]]), dtype=ms.int64)
+        >>> out = mint.scatter(input=input, dim=1, index=index, src=src)
+        >>> print(out)
+        [[1. 0. 2. 0. 3.]
+        [4. 0. 5. 0. 6.]
+        [7. 0. 8. 0. 9.]
+        [0. 0. 0. 0. 0.]
+        [0. 0. 0. 0. 0.]]
+    """
+    return ops.function.array_func.scatter(input, dim, index, src)
+
+
 __all__ = [
+    'conv2d',
     'full',
     'ones_like',
     'zeros_like',
     'abs',
     'erf',
     'where',
-    'linspace',
     'isclose',
     # 1
     'div',
     'divide',
     'topk',
+    'roll',
     # 2
     'sin',
     # 3
     'clamp',
+    'xlogy',
     # 4
-
+    'sinc',
+    'sinh',
+    'cosh',
     # 5
     'cumsum',
     # 6
@@ -918,15 +1710,16 @@ __all__ = [
     # 7
     'zeros',
     # 8
-
+    'transpose',
+    'swapaxes',
     # 9
 
     # 10
     'ne',
     # 11
-
+    'unsqueeze',
     # 12
-
+    "repeat_interleave",
     # 13
     "flip",
     # 14
@@ -966,8 +1759,9 @@ __all__ = [
     # 30
     'searchsorted',
     # 31
-
-    # 32
+    'cummax',
+    'cummin',
+    'einsum',
     'sub',
     # 33
     'split',
@@ -994,15 +1788,17 @@ __all__ = [
     # 44
     'cos',
     # 45
-
+    'concat',
     # 46
-
+    'bitwise_and',
+    'bitwise_or',
+    'bitwise_xor',
     # 47
     'max',
     # 48
     'min',
     # 49
-
+    'baddbmm',
     # 50
     'tile',
     # 51
@@ -1014,9 +1810,9 @@ __all__ = [
     # 54
     'normal',
     # 55
-
+    'cross',
     # 56
-
+    'norm',
     # 57
     'broadcast_to',
     # 58
@@ -1040,7 +1836,7 @@ __all__ = [
     # 67
     'logical_or',
     # 68
-
+    'logical_xor',
     # 69
     'less_equal',
     'le',
@@ -1077,9 +1873,10 @@ __all__ = [
     'narrow',
     # 84
 
-    # 85
+    'masked_select',
 
     # 86
+    'select',
 
     # 87
 
@@ -1109,29 +1906,169 @@ __all__ = [
 
     # 100
 
+    # 101
+
+    # 102
+
+    # 103
+
+    # 104
+
+    # 105
+
+    # 106
+
+    # 107
+
+    # 108
+
+    # 109
+    'argmin',
+    # 110
+
+    # 111
+
+    # 112
+
+    # 113
+
+    # 114
+
+    # 115
+
+    # 116
+
+    # 117
+
+    # 118
+
+    # 119
+
+    # 120
+
+    # 121
+
+    # 122
+
+    # 151
+    'acos',
+    'arccos',
+    # 152
+    'acosh',
+    'arccosh',
+    # 153
+
+    # 154
+
+    # 155
+
+    # 156
+
+    # 157
+    'scatter',
+    # 172
+    'asin',
+    'arcsin',
+    # 173
+    'asinh',
+    'arcsinh',
+    # 174
+    'atan',
+    'arctan',
+    # 175
+    'atanh',
+    'arctanh',
     # 176
     'atan2',
     'arctan2',
 
+    # 177
+    'round',
+
+    # 182
+    'bernoulli',
+
+    # 207
+    'expm1',
+    # 204
+    'erfc',
     # 208
     'eye',
+
+    # 256
+    'median',
+    'randperm',
     'rand',
     'rand_like',
+    'randn',
+    'randn_like',
+    'randint',
+    'randint_like',
     # 210
     'floor',
     # 231
     'inverse',
+    # 244
+    'log1p',
+    # 261
+    'multinomial',
+    # 275
+    'remainder',
     # 285
     'scatter_add',
+    # 289
+    'sign',
+    # 301
+    'tan',
+    # 303
+    'trace',
+    'reshape',
+    'outer',
     # 304
+    'tril',
 
     # 305
     'triu',
+
+    # 538
+    'histc',
+
+    # 553
+    'logaddexp',
+
+    # 610
+    'nan_to_num',
+
+    # 695
+    'count_nonzero',
 ]
-__all__.extend(array_func.__all__)
-__all__.extend(math_func.__all__)
-__all__.extend(nn_func.__all__)
+
+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)
+
 __all__.extend(functional.__all__)
 __all__.extend(nn.__all__)
 __all__.extend(optim.__all__)
 __all__.extend(linalg.__all__)
+__all__.extend(special.__all__)
+__all__.extend(distributed.__all__)