mindspore 2.0.0a0__cp38-cp38-win_amd64.whl → 2.0.0rc1__cp38-cp38-win_amd64.whl

mindspore/common/tensor.py

@@ -16,21 +16,24 @@
 
 __all__ = ['Tensor']
 
+import abc
 import math
 import numbers
 import numpy as np
 
-from mindspore.communication.management import get_rank, get_group_size
+from mindspore.communication.management import get_group_size
 from mindspore.common._utils import is_shape_unknown
 from mindspore.common.seed import get_seed
 from mindspore import context
 from mindspore import log as logger
 from mindspore.common import dtype as mstype
-from mindspore.common._utils import split_to_slice_if_need
+
+from mindspore.common._utils import get_slice_num
 from mindspore.common._register_for_tensor import tensor_operator_registry
 from mindspore._c_expression import Tensor as Tensor_
-from mindspore._checkparam import Rel, check_is_number
-from mindspore._checkparam import Validator as validator
+from mindspore import _checkparam as validator
+from mindspore._checkparam import check_is_number, is_stub_tensor
+from mindspore._check_jit_forbidden_api import jit_forbidden_register
 
 np_types = (np.int8, np.int16, np.int32, np.int64,
             np.uint8, np.uint16, np.uint32, np.uint64, np.float16,
@@ -40,14 +43,14 @@ np_types = (np.int8, np.int16, np.int32, np.int64,
 def _check_input_data_type(input_data):
     """Check the type of input_data for Tensor"""
     validator.check_value_type('input_data', input_data,
-                               (Tensor_, np.ndarray, np.str_, list, tuple, float, int, bool, complex),
+                               (Tensor_, Tensor, np.ndarray, np.str_, list, tuple, float, int, bool, complex),
                                'Tensor')
     valid_dtypes = (np.int8, np.int16, np.int32, np.int64, np.uint8, np.uint16, np.uint32, np.uint64,
                     np.float16, np.float32, np.float64, np.bool_, np.str_, np.complex64, np.complex128)
     if isinstance(input_data, np.ndarray) and input_data.dtype not in valid_dtypes and \
             input_data.dtype.kind != 'U' and input_data.dtype.kind != 'S':  # Support dtype np.str_
+        new_line = '\n'
         for index, x in np.ndenumerate(input_data):
-            new_line = '\n'
             if np.array(x).dtype not in valid_dtypes:
                 raise TypeError(f"initializing tensor by numpy array failed, because the "
                                 f"element type '{type(x)}' of array is not supported.\n"
@@ -65,7 +68,13 @@ def _check_input_data_type(input_data):
             f"For Tensor, the input_data is {input_data} that contain unsupported element.")
 
 
-class Tensor(Tensor_):
+class _TensorMeta(type(Tensor_), abc.ABCMeta):
+    """
+    Meta class for Tensor. Used internally.
+    """
+
+
+class Tensor(Tensor_, metaclass=_TensorMeta):
     """
     Tensor is a data structure that stores an n-dimensional array.
 
@@ -95,6 +104,10 @@ class Tensor(Tensor_):
     Outputs:
         Tensor.
 
+    Note:
+        The default value None of `input_data` works as a placeholder, it does not mean that we can create a NoneType
+        Tensor.
+
     Examples:
         >>> import numpy as np
         >>> import mindspore as ms
@@ -149,8 +162,12 @@ class Tensor(Tensor_):
 
     def __init__(self, input_data=None, dtype=None, shape=None, init=None, internal=False, const_arg=False):
         self.init_finished = False
+        if is_stub_tensor(input_data):
+            input_data = input_data.stub_sync()
+
         if internal:
-            Tensor_.__init__(self, input_data)
+            if input_data is not None:
+                Tensor_.__init__(self, input_data)
         else:
             # If input data is numpy number, convert it to np array
             if isinstance(input_data, np_types):
@@ -168,8 +185,8 @@ class Tensor(Tensor_):
             else:
                 _check_input_data_type(input_data)
                 if dtype is not None:
-                    validator.check_type_name(
-                        'dtype', dtype, mstype.number_type + (mstype.bool_, mstype.string), "Tensor")
+                    validator.check_type_name('dtype', dtype, mstype.number_type +
+                                              (mstype.bool_, mstype.string), "Tensor")
                 else:
                     dtype = self._set_default_dtype(input_data, dtype)
 
@@ -180,8 +197,8 @@ class Tensor(Tensor_):
                     Tensor_.__init__(self, input_data, dtype)
                 else:
                     Tensor_.__init__(self, input_data)
+                validator.check_value_type('const_arg', const_arg, bool, 'Tensor')
 
-        validator.check_value_type('const_arg', const_arg, bool, 'Tensor')
         self.const_arg = const_arg
         self.virtual_flag = False
         self.init = init
@@ -196,6 +213,16 @@ class Tensor(Tensor_):
         self.slice_num_of_persistent_data_ = None
         self.slice_shape_of_persistent_data_ = None
 
+    @classmethod
+    def __subclasshook__(cls, sub):
+        """
+        Subclass with stub_sync attr will be instance of Tensor
+        """
+        if cls is Tensor:
+            if any("stub_sync" in s.__dict__ for s in sub.__mro__):
+                return True
+        return NotImplemented
+
     @staticmethod
     def _set_default_dtype(input_data, dtype):
         """Set tensor default dtype"""
@@ -301,22 +328,16 @@ class Tensor(Tensor_):
         return tensor_operator_registry.get('__add__')(self, other)
 
     def __and__(self, other):
-        if Tensor._use_logical_kernel(self, other):
-            return tensor_operator_registry.get('logical_and')(self, other)
         if isinstance(other, (int, bool, float, Tensor)):
             return tensor_operator_registry.get('bitwise_and')(self, other)
         raise TypeError("Unsupported operand type(s) for &: 'Tensor' and '{}'".format(type(other)))
 
     def __xor__(self, other):
-        if Tensor._use_logical_kernel(self, other):
-            return tensor_operator_registry.get('logical_xor')(self, other)
         if isinstance(other, (int, bool, float, Tensor)):
             return tensor_operator_registry.get('bitwise_xor')(self, other)
         raise TypeError("Unsupported operand type(s) for ^: 'Tensor' and '{}'".format(type(other)))
 
     def __or__(self, other):
-        if Tensor._use_logical_kernel(self, other):
-            return tensor_operator_registry.get('logical_or')(self, other)
         if isinstance(other, (int, bool, float, Tensor)):
             return tensor_operator_registry.get('bitwise_or')(self, other)
         raise TypeError("Unsupported operand type(s) for |: 'Tensor' and '{}'".format(type(other)))
@@ -449,6 +470,20 @@ class Tensor(Tensor_):
         """Return the number of tensor dimensions."""
         return len(self._shape)
 
+    @property
+    def H(self):
+        """
+        Returns a view of a matrix (2-D tensor) conjugated and transposed.
+        x.H is equivalent to `mindspore.Tensor.swapaxes(0, 1).conj()` for complex matrices and
+        `mindspore.Tensor.swapaxes(0, 1)` for real matrices.
+        """
+        if self.ndim != 2:
+            raise ValueError(f"For tensor.H only support 2-D Tensor, but got {self.ndim}-D.")
+        output = self.swapaxes(0, 1)
+        if self.dtype in (mstype.complex64, mstype.complex128):
+            return output.conj()
+        return output
+
     @property
     def has_init(self):
         """Whether tensor is initialized."""
@@ -500,168 +535,13 @@ class Tensor(Tensor_):
 
         return Tensor(Tensor_.from_numpy(array))
 
-    @staticmethod
-    def frombuffer(buffer, dtype=mstype.float64, count=-1, offset=0):
-        r"""
-        Creates a 1-dimensional :class:`Tensor` from an object that implements
-        the Python buffer protocol.
-        Skips the first :attr:`offset` bytes in the buffer, and interprets the rest of
-        the raw bytes as a 1-dimensional tensor of type :attr:`dtype` with :attr:`count`
-        elements.
-
-        Args:
-            buffer (object): a Python object that exposes the buffer interface.
-            dtype (mindspore.dtype): the desired data type of returned tensor.
-            count (int, optional): the number of desired elements to be read. If negative,
-                                    all the elements (until the end of the buffer) will be read. Default: -1.
-            offset (int, optional): the number of bytes to skip at the start of the buffer. Default: 0.
-
-        Returns:
-            a 1-dimensional Tensor from an object that implements the Python buffer protocol.
-
-        Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
-
-        Examples:
-            >>> from array import array
-            >>> import numpy as np
-            >>> import mindspore
-            >>> from mindspore import Tensor
-            >>> input_array = array("d", [1, 2, 3, 4])
-            >>> input_array
-            array('d', [1.0, 2.0, 3.0, 4.0])
-            >>> output = Tensor.frombuffer(input_array, mindspore.int32)
-            >>> print(output)
-            [1 2 3 4]
-        """
-        res = np.frombuffer(buffer=buffer, dtype=np.float64, count=count, offset=offset)
-        result = Tensor(res, dtype=dtype)
-        return result
-
-    @staticmethod
-    def empty_strided(size, stride, dtype=mstype.float64, seed=None):
-        r"""
-        Creates a tensor with the specified :attr:`size` and :attr:`stride` and filled with undefined data.
-
-        Args:
-            size (tuple of python:ints): the shape of the output tensor.
-            stride (tuple of python:ints): the strides of the output tensor.
-            dtype (mindspore.dtype, optional): the desired data type of returned tensor.
-
-        Returns:
-            a tensor with the specified size and stride and filled with undefined data.
-
-        Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
-
-        Examples:
-            >>> from mindspore import Tensor
-            >>> size = (3, 3)
-            >>> stride = (1, 3)
-            >>> output = Tensor.empty_strided(size, stride, seed = 0)
-            >>> print(output)
-            [[0.00000000e+00 7.15189366e+10 0.00000000e+00]
-             [0.00000000e+00 0.00000000e+00 6.45894113e+10]
-             [0.00000000e+00 8.91773001e+10 9.63662761e+10]]
-        """
-        np.random.seed(seed)
-        tensor_ = Tensor(np.random.uniform(low=0, high=10e10, size=size))
-        tensor_array = tensor_.asnumpy()
-        stride_tensor = tensor_.as_strided(shape=size, strides=stride)
-        stride_array = stride_tensor.asnumpy()
-        stride_array.resize(len(stride_array) * len(stride_array[0]))
-        for i in range(size[0]):
-            for j in range(size[1]):
-                if not sum(stride_array - tensor_array[i][j]) < 0.01:
-                    tensor_array[i][j] = 0.0
-        return Tensor(tensor_array, dtype=dtype)
-
-    @staticmethod
-    def poisson(shape, mean, seed=0, seed2=0):
-        r"""
-        Returns a tensor of the same size as `input` with each element sampled from a Poisson
-        distribution with rate parameter given by the corresponding element in `input` i.e.,
-        \text{out}_i \sim \text{Poisson}(\text{input}_i)out*i*∼Poisson(input*i*),
-        and self as a tensor is the μ parameter .the distribution was constructed with.
-        The parameter defines mean number of occurrences of the event.
-        It must be greater than 0. With float32 data type.
-
-        Args:
-            seed (int, option): set the random seed (0 to 2**32)
-            seed2 (int, option): set the random seed2 (0 to 2**32)
-
-        Inputs:
-            - **shape** (tuple) - The shape of random tensor to be generated. Only constant value is allowed.
-
-        Returns:
-            out (Union[Tensor, int]), with the same shape as input_tensor.
-
-        Raises:
-            TypeError: If neither `seed` nor `seed2` is an int.
-            TypeError: If `shape` is not a tuple.
-            TypeError: If `mean` is not a Tensor whose dtype is not float32.
-
-        Supported Platforms:
-            ``Ascend``
-
-        Examples:
-            >>> shape = (4, 1)
-            >>> mean = Tensor(np.array([5.0, 10.0]), mstype.float32)
-            >>> output = Tensor.Poisson(shape, mean, seed=5)
-            >>> result = output.shape
-            >>> print(result)
-            (4, 2)
-        """
-        return tensor_operator_registry.get('poisson')(seed, seed2)(shape, mean)
-
-    @staticmethod
-    def as_tensor(data, dtype=None):
-        r"""
-        convert data to tensor in mindspore.
-
-        Args:
-            data (array_like): Initial data for the tensor. Can be a list, tuple,
-                            NumPy ndarray, scalar, and other types.
-            dtype (mindspore.dtype, optional): the desired data type of returned tensor.
-                                        Default: if None, infers data type from data.
-
-        Returns:
-            Tensor contains the data and the dtype is in mindspore.
-
-        Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
-
-        Examples:
-            >>> import numpy as np
-            >>> import mindspore as ms
-            >>> import mindspore.nn as nn
-            >>> from mindspore import Tensor
-            >>> input_data = np.array([1, 2, 3])
-            >>> ms_tensor = Tensor.as_tensor(input_data)
-            >>> ms_tensor
-            Tensor(shape=[3], dtype=Int64, value= [1, 2, 3])
-        """
-        return Tensor(data, dtype=dtype)
-
-    @staticmethod
-    def _use_logical_kernel(me, other) -> bool:
-        """
-        Decide to use logical kernel or bitwise kernel for &|^ operations.
-        If self or other is bool or bool tensor, then return true, use logical kernel,
-        else false to use bitwise kernel.
-        """
-        def _is_bool_or_bool_tensor(data):
-            return isinstance(data, bool) or (isinstance(data, Tensor) and data.dtype == mstype.bool_)
-        if _is_bool_or_bool_tensor(me) and _is_bool_or_bool_tensor(other):
-            return True
-        return False
-
     def ndimension(self):
         r"""
         Alias for :func:`mindspore.Tensor.ndim`.
         """
         return len(self._shape)
 
+    @jit_forbidden_register
     def set_const_arg(self, const_arg=True):
         """
         Specify whether the tensor is a constant when it is used for the argument of a network.
@@ -727,9 +607,25 @@ class Tensor(Tensor_):
         Returns:
             Tensor, Tensor that's been assigned.
         """
+        if is_stub_tensor(value):
+            value = value.stub_sync()
         self.assign_value_cpp(value)
         return self
 
+    def bincount(self, weights=None, minlength=0):
+        r"""
+        For details, please refer to :func:`mindspore.ops.bincount`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('bincount')(self, weights, minlength)
+
+    def chunk(self, chunks, axis=0):
+        r"""
+        For details, please refer to :func:`mindspore.ops.chunk`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('chunk')(self, chunks, axis)
+
     def item(self, index=None):
         """
         Get the item at the specified index of the tensor.
@@ -765,7 +661,7 @@ class Tensor(Tensor_):
         Insert scalar into a tensor (scalar is cast to tensor's dtype, if possible).
 
         There must be at least 1 argument, and define the last argument as item.
-        Then, tensor.itemset(\*args) is equivalent to :math:`tensor[args] = item`.
+        Then, tensor.itemset(\*args) is equivalent to :math:`Tensor[args] = item`.
 
         Args:
             args (Union[(numbers.Number), (int/tuple(int), numbers.Number)]): The arguments that
@@ -776,7 +672,7 @@ class Tensor(Tensor_):
                 It is either an int or a tuple.
 
         Returns:
-            A new tensor that doesn't affect the original tensor, with value set by :math:`tensor[args] = item`.
+            A new tensor that doesn't affect the original tensor, with value set by :math:`Tensor[args] = item`.
 
         Raises:
             ValueError: If the length of the first argument is not equal to self.ndim.
@@ -823,8 +719,7 @@ class Tensor(Tensor_):
 
     def numpy(self):
         """
-        Refer to `Tensor.asnumpy() \
-        <https://www.mindspore.cn/docs/en/r2.0.0-alpha/api_python/mindspore/Tensor/mindspore.Tensor.asnumpy.html>`_.
+        Alias for :func:`mindspore.Tensor.asnumpy`.
         """
         return self.asnumpy()
 
@@ -859,6 +754,22 @@ class Tensor(Tensor_):
         """
         return self.slice_num_of_persistent_data_
 
+    def histc(self, bins=100, min=0., max=0.):
+        """
+        For details, please refer to :func:`mindspore.ops.histc`.
+        """
+        self._init_check()
+        validator.check_value_type('min', min, (int, float,), 'Tensor.histc')
+        validator.check_value_type('max', max, (int, float,), 'Tensor.histc')
+        return tensor_operator_registry.get('histc')(self, bins, float(min), float(max))
+
+    def geqrf(self):
+        """
+        For details, please refer to :func:`mindspore.ops.geqrf`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('geqrf')(self)
+
     def slice_shape_of_persistent_data(self):
         """
         Get slice shape of tensor after cut to slice size.
@@ -900,28 +811,26 @@ class Tensor(Tensor_):
         self._init_check()
         Tensor_._flush_from_cache(self)
 
-    def addcdiv(self, x1, x2, value):
+    def addcdiv(self, tensor1, tensor2, value=1):
         r"""
         For details, please refer to :func:`mindspore.ops.addcdiv`.
         """
         self._init_check()
-        return tensor_operator_registry.get('addcdiv')()(self, x1, x2, value)
+        return tensor_operator_registry.get('addcdiv')()(self, tensor1, tensor2, value)
 
-    def addcmul(self, x1, x2, value):
+    def addcmul(self, tensor1, tensor2, value=1):
         r"""
         For details, please refer to :func:`mindspore.ops.addcmul`.
         """
-
         self._init_check()
-        return tensor_operator_registry.get('addcmul')()(self, x1, x2, value)
+        return tensor_operator_registry.get('addcmul')()(self, tensor1, tensor2, value)
 
-    def add(self, y):
+    def add(self, other):
         r"""
         For details, please refer to :func:`mindspore.ops.add`.
         """
-
         self._init_check()
-        return tensor_operator_registry.get('add')()(self, y)
+        return tensor_operator_registry.get('add')()(self, other)
 
     def subtract(self, other, *, alpha=1):
         r"""
@@ -936,29 +845,15 @@ class Tensor(Tensor_):
         For details, please refer to :func:`mindspore.ops.div`.
         """
         self._init_check()
-        return tensor_operator_registry.get('div')(self, value, None)
+        return tensor_operator_registry.get('div')(self, value, rounding_mode=None)
 
     def triu(self, diagonal=0):
         r"""
-        Returns a triangular matrix based on the diagonal. Default is the main diagonal.
-
-        Args:
-            diagonal (int): The index of diagonal. Default: 0.
-
-        Returns:
-            Tensor, a tensor has the same shape and data type as input.
-
-        Raises:
-            TypeError: If `diagonal` is not an int.
-            TypeError: If `x` is not an Tensor.
-            ValueError: If length of shape of x is less than 1.
-
-        Supported Platforms:
-            ``GPU`` ``CPU``
+        For details, please refer to :func:`mindspore.ops.triu`.
         """
         self._init_check()
         validator.check_value_type('diagonal', diagonal, [int], 'triu')
-        return tensor_operator_registry.get('triu')(diagonal)(self)
+        return tensor_operator_registry.get('triu')(self, diagonal)
 
     def addbmm(self, batch1, batch2, *, beta=1, alpha=1):
         r"""
@@ -988,34 +883,10 @@ class Tensor(Tensor_):
         self._init_check()
         return tensor_operator_registry.get('adjoint')(self)
 
-    def all(self, axis=(), keep_dims=False):
-        """
-        Check all tensor elements along a given axis evaluate to True.
-
-        Args:
-            axis (Union[None, int, tuple(int)]): Dimensions of reduction.
-                When the axis is None or empty tuple, reduce all dimensions. When the axis is int or
-                tuple(int), if the dimension of Tensor is dim, the value range is [-dim, dim). Default: ().
-            keep_dims (bool): Whether to keep the reduced dimensions. Default: False.
-
-        Returns:
-            Tensor, if all tensor elements along the given axis evaluate to True, its value is True,
-            otherwise its value is False. If the axis is None or empty tuple, reduce all dimensions.
-
-        Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
-
-        See also:
-            :func:`mindspore.Tensor.any`: Check any tensor element along a given axis evaluate to True.
-
-        Examples:
-            >>> from mindspore import Tensor
-            >>> a = Tensor([True, True, False])
-            >>> output = a.all()
-            >>> print(output)
-            False
+    def all(self, axis=None, keep_dims=False):
+        r"""
+        For details, please refer to :func:`mindspore.ops.all`.
         """
-
         self._init_check()
         if axis is None:
             axis = ()
@@ -1028,45 +899,21 @@ class Tensor(Tensor_):
         self._init_check()
         return tensor_operator_registry.get('angle')(self)
 
-    def any(self, axis=(), keep_dims=False):
-        """
-        Check any tensor element along a given axis evaluate to True.
-
-        Args:
-            axis (Union[None, int, tuple(int)]): Dimensions of reduction.
-                When the axis is None or empty tuple, reduce all dimensions. When the axis is int or
-                tuple(int), if the dimension of Tensor is dim, the value range is [-dim, dim). Default: ().
-            keep_dims (bool): Whether to keep the reduced dimensions. Default: False.
-
-        Returns:
-            Tensor, if any tensor element along the given axis evaluates to True, its value is True,
-            otherwise its value is False. If the axis is None or empty tuple, reduce all dimensions.
-
-        Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
-
-        See also:
-            :func:`mindspore.Tensor.all`: Check all tensor elements along a given axis evaluate to True.
-
-        Examples:
-            >>> from mindspore import Tensor
-            >>> a = Tensor([True, True, False])
-            >>> output = a.any()
-            >>> print(output)
-            True
+    def any(self, axis=None, keep_dims=False):
+        r"""
+        For details, please refer to :func:`mindspore.ops.any`.
         """
-
         self._init_check()
         if axis is None:
             axis = ()
         return tensor_operator_registry.get('any')(keep_dims)(self, axis)
 
-    def atan2(self, y):
+    def atan2(self, other):
         r"""
         For details, please refer to :func:`mindspore.ops.atan2`.
         """
         self._init_check()
-        return tensor_operator_registry.get('atan2')(self, y)
+        return tensor_operator_registry.get('atan2')(self, other)
 
     def baddbmm(self, batch1, batch2, beta=1, alpha=1):
         r"""
@@ -1105,26 +952,84 @@ class Tensor(Tensor_):
             shape = shape[0]
         return tensor_operator_registry.get('reshape')()(self, shape)
 
-    def bitwise_and(self, x):
+    def view_as(self, other):
+        r"""
+        View self Tensor as the same shape as `other` .
+
+        Args:
+            other(Tensor): The returned Tensor has the same shape as `other`.
+
+        Returns:
+            Tensor, has the same shape as `other`.
+
+        Raises:
+            TypeError: If `other` is not a Tensor.
+
+        Supported Platforms:
+            ``Ascend`` ``GPU`` ``CPU``
+
+        Examples:
+            >>> a = Tensor([[1, 2, 3], [2, 3, 4]], mstype.float32)
+            >>> b = Tensor([1, 1, 1, 1, 1, 1], mstype.float32)
+            >>> output = a.view_as(b)
+            >>> print(output)
+            [1. 2. 3. 2. 3. 4.]
+        """
+        self._init_check()
+        if not isinstance(other, (Tensor, Tensor_)):
+            raise TypeError(f"For view_as, the input other must be a Tensor, but got {type(other)}")
+        return self.view(other.shape)
+
+    def t(self):
+        r"""
+        For details, please refer to :func:`mindspore.ops.t`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get("t")(self)
+
+    def bitwise_and(self, other):
         """
         For details, please refer to :func:`mindspore.ops.bitwise_and`.
         """
         self._init_check()
-        return tensor_operator_registry.get('bitwise_and')(self, x)
+        return tensor_operator_registry.get('bitwise_and')(self, other)
 
-    def bitwise_or(self, x):
+    def bitwise_or(self, other):
         """
         For details, please refer to :func:`mindspore.ops.bitwise_or`.
         """
         self._init_check()
-        return tensor_operator_registry.get('bitwise_or')(self, x)
+        return tensor_operator_registry.get('bitwise_or')(self, other)
 
-    def bitwise_xor(self, x):
+    def bitwise_xor(self, other):
         """
         For details, please refer to :func:`mindspore.ops.bitwise_xor`.
         """
         self._init_check()
-        return tensor_operator_registry.get('bitwise_xor')(self, x)
+        return tensor_operator_registry.get('bitwise_xor')(self, other)
+
+    def bitwise_left_shift(self, other):
+        """
+        For details, please refer to :func:`mindspore.ops.bitwise_left_shift`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('bitwise_left_shift')(self, other)
+
+    def bitwise_right_shift(self, other):
+        """
+        For details, please refer to :func:`mindspore.ops.bitwise_right_shift`.
+        """
+        self._init_check()
+        _cast = tensor_operator_registry.get('cast')
+        other = _cast(other, self.dtype)
+        return tensor_operator_registry.get('bitwise_right_shift')(self, other)
+
+    def scatter(self, axis, index, src):
+        """
+        For details, please refer to :func:`mindspore.ops.scatter`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('scatter')(self, axis, index, src)
 
     def scatter_mul(self, indices, updates):
         """
@@ -1140,12 +1045,12 @@ class Tensor(Tensor_):
         self._init_check()
         return tensor_operator_registry.get('tensor_scatter_div')(self, indices, updates)
 
-    def ger(self, x):
+    def ger(self, vec2):
         """
         For details, please refer to :func:`mindspore.ops.ger`.
         """
         self._init_check()
-        return tensor_operator_registry.get('ger')(self, x)
+        return tensor_operator_registry.get('ger')(self, vec2)
 
     def gt(self, x):
         """
@@ -1200,6 +1105,27 @@ class Tensor(Tensor_):
         self._init_check()
         return tensor_operator_registry.get('exp')()(self)
 
+    def real(self):
+        r"""
+        For details, please refer to :func:`mindspore.ops.real`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('real')(self)
+
+    def rsqrt(self):
+        r"""
+        For details, please refer to :func:`mindspore.ops.rsqrt`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('rsqrt')(self)
+
+    def reciprocal(self):
+        r"""
+        For details, please refer to :func:`mindspore.ops.reciprocal`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('reciprocal')(self)
+
     def sqrt(self):
         """
         For details, please refer to :func:`mindspore.ops.sqrt`.
@@ -1257,55 +1183,21 @@ class Tensor(Tensor_):
 
     def cos(self):
         r"""
-        Computes cosine of input element-wise.
-
-        .. math::
-            out_i = cos(x_i)
-
-        .. warning::
-            Currently support Float16, Float32 data type. If use Float64, there may
-            be a problem of missing precision.
-
-        Returns:
-            Tensor, has the same shape as `x`.
-
-        Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
-
-        Examples:
-            >>> from mindspore import Tensor
-            >>> a = Tensor(np.array([0.24, 0.83, 0.31, 0.09]), mindspore.float32)
-            >>> output = a.cos()
-            >>> print(output)
-            [0.971338 0.6748758 0.95233357 0.9959527]
+        For details, please refer to :func:`mindspore.ops.cos`.
         """
         self._init_check()
         return tensor_operator_registry.get('cos')(self)
 
-    def acosh(self):
+    def cov(self, *, correction=1, fweights=None, aweights=None):
         r"""
-        Computes inverse hyperbolic cosine of the inputs element-wise.
-
-        .. math::
-
-            out_i = \cosh^{-1}(input_i)
-
-        .. warning::
-            Given an input tensor x, the function computes inverse hyperbolic cosine of every element.
-            Input range is [1, inf].
-
-        Returns:
-            Tensor, has the same shape as `x`.
-
-        Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
+        For details, please refer to :func:`mindspore.ops.cov`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('cov')(self, correction=correction, fweights=fweights, aweights=aweights)
 
-        Examples:
-            >>> from mindspore import Tensor
-            >>> a = Tensor(np.array([1.0, 1.5, 3.0, 100.0]), mindspore.float32)
-            >>> output = a.acosh()
-            >>> print(output)
-            [0.        0.9624237 1.7627472 5.298292]
+    def acosh(self):
+        """
+        For details, please refer to :func:`mindspore.ops.acosh`.
         """
         self._init_check()
         return tensor_operator_registry.get('acosh')(self)
@@ -1358,19 +1250,20 @@ class Tensor(Tensor_):
         self._init_check()
         return tensor_operator_registry.get("negative")(self)
 
-    def norm(self, axis, p=2, keep_dims=False, epsilon=1e-12):
+    # pylint: disable=redefined-builtin
+    def norm(self, ord=None, dim=None, keepdim=False, *, dtype=None):
         """
         For details, please refer to :func:`mindspore.ops.norm`.
         """
         self._init_check()
-        return tensor_operator_registry.get('norm')(self, axis, p, keep_dims, epsilon)
+        return tensor_operator_registry.get('norm')(self, ord, dim, keepdim, dtype=dtype)
 
-    def renorm(self, p, dim, maxnorm):
+    def renorm(self, p, axis, maxnorm):
         """
         For details, please refer to :func:`mindspore.ops.renorm`.
         """
         self._init_check()
-        return tensor_operator_registry.get("renorm")(self, p, dim, maxnorm)
+        return tensor_operator_registry.get("renorm")(self, p, axis, maxnorm)
 
     def approximate_equal(self, other, tolerance=1e-5):
         r"""
@@ -1386,13 +1279,6 @@ class Tensor(Tensor_):
             tensor_operator_registry.get('__sub__')(input_x, input_y)
         ), tolerance)
 
-    def matrix_determinant(self):
-        r"""
-        For details, please refer to :func:`mindspore.ops.matrix_determinant`.
-        """
-        self._init_check()
-        return tensor_operator_registry.get('matrix_determinant')(self)
-
     def log1p(self):
         r"""
         For details, please refer to :func:`mindspore.ops.log1p`.
@@ -1401,7 +1287,6 @@ class Tensor(Tensor_):
         return tensor_operator_registry.get('log1p')(self)
 
     def logit(self, eps=None):
-
         r"""
         For details, please refer to :func:`mindspore.ops.logit`.
         """
@@ -1415,26 +1300,29 @@ class Tensor(Tensor_):
         r"""
         For details, please refer to :func:`mindspore.ops.logaddexp`.
         """
+        self._init_check()
         return tensor_operator_registry.get('logaddexp')(self, other)
 
     def logaddexp2(self, other):
         r"""
         For details, please refer to :func:`mindspore.ops.logaddexp2`.
         """
+        self._init_check()
         return tensor_operator_registry.get('logaddexp2')(self, other)
 
-    def logsumexp(self, dim, keepdim=False):
+    def logsumexp(self, axis, keepdims=False):
         r"""
         For details, please refer to :func:`mindspore.ops.logsumexp`.
         """
-        return tensor_operator_registry.get('logsumexp')(self, dim, keepdim)
+        self._init_check()
+        return tensor_operator_registry.get('logsumexp')(self, axis, keepdims)
 
-    def log_matrix_determinant(self):
+    def logdet(self):
         r"""
-        For details, please refer to :func:`mindspore.ops.log_matrix_determinant`.
+        For details, please refer to :func:`mindspore.ops.logdet`.
         """
         self._init_check()
-        return tensor_operator_registry.get('log_matrix_determinant')(self)
+        return tensor_operator_registry.get('logdet')(self)
 
     def i0(self):
         r"""
@@ -1450,6 +1338,27 @@ class Tensor(Tensor_):
         self._init_check()
         return tensor_operator_registry.get('isclose')(self, x2, rtol, atol, equal_nan)
 
+    def isneginf(self):
+        r"""
+        For details, please refer to :func:`mindspore.ops.isneginf`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('isneginf')(self)
+
+    def isposinf(self):
+        r"""
+        For details, please refer to :func:`mindspore.ops.isposinf`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('isposinf')(self)
+
+    def isreal(self):
+        r"""
+        For details, please refer to :func:`mindspore.ops.isreal`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('isreal')(self)
+
     def isfinite(self):
         r"""
         For details, please refer to :func:`mindspore.ops.isfinite`.
@@ -1457,6 +1366,13 @@ class Tensor(Tensor_):
         self._init_check()
         return tensor_operator_registry.get('isfinite')()(self)
 
+    def is_complex(self):
+        r"""
+        For details, please refer to :func:`mindspore.ops.is_complex`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('is_complex')(self)
+
     def inv(self):
         r"""
         For details, please refer to :func:`mindspore.ops.inv`.
@@ -1464,6 +1380,13 @@ class Tensor(Tensor_):
         self._init_check()
         return tensor_operator_registry.get('inv')(self)
 
+    def inverse(self):
+        r"""
+        For details, please refer to :func:`mindspore.ops.inverse`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('inverse')(self)
+
     def invert(self):
         r"""
         For details, please refer to :func:`mindspore.ops.invert`.
@@ -1471,12 +1394,12 @@ class Tensor(Tensor_):
         self._init_check()
         return tensor_operator_registry.get('invert')(self)
 
-    def pow(self, power):
+    def pow(self, exponent):
         r"""
         For details, please refer to :func:`mindspore.ops.pow`.
         """
         self._init_check()
-        return tensor_operator_registry.get('pow')()(self, power)
+        return tensor_operator_registry.get('pow')()(self, exponent)
 
     def log(self):
         """
@@ -1499,7 +1422,7 @@ class Tensor(Tensor_):
         self._init_check()
         return tensor_operator_registry.get('log2')(self)
 
-    def mean(self, axis=(), keep_dims=False):
+    def mean(self, axis=None, keep_dims=False):
         """
         For details, please refer to :func:`mindspore.ops.mean`.
         """
@@ -1508,12 +1431,14 @@ class Tensor(Tensor_):
             axis = ()
         return tensor_operator_registry.get('mean')(keep_dims)(self, axis)
 
-    def amin(self, axis=(), keep_dims=False):
+    def amin(self, axis=None, keepdims=False, *, initial=None, where=None):
         """
         For details, please refer to :func:`mindspore.ops.amin`.
         """
         self._init_check()
-        return tensor_operator_registry.get('amin')(self, axis, keep_dims)
+        if axis is None:
+            axis = ()
+        return tensor_operator_registry.get('amin')(self, axis, keepdims, initial=initial, where=where)
 
     def reverse(self, axis):
         """
@@ -1522,13 +1447,15 @@ class Tensor(Tensor_):
         self._init_check()
         return tensor_operator_registry.get('reverse')(axis)(self)
 
-    def amax(self, axis=(), keep_dims=False):
+    def amax(self, axis=None, keepdims=False, *, initial=None, where=None):
         """
         For details, please refer to :func:`mindspore.ops.amax`.
         """
         self._init_check()
-        return tensor_operator_registry.get('amax')(self, axis, keep_dims)
-
+        if axis is None:
+            axis = ()
+        return tensor_operator_registry.get('amax')(self, axis, keepdims, initial=initial, where=where)
+
     def reverse_sequence(self, seq_lengths, seq_dim=0, batch_dim=0):
         """
         For details, please refer to :func:`mindspore.ops.reverse_sequence`.
@@ -1536,7 +1463,7 @@ class Tensor(Tensor_):
         self._init_check()
         return tensor_operator_registry.get("reverse_sequence")(seq_dim, batch_dim)(self, seq_lengths)
 
-    def prod(self, axis=(), keep_dims=False):
+    def prod(self, axis=None, keep_dims=False):
         """
         For details, please refer to :func:`mindspore.ops.prod`.
         """
@@ -1663,39 +1590,7 @@ class Tensor(Tensor_):
 
     def rot90(self, k, dims):
         r"""
-        Rotate a n-D tensor by 90 degrees in the plane specified by dims axis.
-        Rotation direction is from the first towards the second axis if k > 0,
-        and from the second towards the first for k < 0.
-
-        Args:
-            k (int): Number of times to rotate.
-            dims (Union[list(int), tuple(int)]): Axis to rotate.
-
-        Returns:
-            Tensor.
-
-        Raises:
-            TypeError: If `x` is not a Tensor.
-            TypeError: If `k` is not an integer.
-            TypeError: If `dims` is not a list or a tuple of integers.
-            ValueError: If the length of `dims` is not `2`.
-            ValueError: If any dims is out of range of [-self.ndim, self.ndim).
-            RuntimeError: If rotation dims are not different.
-
-        Supported Platforms:
-            ``Ascend`` ``GPU``
-
-        Examples:
-            >>> import numpy as np
-            >>> import mindspore as ms
-            >>> from mindspore import Tensor
-            >>> x = Tensor(np.array([[0, 1], [2, 3]])).astype(np.float32)
-            >>> k = 1
-            >>> dims = [0, 1]
-            >>> output = x.rot90(k, dims)
-            >>> print(output)
-            [[1. 3.]
-            [0. 2.]]
+        For details, please refer to :func:`mindspore.ops.rot90`.
         """
         self._init_check()
         return tensor_operator_registry.get('rot90')(self, k, dims)
@@ -1707,6 +1602,13 @@ class Tensor(Tensor_):
         self._init_check()
         return tensor_operator_registry.get('deg2rad')(self)
 
+    def dot(self, other):
+        r"""
+        For details, please refer to :func:`mindspore.ops.dot`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('dot')(self, other)
+
     def rad2deg(self):
         r"""
         For details, please refer to :func:`mindspore.ops.rad2deg`.
@@ -1735,16 +1637,13 @@ class Tensor(Tensor_):
         self._init_check()
         return tensor_operator_registry.get('numel')(self)
 
-    def permute(self, *dims):
+    def permute(self, *axis):
         """
         For details, please refer to :func:`mindspore.ops.permute`.
         """
         self._init_check()
-        if not dims:
-            raise ValueError(f"For Tensor.permute, the dims must not be none.")
-        if len(dims) == 1:
-            return tensor_operator_registry.get("permute")(self, *dims)
-        return tensor_operator_registry.get("permute")(self, dims)
+        perm = validator.check_transpose_axis(axis, self.ndim)
+        return tensor_operator_registry.get('permute')(self, perm)
 
     def positive(self):
         """
@@ -1760,20 +1659,26 @@ class Tensor(Tensor_):
         self._init_check()
         return tensor_operator_registry.get('remainder')(self, divisor)
 
-    def flatten(self, order='C'):
+    def flatten(self, order='C', *, start_dim=0, end_dim=-1):
         r"""
         For details, please refer to :func:`mindspore.ops.flatten`.
         """
         self._init_check()
-        reshape_op = tensor_operator_registry.get('reshape')()
-        trans_op = tensor_operator_registry.get('transpose')()
+        return tensor_operator_registry.get('flatten')(self, order, start_dim=start_dim, end_dim=end_dim)
 
-        order = validator.check_flatten_order(order)
-        if order == 'C':
-            return reshape_op(self, (-1,))
+    def float_power(self, other):
+        r"""
+        For details, please refer to :func:`mindspore.ops.float_power`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('float_power')(self, other)
 
-        perm = tuple(range(self.ndim - 1, -1, -1))
-        return reshape_op(trans_op(self, perm), (-1,))
+    def fmod(self, other):
+        r"""
+        For details, please refer to :func:`mindspore.ops.fmod`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('fmod')(self, other)
 
     def narrow(self, axis, start, length):
         """
@@ -1782,49 +1687,19 @@ class Tensor(Tensor_):
         self._init_check()
         return tensor_operator_registry.get('narrow')(self, axis, start, length)
 
-    def swapaxes(self, axis1, axis2):
+    def swapaxes(self, axis0, axis1):
         """
-        Interchange two axes of a tensor.
-
-        Args:
-            axis1 (int): First axis.
-            axis2 (int): Second axis.
-
-        Returns:
-            Transposed tensor, has the same data type as the input.
-
-        Raises:
-            TypeError: If `axis1` or `axis2` is not integer.
-            ValueError: If `axis1` or `axis2` is not in the range of :math:`[-ndim, ndim-1]`.
-
-        Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
-
-        Examples:
-            >>> import numpy as np
-            >>> from mindspore import Tensor
-            >>> x = Tensor(np.ones((2,3,4), dtype=np.float32))
-            >>> output = x.swapaxes(0, 2)
-            >>> print(output.shape)
-            (4,3,2)
+        For details, please refer to :func:`mindspore.ops.swapaxes`.
         """
         self._init_check()
-        axis1, axis2 = validator.check_swapaxes_axis((axis1, axis2), self.ndim)
-
-        if axis1 == axis2:
-            return self
-        if axis1 > axis2:
-            axis1, axis2 = axis2, axis1
-
-        perm = tuple(range(0, self.ndim))
-        if axis2 + 1 < self.ndim:
-            new_perm = perm[0:axis1] + perm[axis2:axis2 + 1] + \
-                       perm[axis1 + 1:axis2] + perm[axis1:axis1 + 1] + perm[axis2 + 1:]
-        else:
-            new_perm = perm[0:axis1] + perm[axis2:axis2 + 1] + \
-                       perm[axis1 + 1:axis2] + perm[axis1:axis1 + 1]
+        return tensor_operator_registry.get('swapaxes')(self, axis0, axis1)
 
-        return tensor_operator_registry.get('transpose')()(self, new_perm)
+    def swapdims(self, dim0, dim1):
+        """
+        For details, please refer to :func:`mindspore.ops.swapdims`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('swapdims')(self, dim0, dim1)
 
     def squeeze(self, axis=None):
         """
@@ -1836,13 +1711,27 @@ class Tensor(Tensor_):
         new_shape = validator.prepare_shape_for_squeeze(self.shape, axis)
         return tensor_operator_registry.get('reshape')()(self, new_shape)
 
+    def slogdet(self):
+        """
+        For details, please refer to :func:`mindspore.ops.slogdet`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('slogdet')(self)
+
+    def tril(self, diagonal=0):
+        """
+        For details, please refer to :func:`mindspore.ops.tril`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('tril')(self, diagonal)
+
     def unsqueeze(self, dim):
         """
         For details, please refer to :func:`mindspore.ops.unsqueeze`.
         """
         self._init_check()
         validator.check_is_int(dim, 'dim')
-        validator.check_int_range(dim, -self.ndim - 1, self.ndim + 1, Rel.INC_LEFT, 'dim')
+        validator.check_int_range(dim, -self.ndim - 1, self.ndim + 1, validator.INC_LEFT, 'dim')
         return tensor_operator_registry.get('unsqueeze')(self, dim)
 
     def expand_dims(self, axis):
@@ -1851,7 +1740,7 @@ class Tensor(Tensor_):
         """
         self._init_check()
         validator.check_is_int(axis, 'axis')
-        validator.check_int_range(axis, -self.ndim - 1, self.ndim + 1, Rel.INC_LEFT, 'axis')
+        validator.check_int_range(axis, -self.ndim - 1, self.ndim + 1, validator.INC_LEFT, 'axis')
         return tensor_operator_registry.get('expand_dims')(self, axis)
 
     def astype(self, dtype, copy=True):
@@ -1860,7 +1749,7 @@ class Tensor(Tensor_):
 
         Args:
             dtype (Union[:class:`mindspore.dtype`, numpy.dtype, str]): Designated tensor dtype, can be in
-                format of :class:`mindspore.dtype.float32` or :class:`numpy.float32` or `float32`.
+                format of `mindspore.dtype.float32` or `numpy.float32` or `float32`.
             copy (bool, optional): By default, astype always returns a newly allocated
                 tensor. If this is set to false, the input tensor is returned instead
                 of a copy. Default: True.
@@ -1962,12 +1851,12 @@ class Tensor(Tensor_):
 
         Examples:
             >>> x = Tensor(np.array([0.0, 0.4, 0.6, 0.7, 0.1]), mindspore.float32)
-            >>> index, output = x.argmax_with_value()
-            >>> print(index, output)
-            3 0.7
-            >>> index, output = x.argmax_with_value(keep_dims=True)
-            >>> print(index, output)
-            [3] [0.7]
+            >>> output, index = x.argmax_with_value()
+            >>> print(output, index)
+            0.7 3
+            >>> output, index = x.argmax_with_value(keep_dims=True)
+            >>> print(output, index)
+            [0.7] [3]
         """
         if self.shape == ():
             return (Tensor(0), self)
@@ -2009,12 +1898,12 @@ class Tensor(Tensor_):
 
         Examples:
             >>> x = Tensor(np.array([0.0, 0.4, 0.6, 0.7, 0.1]), mindspore.float32)
-            >>> index, output = x.argmin_with_value()
-            >>> print(index, output)
-            0 0.0
-            >>> index, output = x.argmin_with_value(keep_dims=True)
-            >>> print(index, output)
-            [0] [0.0]
+            >>> output, index = x.argmin_with_value()
+            >>> print(output, index
+            0.0 0
+            >>> output, index = x.argmin_with_value(keep_dims=True)
+            >>> print(output, index)
+            [0.0] [0]
         """
         if self.shape == ():
             return (Tensor(0), self)
@@ -2050,18 +1939,25 @@ class Tensor(Tensor_):
         """
         return tensor_operator_registry.get('cummax')(self, axis)
 
-    def index_fill(self, dim, index, value):
+    def index_fill(self, axis, index, value):
         """
         For details, please refer to :func:`mindspore.ops.index_fill`.
         """
-        return tensor_operator_registry.get('index_fill')(self, dim, index, value)
+        return tensor_operator_registry.get('index_fill')(self, axis, index, value)
+
+    def index_select(self, axis, index):
+        """
+        For details, please refer to :func:`mindspore.ops.index_select`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('index_select')(self, axis, index)
 
     def inplace_update(self, v, indices):
         """
         For details, please refer to :func:`mindspore.ops.inplace_update`.
         """
         self._init_check()
-        return tensor_operator_registry.get('inplace_update')(indices)(self, v)
+        return tensor_operator_registry.get('inplace_update')()(self, indices, v)
 
     def copy(self):
         """
@@ -2099,7 +1995,7 @@ class Tensor(Tensor_):
         x = x.astype(origin_dtype)
         return x
 
-    def max(self, axis=None, keepdims=False, initial=None, where=True):
+    def max(self, axis=None, keepdims=False, *, initial=None, where=True, return_indices=False):
         """
         Return the maximum of a tensor or maximum along an axis.
 
@@ -2112,13 +2008,17 @@ class Tensor(Tensor_):
                 If this is set to True, the axes which are reduced are left in the
                 result as dimensions with size one. With this option, the result will
                 broadcast correctly against the input array. Default: False.
+
+        Keyword Args:
             initial (scalar, optional):
                 The minimum value of an output element. Must be present to allow
                 computation on empty slice. Default: None.
-            where (bool Tensor, optional):
+            where (Tensor[bool], optional):
                 A boolean tensor which is broadcasted to match the dimensions of array,
                 and selects elements to include in the reduction. If non-default value
                 is passed, initial must also be provided. Default: True.
+            return_indices (bool, optional): Whether to return the index of the maximum value. Default: False.
+                If `axis` is a list or tuple of ints, it must be False.
 
         Returns:
             Tensor or scalar, maximum of input tensor. If `axis` is None, the result is a scalar
@@ -2144,22 +2044,99 @@ class Tensor(Tensor_):
             >>> output = a.max()
             >>> print(output)
             3.0
+            >>> value, indices = a.max(axis=0, return_indices=True)
+            >>> print(value)
+            [2. 3.]
+            >>> print(indices)
+            [1 1]
         """
-        reduce_ = tensor_operator_registry.get("reduce")
-        reduce_max = tensor_operator_registry.get("reduce_max")
-        maximum = tensor_operator_registry.get("maximum")
-        return reduce_(self, reduce_max(keepdims), cmp_fn=maximum, axis=axis, keepdims=keepdims,
-                       initial=initial, where=where)
+        self._init_check()
+        if isinstance(axis, (list, tuple)):
+            reduce_ = tensor_operator_registry.get("reduce")
+            reduce_max = tensor_operator_registry.get("reduce_max")
+            maximum = tensor_operator_registry.get("maximum")
+            return reduce_(self, reduce_max(keepdims), cmp_fn=maximum, axis=axis, keepdims=keepdims,
+                           initial=initial, where=where)
+        values, indices = tensor_operator_registry.get("max")(self, axis, keepdims, initial=initial, where=where)
+        if not return_indices:
+            return values
+        return values, indices
 
-    def min(self, axis=None, keepdims=False, initial=None, where=True):
+    def min(self, axis=None, keepdims=False, *, initial=None, where=True, return_indices=False):
         """
-        For details, please refer to :func:`mindspore.ops.min`.
-        """
-        reduce_ = tensor_operator_registry.get("reduce")
-        reduce_min = tensor_operator_registry.get("reduce_min")
-        minimum = tensor_operator_registry.get("minimum")
-        return reduce_(self, reduce_min(keepdims), cmp_fn=minimum(), axis=axis, keepdims=keepdims,
-                       initial=initial, where=where)
+        Return the minimum of a tensor or minimum along an axis.
+
+        Args:
+            axis (Union[None, int, list, tuple of ints], optional): An axis or
+                axes along which to operate. By default, flattened input is used. If
+                `axis` is a tuple of ints, the minimum is selected over multiple axes,
+                instead of a single axis or all the axes as before. Default: None.
+            keepdims (bool, optional):
+                If True, the axes which are reduced are left in the
+                result as dimensions with size one. With this option, the result will
+                broadcast correctly against the input array. Default: False.
+
+        Keyword Args:
+            initial (scalar, optional):
+                The minimum value of an output element. Must be present to allow
+                computation on empty slice. Default: None.
+            where (bool Tensor, optional):
+                A boolean tensor which is broadcasted to match the dimensions of array,
+                and selects elements to include in the reduction. If non-default value
+                is passed, initial must also be provided. Default: True.
+            return_indices (bool, optional): Whether to return the index of the minimum value. Default: False.
+                If `axis` is a list or tuple of ints, it must be False.
+
+        Returns:
+            Tensor or scalar, minimum of input tensor. If `axis` is None, the result is a scalar
+            value. If `axis` is given, the result is a tensor of dimension ``self.ndim - 1``.
+
+        Raises:
+            TypeError: If arguments have types not specified above.
+
+        Supported Platforms:
+            ``Ascend`` ``GPU`` ``CPU``
+
+        See also:
+            :func:`mindspore.Tensor.argmin`: Return the indices of the minimum values along an axis.
+
+            :func:`mindspore.Tensor.argmax`: Return the indices of the maximum values along an axis.
+
+            :func:`mindspore.Tensor.max`: Return the minimum of a tensor or minimum along an axis.
+
+        Examples:
+            >>> import numpy as np
+            >>> from mindspore import Tensor
+            >>> a = Tensor(np.arange(4).reshape((2, 2)).astype('float32'))
+            >>> output = a.min()
+            >>> print(output)
+            0.0
+            >>> output = a.min(axis=0)
+            >>> print(output)
+            [0. 1.]
+            >>> output = a.min(axis=0, initial=9, where=Tensor([False]))
+            >>> print(output)
+            [9. 9.]
+            >>> output = a.min(axis=0, initial=9, where=Tensor([False, True]))
+            >>> print(output)
+            [9. 1.]
+            >>> value, indices = a.min(axis=0, return_indices=True)
+            >>> print(value)
+            [0. 1.]
+            >>> print(indices)
+            [0 0]
+        """
+        self._init_check()
+        if isinstance(axis, (list, tuple)):
+            reduce_ = tensor_operator_registry.get("reduce")
+            reduce_min = tensor_operator_registry.get("reduce_min")
+            minimum = tensor_operator_registry.get("minimum")
+            return reduce_(self, reduce_min(keepdims), cmp_fn=minimum(), axis=axis, keepdims=keepdims,
+                           initial=initial, where=where)
+        values, indices = tensor_operator_registry.get("min")(self, axis, keepdims, initial=initial, where=where)
+        if not return_indices:
+            return values
+        return values, indices
 
     def scatter_add(self, indices, updates):
         """
@@ -2232,7 +2209,7 @@ class Tensor(Tensor_):
 
     def fill(self, value):
         """
-        For details, please refer to :func:`mindspore.ops.fill`.
+        `Tensor.fill` is deprecated, please use `ops.fill` instead.
         """
         if value is None:
             if self.dtype not in (mstype.float16, mstype.float32, mstype.float64):
@@ -2247,7 +2224,7 @@ class Tensor(Tensor_):
 
     def fills(self, value):
         """
-        For details, please refer to :func:`mindspore.ops.fills`.
+        `Tensor.fills` is deprecated, please use `ops.fill` instead.
         """
         self._init_check()
         return tensor_operator_registry.get('fills')(self, value)
@@ -2314,68 +2291,18 @@ class Tensor(Tensor_):
         """
         return tensor_operator_registry.get('minimum')()(self, other)
 
-    def clip(self, xmin, xmax, dtype=None):
+    def clamp(self, min=None, max=None):
+        r"""
+        For details, please refer to :func:`mindspore.ops.clamp`.
         """
-        Clips (limits) the values in a Tensor.
-
-        Given an interval, values outside the interval are clipped to the interval edges.
-        For example, if an interval of :math:`[0, 1]` is specified, values smaller than 0 become 0,
-        and values larger than 1 become 1.
-
-        Note:
-            Currently, clip with `xmin=nan` or `xmax=nan` is not supported.
-
-        Args:
-            xmin (Tensor, scalar, None): Minimum value. If None, clipping is not performed
-                on the lower interval edge. Not more than one of `xmin` and `xmax` may be None.
-            xmax (Tensor, scalar, None): Maximum value. If None, clipping is not performed
-                on the upper interval edge. Not more than one of `xmin` and `xmax` may be None.
-                If `xmin` or `xmax` are tensors, then `xmin`, `xmax` and the given tensor
-                will be broadcasted to match their shapes.
-            dtype (:class:`mindspore.dtype`, optional): Overrides the dtype of the
-                output Tensor. Default is None.
-
-        Returns:
-            Tensor, a tensor with the elements of the input tensor, but where values
-            < `xmin` are replaced with `xmin`, and those > `xmax` with `xmax`.
-
-        Raises:
-            TypeError: If inputs have types not specified above.
-            ValueError: If the shapes of `x1` and `x2` cannot broadcast, or both `xmin` and `xmax` are `None`.
-
-        Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
+        self._init_check()
+        return tensor_operator_registry.get('clamp')(self, min, max)
 
-        Examples:
-            >>> from mindspore import Tensor
-            >>> x = Tensor([1, 2, 3, -4, 0, 3, 2, 0]).astype("float32")
-            >>> y = x.clip(0, 2)
-            >>> print(y)
-            [1. 2. 2. 0. 0. 2. 2. 0.]
-            >>> t = Tensor([1, 1, 1, 1, 1, 1, 1, 1])
-            >>> y = x.clip(t, 2)
-            >>> print(y)
-            [1. 2. 2. 1. 1. 2. 2. 1.]
+    def clip(self, min=None, max=None):
+        r"""
+        Alias for :func:`mindspore.Tensor.clamp`.
         """
-        if xmin is None and xmax is None:
-            raise ValueError("For 'Tensor.clip', the argument 'xmin' and 'xman' cannot all be None.")
-        x = self
-        # F.maximum/minimum does not support when both operands are scalar
-        if xmin is not None:
-            xmin = Tensor(xmin).astype(x.dtype)
-            if x.ndim == 0 and xmin.ndim == 0:
-                x = tensor_operator_registry.get("maximum")(x.reshape((1,)), xmin).squeeze()
-            else:
-                x = tensor_operator_registry.get("maximum")(x, xmin)
-        if xmax is not None:
-            xmax = Tensor(xmax).astype(x.dtype)
-            if x.ndim == 0 and xmax.ndim == 0:
-                x = tensor_operator_registry.get("minimum")()(x.reshape((1,)), xmax).squeeze()
-            else:
-                x = tensor_operator_registry.get("minimum")()(x, xmax)
-        if dtype is not None and dtype != x.dtype:
-            return x.astype(dtype)
-        return x
+        return self.clamp(min, max)
 
     def _init_check(self):
         if self.has_init:
@@ -2420,7 +2347,7 @@ class Tensor(Tensor_):
         # At embedding cache scenes, we need limit the size of memory for tensor.
         # And save out of range data to persistent storage to support TB-Level size of tensor.
         data_shape = list(shape)
-        slice_num_of_persistent_data = split_to_slice_if_need(self.dtype, shape)
+        slice_num_of_persistent_data = get_slice_num(self.dtype, shape)
         if slice_num_of_persistent_data > 1:
             slice_first_dim = math.ceil(shape[0] / slice_num_of_persistent_data)
             data_shape[0] = slice_first_dim
@@ -2443,9 +2370,9 @@ class Tensor(Tensor_):
                 self._np_seed = np.random.get_state()[1][0]
                 self.need_set_seed = (slice_index is not None)
                 self._global_seed = global_seed
-                self._device_num = 1
+                self._seed_offset = 1
                 if self.need_set_seed:
-                    self._device_num = get_group_size()
+                    self._seed_offset = get_group_size() * 2
 
             def __enter__(self):
                 if self.need_set_seed:
@@ -2456,7 +2383,7 @@ class Tensor(Tensor_):
                     else:
                         np.random.seed(slice_index + Tensor.delta_seed)
                         self.init.seed = slice_index + Tensor.delta_seed
-                        Tensor.delta_seed += self._device_num
+                        Tensor.delta_seed += self._seed_offset
 
             def __exit__(self, ptype, value, trace):
                 if self.need_set_seed:
@@ -2465,10 +2392,6 @@ class Tensor(Tensor_):
 
         with seed_context(self.init):
             self.init(data)
-        if opt_shard_group:
-            rank = get_rank(opt_shard_group)
-            size = get_group_size(opt_shard_group)
-            data = np.split(data, size)[rank]
         self.init = None
 
         # At embedding cache scenes. When size of tensor is out of range, we store data to persistent storage
@@ -2478,44 +2401,6 @@ class Tensor(Tensor_):
             self.assign_value(Tensor_.from_numpy(data))
         return self
 
-    def to_tensor(self, slice_index=None, shape=None, opt_shard_group=None):
-        """
-        Return init_data() and get the tensor format data of this Tensor.
-
-        Note:
-            The usage of `to_tensor` is deprecated. Please use `init_data`.
-
-        Args:
-            slice_index (int): Slice index of a parameter's slices.
-                It is used when initialize a slice of a parameter, it guarantees that devices
-                using the same slice can generate the same tensor. Default: None.
-            shape (list[int]): Shape of the slice, it is used when initialize a slice of the parameter. Default: None.
-            opt_shard_group(str): Optimizer shard group which is used in auto or semi auto parallel mode
-                to get one shard of a parameter's slice. Default: None.
-
-        Returns:
-            Initialized Tensor.
-
-        Raises:
-            TypeError: `indices` is neither int32 nor int64.
-            ValueError: The length of the shape of the tensor is less than the last dimension of `indices`.
-
-        Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
-
-        Examples:
-            >>> import mindspore as ms
-            >>> from mindspore.common.initializer import initializer, Constant
-            >>> x = initializer(Constant(1), [2, 2], ms.float32)
-            >>> out = x.to_tensor()
-            >>> print(out)
-            [[1. 1.]
-             [1. 1.]]
-        """
-        logger.warning("WARN_DEPRECATED: The usage of to_tensor is deprecated."
-                       " Please use init_data")
-        return self.init_data(slice_index, shape, opt_shard_group)
-
     def resize(self, *new_shape):
         """
         Changes shape and size of tensor in-place.
@@ -2575,10 +2460,59 @@ class Tensor(Tensor_):
 
     def det(self):
         r"""
-        Refer to :func:`mindspore.Tensor.matrix_determinant`.
+        For details, please refer to :func:`mindspore.ops.det`.
         """
         self._init_check()
-        return tensor_operator_registry.get('matrix_determinant')(self)
+        return tensor_operator_registry.get('det')(self)
+
+    def diff(self, n=1, axis=-1, prepend=None, append=None):
+        r"""
+        For details, please refer to :func:`mindspore.ops.diff`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('diff')(self, n, axis, prepend, append)
+
+    def frac(self):
+        r"""
+        For details, please refer to :func:`mindspore.ops.frac`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('frac')(self)
+
+    def argwhere(self):
+        r"""
+        For details, please refer to :func:`mindspore.ops.argwhere`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('argwhere')(self)
+
+    def moveaxis(self, source, destination):
+        r"""
+        For details, please refer to :func:`mindspore.ops.moveaxis`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('moveaxis')(self, source, destination)
+
+    def movedim(self, source, destination):
+        r"""
+        For details, please refer to :func:`mindspore.ops.movedim`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('movedim')(self, source, destination)
+
+    def digamma(self):
+        r"""
+        For details, please refer to :func:`mindspore.ops.digamma`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('digamma')(self)
+
+    def lgamma(self):
+        r"""
+        For details, please refer to :func:`mindspore.ops.lgamma`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('lgamma')(self)
 
     def diagonal(self, offset=0, axis1=0, axis2=1):
         """
@@ -2607,11 +2541,11 @@ class Tensor(Tensor_):
         elif offset != 0:
             e = e.astype(mstype.float32)
             if offset > 0:
-                e_left = tensor_operator_registry.get('fill')(dtype, (n, offset), 0)
+                e_left = tensor_operator_registry.get('fill')(mstype.float32, (n, offset), 0)
                 e_right = e[..., 0:m - offset:1]
                 e = tensor_operator_registry.get('concatenate')(1)((e_left, e_right)).astype(dtype)
             elif offset < 0:
-                e_upper = tensor_operator_registry.get('fill')(dtype, (-offset, m), 0)
+                e_upper = tensor_operator_registry.get('fill')(mstype.float32, (-offset, m), 0)
                 e_lower = e[0:n + offset:1, ...]
                 e = tensor_operator_registry.get('concatenate')(0)((e_upper, e_lower)).astype(dtype)
         e = tensor_operator_registry.get('broadcast_to')(shape)(e)
@@ -2668,6 +2602,9 @@ class Tensor(Tensor_):
             >>> print(x.trace())
             3.0
         """
+        if offset == 0 and axis1 == 0 and axis2 == 1 and dtype is None:
+            self._init_check()
+            return tensor_operator_registry.get('trace')(self)
         d = self.diagonal(offset, axis1=axis1, axis2=axis2)
         shape = d.shape
         if dtype is None:
@@ -2873,7 +2810,7 @@ class Tensor(Tensor_):
         i = tensor_operator_registry.get('fill')(mstype.int32, shape, 0)
         j = tensor_operator_registry.get('fill')(mstype.int32, shape, a.size)
 
-        sort_range = tuple(range(validator.get_log2_size(tensor_operator_registry.get('shape_mul')(a.shape) + 1)))
+        sort_range = tuple(range(math.ceil(math.log2(tensor_operator_registry.get('shape_mul')(a.shape) + 1))))
         for _ in sort_range:
             mid = (i - -j) // 2
             mask = less_op(v, tensor_operator_registry.get('gather_nd')(a, mid.reshape(mid.shape + (1,))))
@@ -2886,16 +2823,17 @@ class Tensor(Tensor_):
         For details, please refer to :func:`mindspore.ops.gather_nd`.
         """
         self._init_check()
-        validator.check_value_type('indices', indices, (Tensor_,), 'Tensor.gather_nd')
+        validator.check_value_type('indices', indices, (Tensor, Tensor_,), 'Tensor.gather_nd')
         return tensor_operator_registry.get('gather_nd')(self, indices)
 
-    def gather(self, input_indices, axis):
+    def gather(self, input_indices, axis, batch_dims=0):
         r"""
         For details, please refer to :func:`mindspore.ops.gather`.
         """
         self._init_check()
         validator.check_is_int(axis, 'axis')
-        return tensor_operator_registry.get('gather')(self, input_indices, axis)
+        validator.check_is_int(batch_dims, "batch_dims")
+        return tensor_operator_registry.get('gather')(self, input_indices, axis, batch_dims)
 
     def var(self, axis=None, ddof=0, keepdims=False):
         """
@@ -3038,6 +2976,55 @@ class Tensor(Tensor_):
             res += initial
         return res.astype(dtype)
 
+    def sum_to_size(self, *size):
+        r"""
+        Sum self Tensor to the `size`. `size` must be expandable to the Tensor size.
+
+        Args:
+            size (Union[tuple(int), int]): The expected shape of output Tensor.
+
+        Returns:
+            Tensor, the sum result of self Tensor according to the `size`.
+
+        Raises:
+            ValueError: If `size` is not expandable to the size of self Tensor.
+
+        Supported Platforms:
+            ``Ascend`` ``GPU`` ``CPU``
+
+        Examples:
+            >>> x = Tensor(np.random.randn(3, 3, 3, 3, 3, 3), mindspore.float32)
+            >>> output = x.sum_to_size((1, 3, 1, 3))
+            >>> print(output.shape)
+            (1, 3, 1, 3)
+        """
+        self._init_check()
+        x = self
+        if len(size) == 1 and isinstance(size[0], tuple):
+            size = size[0]
+        shape_x = x.shape
+        if len(size) > x.ndim:
+            raise ValueError(f"For sum_to_size, size {size} is not expandable to the tensor size {shape_x}.")
+        if len(size) < x.ndim:
+            pre_axis = tuple([axis for axis in range(x.ndim - len(size))])
+            x = x.sum(pre_axis)
+        axes = []
+        for i, element in enumerate(size):
+            if element != x.shape[i] and element == 1:
+                axes.append(i)
+            elif element != x.shape[i]:
+                raise ValueError(f"For sum_to_size, size {size} is not expandable to the tensor size {shape_x}.")
+        if axes:
+            return x.sum(tuple(axes), keepdims=True)
+        return x
+
+    def nansum(self, axis=None, keepdims=False, dtype=None):
+        """
+        For details, please refer to :func:`mindspore.ops.nansum`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('nansum')(self, axis=axis, keepdims=keepdims, dtype=dtype)
+
     def repeat(self, repeats, axis=None):
         """
         Repeat elements of a tensor.
@@ -3105,7 +3092,7 @@ class Tensor(Tensor_):
             raise ValueError(f"For 'Tensor.repeat', the length of 'repeats' must be the same as the shape of the "
                              f"original tensor in the 'axis' dimension, but got the length of 'repeats' "
                              f"{len(repeats)}, the shape of the original tensor in the 'axis' dimension {size}.")
-        subs = tensor_operator_registry.get('split')(axis, size)(input_x)
+        subs = tensor_operator_registry.get('tensor_split')(input_x, size, axis)
         repeated_subs = []
         for sub, rep in zip(subs, repeats):
             if rep != 0:
@@ -3117,10 +3104,9 @@ class Tensor(Tensor_):
         For details, please refer to :func:`mindspore.ops.repeat_interleave`.
         """
         self._init_check()
-        dim = dim if dim is not None else 0
         return tensor_operator_registry.get('repeat_interleave')(self, repeats, dim)
 
-    def bernoulli(self, p=0.5, seed=-1):
+    def bernoulli(self, p=0.5, seed=None):
         r"""
         For details, please refer to :func:`mindspore.ops.bernoulli`.
         """
@@ -3128,278 +3114,44 @@ class Tensor(Tensor_):
         validator.check_is_int(seed, 'seed')
         return tensor_operator_registry.get('bernoulli')(self, p, seed)
 
-    def multinomial(self, num_samples, seed=0, seed2=0):
+    def random_categorical(self, num_sample, seed=0, dtype=mstype.int64):
         r"""
-        Returns a tensor sampled from the multinomial probability distribution located in the corresponding
-        row of tensor input.
-
-        Note:
-            The rows of input do not need to sum to one (in which case we use the values as weights),
-            but must be non-negative, finite and have a non-zero sum. self must be the input tensor
-            containing the cumsum of probabilities, must be 1 or 2 dimensions.
-
-        Args:
-            seed (int): Random seed, must be non-negative. Default: 0.
-            seed2 (int): Random seed2, must be non-negative. Default: 0.
-
-        Inputs:
-            - **num_samples** (int32) - number of samples to draw.
-
-        Outputs:
-            Tensor with the same rows as `self`, each row has num_samples sampled indices.
-
-        Raises:
-            TypeError: If neither `seed` nor `seed2` is an int.
-            TypeError: If `self` is not a Tensor whose dtype is float32.
-            TypeError: If dtype of `num_samples` is not int32.
+        For details, please refer to :func:`mindspore.ops.random_categorical`.
+        """
+        self._init_check()
+        validator.check_is_int(num_sample, 'num_sample')
+        validator.check_is_int(seed, 'seed')
+        return tensor_operator_registry.get('random_categorical')(self, num_sample, seed, dtype)
 
-        Supported Platforms:
-            ``GPU``
+    def masked_select(self, mask):
+        """
+        For details, please refer to :func:`mindspore.ops.masked_select`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('masked_select')(self, mask)
 
-        Examples:
-            >>> from mindspore import Tensor
-            >>> import mindspore
-            >>> x = Tensor([0., 9., 4., 0.], mindspore.float32)
-            >>> output = x.multinomial(num_samples=2,seed=10)
-            >>> print(output)
-            [2 1]
+    def gather_elements(self, dim, index):
+        """
+        For details, please refer to :func:`mindspore.ops.gather_elements`.
         """
         self._init_check()
-        validator.check_non_negative_int(seed, 'seed')
-        validator.check_non_negative_int(seed2, 'seed')
-        return tensor_operator_registry.get('multinomial')(seed, seed2)(self, num_samples)
+        validator.check_value_type('index', index, (Tensor, Tensor_,), 'Tensor.gather_elements')
+        return tensor_operator_registry.get('gather_elements')(self, dim, index)
 
-    def rand_like(self, seed=None):
-        r"""
-        Returns a tensor with the same size as input that is filled with
-        random numbers from a uniform distribution on the interval [0, 1)
+    def nonzero(self):
+        """
+        For details, please refer to :func:`mindspore.ops.nonzero`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('nonzero')(self)
 
-        Args:
-            input_tensor (Union[Tensor, int, float]): the input tensor.
-            seed (int, option): set the random seed (0 to 2**32).
-
-        Returns:
-            out (Union[Tensor, float]), with the same shape as input_tensor.
-
-        Raises:
-            TypeError: If dtype of the input_tensor is not int or float.
-
-        Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
-
-        Examples:
-            >>> import mindspore
-            >>> import numpy as np
-            >>> from mindspore import Tensor
-            >>> input_x = Tensor(np.array([[1, 2, 3, 9], [1, 2, 3, 9]]), mindspore.int8)
-            >>> output = input_x.rand_like(seed = 0)
-            >>> print(output)
-                [[0.5488135  0.71518937 0.60276338 0.54488318]
-                [0.4236548  0.64589411 0.43758721 0.891773  ]]
-            >>> input_p = Tensor(np.array([1.0, 2.0, 3.0]), mindspore.float32)
-            >>> output = input_p.rand_like(seed = 0)
-            >>> print(output)
-                [0.5488135  0.71518937 0.60276338]
-        """
-        input_tensor = self
-        input_tensor = np.array(input_tensor)
-        shape_ = input_tensor.shape
-        input_tensor = input_tensor.reshape(-1)
-        x = len(input_tensor)
-        np.random.seed(seed)
-        return Tensor(np.array([np.random.rand(1) for i in range(x)]).reshape(shape_))
-
-    def randint_like(self, high, low=0, seed=None):
-        r"""
-        Returns a tensor with the same size as the input tensor,
-        and the numerical value is a random number on the interval [low, high],
-        if only one int type data is entered, the default value is high,
-        if two integers are entered, they are low and high respectively.
-
-        Args:
-            input_tensor (Union[Tensor, int, float]): the size of input will determine size of the output tensor.
-            low (int, optional) – Lowest integer to be drawn from the distribution. Default: 0.
-            high (int) – One above the highest integer to be drawn from the distribution.
-            seed (int, optional): set the random seed (0 to 2**32).
-
-        Returns:
-            out (Union[Tensor, int]), with the same shape as input_tensor.
-
-        Raises:
-            TypeError: If dtype of the input_tensor is not int or float.
-
-        Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
-
-        Examples:
-            >>> import mindspore
-            >>> import numpy as np
-            >>> from mindspore import Tensor
-            >>> input_x = Tensor(np.array([1., 2., 3., 4., 5.]), mindspore.float32)
-            >>> output = input_x.randint_like(20, seed = 0)
-            >>> print(output)
-                [12 15  0  3  3]
-            >>> output = input_x.randint_like(20, 100, seed = 0)
-            >>> print(output)
-                [64 67 84 87 87]
-        """
-        input_tensor = self
-        input_tensor = np.array(input_tensor)
-        shape_ = input_tensor.shape
-        input_tensor = input_tensor.reshape(-1)
-        if low > high:
-            high, low = low, high
-        x = len(input_tensor)
-        np.random.seed(seed)
-        return Tensor(np.array([np.random.randint(low, high) for i in range(x)]).reshape(shape_))
-
-    def randn_like(self, seed=None):
-        r"""
-        Returns a tensor with the same size as input that is filled with random
-        numbers from a normal distribution with mean 0 and variance 1.
-
-        Args:
-            input_tensor (Union[Tensor, int, float]): the size of input will determine size of the output tensor.
-            seed (int, optional): set the random seed (0 to 2**32).
-
-        Returns:
-            out (Union[Tensor, int]), with the same shape as input_tensor.
-
-        Raises:
-            TypeError: If dtype of the input_tensor is not int or float.
-
-        Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
-
-        Examples:
-            >>> import mindspore
-            >>> import numpy as np
-            >>> from mindspore import Tensor
-            >>> input_x = Tensor(np.array([1., 2., 3., 4., 5.]), mindspore.float32)
-            >>> output = input_x.randn_like(seed = 0)
-            >>> print(output)
-                [1.7640524 0.4001572 0.978738  2.2408931 1.867558 ]
-            >>> input_p = Tensor(np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]), mindspore.int32)
-            >>> output = input_p.randn_like(seed = 0)
-            >>> print(output)
-                [[ 1.7640524   0.4001572   0.978738    2.2408931   1.867558  ]
-                [-0.9772779   0.95008844 -0.1513572  -0.10321885  0.41059852]]
-        """
-        input_tensor = np.array(self)
-        shape_ = input_tensor.shape
-        input_tensor = input_tensor.reshape(-1)
-        x = len(input_tensor)
-        np.random.seed(seed)
-        return Tensor([np.random.randn() for i in range(x)]).reshape(shape_)
-
-    def as_strided(self, shape=None, strides=None, subok=False, writeable=True):
-        r"""
-        as_strided(input, size, stride, storage_offset=0) -> Tensor
-        Create a view of an existing `mindspore.Tensor` :attr:`x` with specified
-        :attr:`shape`, :attr:`stride` and :attr:`subok`.
-
-        Args:
-            x (Tensor): the input tensor.
-            shape (tuple or ints): the shape of the output tensor
-            stride (tuple or ints): the stride of the output tensor
-            subok (int, optional): the offset in the underlying storage of the output tensor
-
-        Returns:
-            Tensor viewed by strides and subok.
-
-        Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
-
-        Examples:
-            >>> import numpy as np
-            >>> from mindspore import Tensor
-            >>> X = np.arange(9, dtype=np.int32).reshape(3,3)
-            >>> output = Tensor(X).as_strided((2, 2), (1, 1))
-            >>> print(output)
-            [[0 1]
-             [1 2]]
-        """
-        dtype_ = self.dtype
-        x = self.asnumpy()
-        n = x.strides[1]
-        strides = tuple(np.array(strides) * n)
-        return Tensor(np.lib.stride_tricks.as_strided(x, shape, strides, subok, writeable), dtype=dtype_)
-
-    def randperm(self, max_length=1, pad=-1):
-        r"""
-        Generates n random samples from 0 to n-1 without repeating. If `max_length` > n,
-        the last `max_length-n` elements will be filled with `pad`.
-
-        Args:
-            max_length (int): Number of items expected to get and the number must be greater than 0. Default: 1.
-            pad (int): The pad value to be filled. Default: -1.
-            dtype (mindspore.dtype): The type of output. Default: mindspore.int32.
-
-        Inputs:
-            - **n** (Tensor[int32]) - The input tensor with shape: (1,) and the number must be in [0, `max_length`].
-
-        Outputs:
-            - **output** (Tensor) - The output Tensor with shape: (`max_length`,) and type: `dtype`.
-
-        Raises:
-            TypeError: If neither `max_length` nor `pad` is an int.
-            TypeError: If `self` has non-Int elements.
-            TypeError: If `self` has negative elements.
-
-        Supported Platforms:
-            ``Ascend`` ``GPU``
-
-        Examples:
-            >>> # The result of every execution is different because this operator will generate n random samples.
-            >>> from mindspore import Tensor
-            >>> import mindspore
-            >>> n = Tensor([20], dtype=mindspore.int32)
-            >>> output = n.randperm(max_length=30, pad=-1)
-            >>> print(output)
-            [15 6 11 19 14 16 9 5 13 18 4 10 8 0 17 2 1 12 3 7
-                -1 -1 -1 -1 -1 -1 -1 -1 -1 -1]
-        """
-        self._init_check()
-        return tensor_operator_registry.get('randperm')(max_length, pad)(self)
-
-    def random_categorical(self, num_sample, seed=0, dtype=mstype.int64):
-        r"""
-        For details, please refer to :func:`mindspore.ops.random_categorical`.
-        """
-        self._init_check()
-        validator.check_is_int(num_sample, 'num_sample')
-        validator.check_is_int(seed, 'seed')
-        return tensor_operator_registry.get('random_categorical')(self, num_sample, seed, dtype)
-
-    def masked_select(self, mask):
-        """
-        For details, please refer to :func:`mindspore.ops.masked_select`.
-        """
-        self._init_check()
-        return tensor_operator_registry.get('masked_select')(self, mask)
-
-    def gather_elements(self, dim, index):
-        """
-        For details, please refer to :func:`mindspore.ops.gather_elements`.
-        """
-        self._init_check()
-        validator.check_value_type('index', index, (Tensor_,), 'Tensor.gather_elements')
-        return tensor_operator_registry.get('gather_elements')(self, dim, index)
-
-    def nonzero(self):
-        """
-        For details, please refer to :func:`mindspore.ops.nonzero`.
-        """
-        self._init_check()
-        return tensor_operator_registry.get('nonzero')(self)
-
-    def svd(self, full_matrices=False, compute_uv=True):
-        """
-        For details, please refer to :func:`mindspore.ops.svd`.
-        """
-        svd_op = tensor_operator_registry.get("svd")
-        if compute_uv:
-            return svd_op(full_matrices, compute_uv)(self)
+    def svd(self, full_matrices=False, compute_uv=True):
+        """
+        For details, please refer to :func:`mindspore.ops.svd`.
+        """
+        svd_op = tensor_operator_registry.get("svd")
+        if compute_uv:
+            return svd_op(full_matrices, compute_uv)(self)
 
         s, _, _ = svd_op(full_matrices, compute_uv)(self)
         return s
@@ -3418,7 +3170,6 @@ class Tensor(Tensor_):
         self._init_check()
         return tensor_operator_registry.get('heaviside')(self, values)
 
-
     def hypot(self, other):
         r"""
         For details, please refer to :func:`mindspore.ops.hypot`.
@@ -3431,7 +3182,21 @@ class Tensor(Tensor_):
         For details, please refer to :func:`mindspore.ops.soft_shrink`.
         """
         self._init_check()
-        return tensor_operator_registry.get('soft_shrink')(lambd)(self)
+        return tensor_operator_registry.get('soft_shrink')(self, lambd)
+
+    def matrix_determinant(self):
+        r"""
+        For details, please refer to :func:`mindspore.ops.matrix_determinant`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('matrix_determinant')(self)
+
+    def log_matrix_determinant(self):
+        r"""
+        For details, please refer to :func:`mindspore.ops.log_matrix_determinant`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('log_matrix_determinant')(self)
 
     def to_coo(self):
         """
@@ -3556,6 +3321,13 @@ class Tensor(Tensor_):
         self._init_check()
         return tensor_operator_registry.get('diag')()(self)
 
+    def diagflat(self, offset=0):
+        r"""
+        For details, please refer to :func:`mindspore.ops.diagflat`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('diagflat')(self, offset)
+
     def xdivy(self, y):
         r"""
         For details, please refer to :func:`mindspore.ops.xdivy`.
@@ -3563,11 +3335,40 @@ class Tensor(Tensor_):
         self._init_check()
         return tensor_operator_registry.get("xdivy")()(self, y)
 
-    def split(self, axis=0, output_num=1):
+    def split(self, split_size_or_sections, axis=0):
         """
         For details, please refer to :func:`mindspore.ops.split`.
         """
-        return tensor_operator_registry.get('split')(axis, output_num)(self)
+        return tensor_operator_registry.get('split')(self, split_size_or_sections, axis)
+
+    def tensor_split(self, indices_or_sections, axis=0):
+        """
+        For details, please refer to :func:`mindspore.ops.tensor_split`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('tensor_split')(self, indices_or_sections, axis)
+
+    def vsplit(self, indices_or_sections):
+        """
+        For details, please refer to :func:`mindspore.ops.vsplit`.
+        """
+
+        self._init_check()
+        return tensor_operator_registry.get('vsplit')(self, indices_or_sections)
+
+    def hsplit(self, indices_or_sections):
+        """
+        For details, please refer to :func:`mindspore.ops.hsplit`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('hsplit')(self, indices_or_sections)
+
+    def dsplit(self, indices_or_sections):
+        """
+        For details, please refer to :func:`mindspore.ops.dsplit`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('dsplit')(self, indices_or_sections)
 
     def xlogy(self, y):
         r"""
@@ -3593,9 +3394,16 @@ class Tensor(Tensor_):
         """
         return tensor_operator_registry.get('tile')()(self, multiples)
 
+    def topk(self, k, dim=None, largest=True, sorted=True):
+        r"""
+        For details, please refer to :func:`mindspore.ops.topk`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get("topk")(self, k, dim, largest, sorted)
+
     def top_k(self, k, sorted=True):
         r"""
-        For details, please refer to :func:`mindspore.ops.top_k`.
+        `Tensor.top_k` is deprecated, please use `Tensor.topk` instead.
         """
         self._init_check()
         validator.check_is_int(k, 'k')
@@ -3603,7 +3411,7 @@ class Tensor(Tensor_):
         return tensor_operator_registry.get("top_k")(sorted)(self, k)
 
     def sigmoid(self):
-        """
+        r"""
         For details, please refer to :func:`mindspore.ops.sigmoid`.
         """
         return tensor_operator_registry.get("sigmoid")()(self)
@@ -3618,47 +3426,10 @@ class Tensor(Tensor_):
 
     def addmv(self, mat, vec, beta=1, alpha=1):
         r"""
-        Multiplies matrix `mat` and vector `vec`. Input vector is added to the final result.
-
-        If `mat` is a :math:`(N, M)` tensor, `vec` is a 1-D tensor of size :math:`M`, then `x` must be broadcastable
-        with a 1-D tensor of size :math:`N` and `out` will be 1-D tensor of size :math:`N`.
-
-        The optional values `beta` and `alpha` are the matrix-vector product between `mat` and `vec` and the scale
-        factor for the added tensor `x` respectively. If `beta` is 0, then `x` will be ignored.
-
-        .. math::
-            output = β x + α (mat @ vec)
-
-        Args:
-            mat (Tensor): The first tensor to be multiplied. The shape of the tensor is :math:`(N, M)`.
-            vec (Tensor): The second tensor to be multiplied. The shape of the tensor is :math:`(M,)`.
-            beta (scalar[int, float, bool], optional): Multiplier for `x` (β). The `beta` must be int or
-                float or bool, Default: 1.
-            alpha (scalar[int, float, bool], optional): Multiplier for `mat` @ `vec` (α). The `alpha` must
-                be int or float or bool, Default: 1.
-
-        Returns:
-            Tensor, the shape of the output tensor is :math:`(N,)`, has the same dtype as `x`.
-
-        Raises:
-            TypeError: If `mat`, `vec`, `x` is not a Tensor.
-            TypeError: If input tensor and `x`, `mat`, 'vec' are not the same dtype.
-            ValueError: If `mat` is not a 2-D Tensor.
-                If `x`, `vec` is not a 1-D Tensor.
-
-        Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
-
-        Examples:
-            >>> x = Tensor(np.array([2., 3.]).astype(np.float32))
-            >>> mat = Tensor(np.array([[2., 5., 3.], [4., 2., 2.]]).astype(np.float32))
-            >>> vec = Tensor(np.array([3., 2., 4.]).astype(np.float32))
-            >>> output = x.addmv(mat, vec)
-            >>> print(output)
-            [30. 27.]
+        For details, please refer to :func:`mindspore.ops.addmv`.
         """
         self._init_check()
-        return tensor_operator_registry.get('addmv')(self, mat, vec, beta=1, alpha=1)
+        return tensor_operator_registry.get('addmv')(self, mat, vec, beta=beta, alpha=alpha)
 
     def asinh(self):
         r"""
@@ -3671,7 +3442,8 @@ class Tensor(Tensor_):
         r"""
         Alias for :func:`mindspore.Tensor.asinh`.
         """
-        return self.asinh()
+        self._init_check()
+        return tensor_operator_registry.get('arcsinh')(self)
 
     def atan(self):
         r"""
@@ -3691,7 +3463,8 @@ class Tensor(Tensor_):
         r"""
         Alias for :func:`mindspore.Tensor.atanh`.
         """
-        return self.atanh()
+        self._init_check()
+        return tensor_operator_registry.get('arctanh')(self)
 
     def bmm(self, mat2):
         r"""
@@ -3705,7 +3478,7 @@ class Tensor(Tensor_):
         Performs tensor dtype conversion.
 
         Args:
-            dtype (dtype.Number): The valid data type of the output tensor. Only constant value is allowed.
+            dtype (Number): The valid data type of the output tensor. Only constant value is allowed.
 
         Returns:
             Tensor, converted to the specified `dtype`.
@@ -3937,19 +3710,19 @@ class Tensor(Tensor_):
         self._init_check()
         return tensor_operator_registry.get('multiply')(self, value)
 
-    def div(self, other, rounding_mode=None):
+    def div(self, value, *, rounding_mode=None):
         r"""
         For details, please refer to :func:`mindspore.ops.div`.
         """
         self._init_check()
-        return tensor_operator_registry.get('div')(self, other, rounding_mode)
+        return tensor_operator_registry.get('div')(self, value, rounding_mode=rounding_mode)
 
-    def divide(self, other, *, rounding_mode=None):
+    def divide(self, value, *, rounding_mode=None):
         r"""
-        For details, please refer to :func:`mindspore.ops.div`.
+        Alias for :func:`mindspore.Tensor.div`.
         """
         self._init_check()
-        return tensor_operator_registry.get('div')(self, other, rounding_mode)
+        return tensor_operator_registry.get('div')(self, value, rounding_mode=rounding_mode)
 
     def equal(self, other):
         r"""
@@ -4078,6 +3851,12 @@ class Tensor(Tensor_):
         self._init_check()
         return tensor_operator_registry.get('less')(self, other)
 
+    def lt(self, other):
+        """
+        Alias for :func:`mindspore.Tensor.less`.
+        """
+        return self.less(other)
+
     def logical_and(self, other):
         r"""
         For details, please refer to :func:`mindspore.ops.logical_and`.
@@ -4108,354 +3887,256 @@ class Tensor(Tensor_):
 
     def lstsq(self, A):
         r"""
-        Computes the solutions of the least squares and minimum norm problems of full-rank
-        matrix `x` of size :math:`(m \times n)` and matrix `a` of size :math:`(m \times k)`.
-
-        If :math:`m \geq n`, `lstsq` solves the least-squares problem:
-
-        .. math::
-
-           \begin{array}{ll}
-           \min_y & \|xy-a\|_2.
-           \end{array}
-
-        If :math:`m < n`, `lstsq` solves the least-norm problem:
-
-        .. math::
-
-           \begin{array}{llll}
-           \min_y & \|y\|_2 & \text{subject to} & xy = a.
-           \end{array}
-
-        Args:
-            A (Tensor) - The m by k matrix equivalent to `a` in above.
-                The input tensor whose data type is float16, float32 or float64.
-
-        Returns:
-            Tensor, the least squares or minimum norm problems solution, which has shape :math:`(n \times k)`.
-            The data type is the same with `input`.
-
-        Raises:
-            TypeError: If `A` is not a Tensor.
-            TypeError: If dtype of input tensor or `A` is not one of: float16, float32, float64.
-            TypeError: If the dtypes of input tensor and `A` are not the same.
-            ValueError: If the dimension of input tensor is not equal to 2.
-            ValueError: If the dimension of `A` is not equal to 2 or 1.
-            ValueError: If the length of input_dims[0] is not equal to the length of A_dims[0].
-
-        Supported Platforms:
-            ``CPU``
-
-        Examples:
-            >>> x = Tensor(np.array([[2,1,5],[3,5,1],[1,1,1]]),mindspore.float32)
-            >>> a = Tensor(np.array([[10,5],[15,8],[7,4]]),mindspore.float32)
-            >>> output = x.lstsq(a)
-            >>> print(output)
-            [[17.000002  11.000002 ]
-             [-6.5000005 -4.500001 ]
-             [-3.500002  -2.5000017]]
+        For details, please refer to :func:`mindspore.ops.lstsq`.
         """
         self._init_check()
         return tensor_operator_registry.get('lstsq')(self, A)
 
-    def mvlgamma(self, p):
+    @property
+    def mH(self):
         r"""
-        Computes the multivariate log-gamma function with dimension p element-wise.
-
-        The following tex shows the mathematical calculation process of Mvlgamma:
-
-        .. math::
-
-            \log (\Gamma_{p}(a))=C+\sum_{i=1}^{p} \log (\Gamma(a-\frac{i-1}{2}))
-
-        where :math:`C = \log(\pi) \times \frac{p(p-1)}{4}` and :math:`\Gamma(\cdot)` is the Gamma function.
-
-        Args:
-            p (int): The number of dimensions. And the value of `p` must be greater than or equal to 1.
-
-        Returns:
-            Tensor, has the same shape and type as input tensor.
-
-        Raises:
-            TypeError: If dtype of input tensor is neither float32 nor float64.
-            TypeError: If `p` is not an int.
-            ValueError: If `p` is not greater than or equal to 1.
-            ValueError: If all elements of input tensor are not greater than (p-1)/2.
+        Accessing this property is equivalent to Calling self.adjoint().
+        For details, please refer to :func:`mindspore.ops.adjoint`.
+        """
+        return self.adjoint()
 
-        Supported Platforms:
-            ``CPU`` ``GPU``
+    @property
+    def mT(self):
+        r"""
+        Returns the Tensor that exchanges the last two dimensions.
+        Accessing the attribute, x.mT, is equal to calling the method, x.swapaxes(-2, -1).
+        For details, please refer to :func:`mindspore.Tensor.swapaxes`.
+        """
+        return self.swapaxes(-2, -1)
 
-        Examples:
-            >>> x = Tensor(np.array([[3, 4, 5], [4, 2, 6]]), mindspore.float32)
-            >>> y = x.mvlgamma(p=3)
-            >>> print(y)
-            [[2.694925 5.402975 9.140645]
-             [5.402975 1.596312 13.64045]]
+    def mvlgamma(self, p):
+        r"""
+        For details, please refer to :func:`mindspore.ops.mvlgamma`.
         """
         self._init_check()
         return tensor_operator_registry.get('mvlgamma')(self, p)
 
     def matmul(self, tensor2):
         r"""
-        Returns the matrix product of two tensors.
-
-        Note:
-            Numpy arguments `out`, `casting`, `order`, `subok`, `signature`, and `extobj` are
-            not supported.
-            On CPU, the supported dtypes are np.float16 and np.float32.
-            On GPU, the supported dtypes are np.float16 and np.float32.
-
-        Args:
-            tensor2 (Tensor): Second input tensor, scalar not allowed.
-              The last dimension of input tensor must be the same size as the second last dimension of `tensor2`.
-              And the shape of input tensor and tensor2 could be broadcast.
-
-        Returns:
-            Tensor or scalar, the matrix product of the inputs. This is a scalar only
-            when both input tensor, `tensor2` are 1-d vectors.
-
-        Raises:
-            ValueError: If the last dimension of input tensor is not the same size as the
-                second-to-last dimension of `tensor2`, or if a scalar value is passed in.
-            ValueError: If the shape of input tensor and `tensor2` could not broadcast together.
-
-        Supported Platforms:
-            ``Ascend`` ``CPU`` ``GPU``
-
-        Examples:
-            >>> x = Tensor(np.arange(2*3*4).reshape(2, 3, 4), mindspore.float32)
-            >>> y = Tensor(np.arange(4*5).reshape(4, 5), mindspore.float32)
-            >>> output = x.matmul(y)
-            >>> print(output)
-            [[[  70.   76.   82.   88.   94.]
-            [ 190.  212.  234.  256.  278.]
-            [ 310.  348.  386.  424.  462.]]
-            [[ 430.  484.  538.  592.  646.]
-            [ 550.  620.  690.  760.  830.]
-            [ 670.  756.  842.  928. 1014.]]]
+        For details, please refer to :func:`mindspore.ops.matmul`.
         """
         self._init_check()
         return tensor_operator_registry.get('matmul')(self, tensor2)
 
-    def maximum(self, other):
+    def inner(self, other):
         r"""
-        Computes the maximum of input tensors element-wise.
-
-        Note:
-            - Inputs of `input` and `other` comply with the implicit type conversion rules to make the data
-              types consistent.
-            - The inputs must be two tensors or one tensor and one scalar.
-            - When the inputs are two tensors,
-              dtypes of them cannot be bool at the same time, and the shapes of them could be broadcast.
-            - When the inputs are one tensor and one scalar,
-              the scalar could only be a constant.
-            - Broadcasting is supported.
-            - If one of the elements being compared is a NaN, then that element is returned.
-
-        .. math::
-            output_i = max(input_i, other_i)
-
-        Args:
-            other (Union[Tensor, Number, bool]): The second input is a number or
-                a bool when the first input is a tensor or a tensor whose data type is number or bool.
-
-        Returns:
-            Tensor, the shape is the same as the one after broadcasting,
-            and the data type is the one with higher precision or higher digits among the two inputs.
+        For details, please refer to :func:`mindspore.ops.inner`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('inner')(self, other)
 
-        Raises:
-            TypeError: If `input` and `other` is not one of the following: Tensor, Number, bool.
-            ValueError: If `input` and `other` are not the same shape.
+    def multinomial(self, num_samples, replacement=True, seed=None):
+        r"""
+        For details, please refer to :func:`mindspore.ops.multinomial`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('multinomial')(self, num_samples, replacement, seed)
 
-        Supported Platforms:
-            ``Ascend`` ``CPU`` ``GPU``
+    def matrix_power(self, n):
+        r"""
+        For details, please refer to :func:`mindspore.ops.matrix_power`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('matrix_power')(self, n)
 
-        Examples:
-            >>> x = Tensor(np.array([1.0, 5.0, 3.0]), mindspore.float32)
-            >>> y = Tensor(np.array([4.0, 2.0, 6.0]), mindspore.float32)
-            >>> output = x.maximum(y)
-            >>> print(output)
-            [4. 5. 6.]
+    def maximum(self, other):
+        r"""
+        For details, please refer to :func:`mindspore.ops.maximum`.
         """
         self._init_check()
         return tensor_operator_registry.get('maximum')(self, other)
 
-    def mul(self, value):
+    def mm(self, mat2):
         r"""
-        Multiplies two tensors element-wise.
-
-        .. note::
-            - Inputs of input tensor and `value` comply with the implicit type conversion rules to make
-              the data types consistent.
-            - The inputs must be two tensors or one tensor and one scalar.
-            - When the inputs are two tensors,
-              dtypes of them cannot be bool at the same time, and the shapes of them can be broadcast.
-            - When the inputs are one tensor and one scalar, the scalar could only be a constant.
-
-        Args:
-            value (Union[Tensor, number.Number, bool]): The second input, when the first input is a Tensor,
-                the second input should be a number.Number or bool value, or a Tensor whose data type is number
-                or bool\_. When the first input is Scalar, the second input must be a Tensor whose data type is
-                number or bool\_.
-
-        Returns:
-            Tensor, the shape is the same as the one after broadcasting,
-            and the data type is the one with higher precision or higher digits among the two inputs.
-
-        Raises:
-            TypeError: If input tensor and `value` is not one of the following: Tensor, number.Number, bool.
-            ValueError: If input tensor and `value` are not the same shape.
+        For details, please refer to :func:`mindspore.ops.mm`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('mm')(self, mat2)
 
-        Supported Platforms:
-            ``Ascend`` ``CPU`` ``GPU``
+    def msort(self):
+        r"""
+        For details, please refer to :func:`mindspore.ops.msort`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('msort')(self)
 
-        Examples:
-            >>> x = Tensor(np.array([1.0, 2.0, 3.0]), mindspore.float32)
-            >>> y = Tensor(np.array([4.0, 5.0, 6.0]), mindspore.float32)
-            >>> output = x.mul(y)
-            >>> print(output)
-            [ 4. 10. 18.]
+    def mul(self, value):
+        r"""
+        For details, please refer to :func:`mindspore.ops.mul`.
         """
         self._init_check()
         return tensor_operator_registry.get('mul')(self, value)
 
+    def nan_to_num(self, nan=0.0, posinf=None, neginf=None):
+        """
+        For details, please refer to :func:`mindspore.ops.nan_to_num`.
+        """
+        return tensor_operator_registry.get('nan_to_num')(self, nan, posinf, neginf)
+
     def neg(self):
         r"""
-        Returns a tensor with negative values of the input tensor element-wise.
-
-        .. math::
-
-            out_{i} = - x_{i}
-
-        Returns:
-            Tensor, has the same shape and dtype as input.
-
-        Supported Platforms:
-            ``Ascend`` ``CPU`` ``GPU``
-
-        Examples:
-            >>> x = Tensor(np.array([1, 2, -1, 2, 0, -3.5]), mindspore.float32)
-            >>> output = x.neg()
-            >>> print(output)
-            [-1.  -2.   1.  -2.   0.   3.5]
+        For details, please refer to :func:`mindspore.ops.neg`.
         """
         self._init_check()
         return tensor_operator_registry.get('neg')(self)
 
     def ne(self, other):
         r"""
-        Computes the non-equivalence of two tensors element-wise.
+        For details, please refer to :func:`mindspore.ops.ne`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('ne')(self, other)
 
-        Note:
-            - Input tensor and `other` comply with the implicit type conversion rules to make the data
-              types consistent.
-            - The inputs must be two tensors or one tensor and one scalar.
-            - When the inputs are two tensors, the shapes of them could be broadcast.
-            - When the inputs are one tensor and one scalar, the scalar could only be a constant.
-            - Broadcasting is supported.
+    def not_equal(self, other):
+        r"""
+        For details, please refer to :func:`mindspore.ops.not_equal`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('not_equal')(self, other)
+
+    def new_zeros(self, size, *, dtype=None):
+        r"""
+        Return a tensor of `size` filled with zeros.
 
         Args:
-            other (Union[Tensor, Number, bool]): The second input is a number or
-                a bool when the first input is a tensor or a tensor whose data type is number or bool.
+            size (Union[int, tuple, list]): An int, list or tuple of integers defining the output shape.
+
+        Keyword Args:
+            dtype (mindspore.dtype, optional): The desired dtype of the output tensor. If None, the returned tensor has
+                thesame dtype as `self`. Default: None.
 
         Returns:
-            Tensor, the shape is the same as the one after broadcasting,and the data type is bool.
+            Tensor, the shape and dtype is defined above and filled with zeros.
 
         Raises:
-            TypeError: If input tensor and `other` is not one of the following: Tensor, Number, bool.
-            TypeError: If neither input tensor and `other` is a Tensor.
+            TypeError: If `size` is not an int, list or tuple of integers.
 
         Supported Platforms:
-            ``Ascend`` ``CPU`` ``GPU``
+            ``Ascend`` ``GPU`` ``CPU``
 
         Examples:
             >>> x = Tensor(np.array([1, 2, 3]), mindspore.float32)
-            >>> output = x.ne(2.0)
+            >>> output = x.new_zeros((2, 2))
             >>> print(output)
-            [ True False  True]
+            [[0. 0.]
+             [0. 0.]]
         """
+        validator.check_value_type('size', size, [list, int, tuple], 'Tensor.new_zeros')
+        if isinstance(size, list):
+            size = tuple(size)
         self._init_check()
-        return tensor_operator_registry.get('ne')(self, other)
+        _dtype = self.dtype if dtype is None else dtype
+        return tensor_operator_registry.get('zeros')(size, _dtype)
 
-    def sinh(self):
+    def new_ones(self, size, *, dtype=None):
         r"""
-        Computes hyperbolic sine of the input element-wise.
+        Return a tensor of `size` filled with ones.
 
-        .. math::
+        Args:
+            size (Union[int, tuple, list]): An int, list or tuple of integers defining the output shape.
 
-            out_i = \sinh(x_i)
+        Keyword Args:
+            dtype (mindspore.dtype, optional): The desired dtype of the output tensor. If None, the returned
+                tensor has the same dtype as `self`. Default: None.
 
         Returns:
-            Tensor, has the same shape as input tensor.
+            Tensor, the shape and dtype is defined above and filled with ones.
+
+        Raises:
+            TypeError: If `size` is not an int, list or tuple of integers.
 
         Supported Platforms:
-            ``Ascend`` ``CPU`` ``GPU``
+            ``Ascend`` ``GPU`` ``CPU``
 
         Examples:
-            >>> x = Tensor(np.array([0.62, 0.28, 0.43, 0.62]), mindspore.float32)
-            >>> output = x.sinh()
+            >>> x = Tensor(np.array([1, 2, 3]), mindspore.float32)
+            >>> output = x.new_ones((2, 2))
             >>> print(output)
-            [0.6604918 0.28367308 0.44337422 0.6604918]
+            [[1. 1.]
+             [1. 1.]]
         """
+        validator.check_value_type('size', size, [list, int, tuple], 'Tensor.new_zeros')
+        if isinstance(size, list):
+            size = tuple(size)
         self._init_check()
-        return tensor_operator_registry.get('sinh')(self)
+        _dtype = self.dtype if dtype is None else dtype
+        return tensor_operator_registry.get('ones')(size, _dtype)
 
-    def sort(self, dim=-1, descending=False):
+    def sign(self):
         r"""
-        Sorts the elements of the input tensor along a given dimension in ascending order by value.
-
-        Args:
-            dim (int, optional): The dimension to sort along. Default: -1.
-            descending (bool, optional): Controls the sorting order. If descending is True, then the elements
-                are sorted in descending order by value. Default: False.
+        For details, please refer to :func:`mindspore.ops.sign`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('sign')(self)
 
-        Returns:
-            y1 (Tensor): A tensor whose values are the sorted values, with the same shape and dtype as input.
-            y2 (Tensor): The indices of the elements in the original input tensor. Tensor dtype is int32.
+    def signbit(self):
+        """
+        For details, please refer to :func:`mindspore.ops.signbit`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('signbit')(self)
 
-        Raises:
-            TypeError: If dtype of `dim` is not int.
-            TypeError: If dtype of `descending` is not bool.
-            TypeError: If dtype of input tensor is neither float16 nor float32.
-            ValueError: If `dim` is not in range of [-len(x.shape), len(x.shape)).
+    def sgn(self):
+        """
+        For details, please refer to :func:`mindspore.ops.sgn`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('sgn')(self)
 
-        Supported Platforms:
-            ``Ascend`` ``CPU`` ``GPU``
+    def sin(self):
+        r"""
+        For details, please refer to :func:`mindspore.ops.sin`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('sin')(self)
 
-        Examples:
-            >>> x = Tensor(np.array([[8, 2, 1], [5, 9, 3], [4, 6, 7]]), mindspore.float16)
-            >>> output = x.sort()
-            >>> print(output)
-            (Tensor(shape=[3, 3], dtype=Float16, value=
-            [[ 1.0000e+00,  2.0000e+00,  8.0000e+00],
-             [ 3.0000e+00,  5.0000e+00,  9.0000e+00],
-             [ 4.0000e+00,  6.0000e+00,  7.0000e+00]]), Tensor(shape=[3, 3], dtype=Int32, value=
-            [[2, 1, 0],
-             [2, 0, 1],
-             [0, 1, 2]]))
+    def sinc(self):
+        r"""
+        For details, please refer to :func:`mindspore.ops.sinc`.
         """
         self._init_check()
-        return tensor_operator_registry.get('sort')(axis=dim, descending=descending)(self)
+        return tensor_operator_registry.get('sinc')(self)
 
-    def trunc(self):
+    def sinh(self):
         r"""
-        Returns a new tensor with the truncated integer values of the elements of input.
+        For details, please refer to :func:`mindspore.ops.sinh`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('sinh')(self)
 
-        Returns:
-            Tensor, the same shape and dtype as the input.
+    def sort(self, axis=-1, descending=False):
+        r"""
+        For details, please refer to :func:`mindspore.ops.sort`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('sort')(self, axis=axis, descending=descending)
 
-        Supported Platforms:
-            ``CPU``
+    def argsort(self, axis=-1, descending=False):
+        """
+        For details, please refer to :func:`mindspore.ops.argsort`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('argsort')(self, axis, descending)
 
-        Examples:
-            >>> x = Tensor(np.array([3.4742, 0.5466, -0.8008, -3.9079]),mindspore.float32)
-            >>> output = x.trunc()
-            >>> print(output)
-            [3. 0. 0. -3.]
+    def trunc(self):
+        r"""
+        For details, please refer to :func:`mindspore.ops.trunc`.
         """
         self._init_check()
         return tensor_operator_registry.get('trunc')(self)
 
+    def where(self, condition, y):
+        r"""
+        For details, please refer to :func:`mindspore.ops.where`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('where')(condition, self, y)
+
     def imag(self):
         r"""
         Returns a new tensor containing imaginary value of the input tensor.
@@ -4465,7 +4146,7 @@ class Tensor(Tensor_):
             Tensor, the shape is the same as the input tensor.
 
         Supported Platforms:
-            ``CPU`` ``GPU``
+            ``GPU`` ``CPU``
 
         Examples:
             >>> x = Tensor(np.asarray(np.complex(1.3 + 0.4j)), mindspore.complex64)
@@ -4477,6 +4158,23 @@ class Tensor(Tensor_):
         return tensor_operator_registry.get('imag')(self)
 
 
+    def nextafter(self, other):
+        r"""
+        For details, please refer to :func:`mindspore.ops.nextafter`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('nextafter')(self, other)
+
+
+    def qr(self, some=True):
+        r"""
+        For details, please refer to :func:`mindspore.ops.qr`.
+        """
+        self._init_check()
+        validator.check_value_type('some', some, bool, 'Tensor.qr')
+        return tensor_operator_registry.get('qr')(self, 'reduced' if some else 'complete')
+
+
 def _vm_compare(*args):
     """Implement `vm_compare` for tensor."""
     obj_str = args[-1]