mindspore 2.4.10__cp310-cp310-manylinux1_x86_64.whl → 2.5.0__cp310-cp310-manylinux1_x86_64.whl

mindspore/common/tensor.py

@@ -31,14 +31,13 @@ from mindspore.common.hook_handle import _TensorHookHandle
 
 from mindspore.common._utils import get_slice_num
 from mindspore.common._register_for_tensor import tensor_operator_registry
-from mindspore.common._tensor_overload import (repeat_interleave_mint, add_mint, item_mint, isnan_mint, flatten_mint,
-                                               max_mint, mean_mint, min_mint, split_mint, sub_mint)
 from mindspore._c_expression import Tensor as Tensor_
 from mindspore import _checkparam as validator
 from mindspore._checkparam import check_is_number, is_stub_tensor, check_hook_fn
 from mindspore._check_jit_forbidden_api import jit_forbidden_register
 from mindspore.common.symbol import Symbol
 
+
 np_types = (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.complex64, np.complex128)
@@ -47,7 +46,7 @@ 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_, Tensor, np.ndarray, np.str_, list, tuple, float, int, bool, complex),
+                               (Tensor_, Tensor, np.ndarray, np.str_, list, tuple, float, int, bool, complex, bytes),
                                '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)
@@ -119,8 +118,11 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
     Tensor is a data structure that stores an n-dimensional array.
 
     Note:
-        If `init` interface is used to initialize `Tensor`, the `Tensor.init_data` API needs to be called to load the
-        actual data to `Tensor`.
+        - If `init` interface is used to initialize `Tensor`, the `Tensor.init_data` API needs to be called to load the
+          actual data to `Tensor`.
+        - All modes of CPU and GPU, and Atlas training series with `graph mode (mode=mindspore.GRAPH_MODE)
+          <https://www.mindspore.cn/docs/en/master/model_train/program_form/static_graph.html>`_  do not supported
+          in-place operations yet.
 
     Warning:
           To convert dtype of a `Tensor`, it is recommended to use `Tensor.astype()` rather than
@@ -352,12 +354,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         return out
 
     def __bool__(self):
-        data = self.asnumpy()
-        if data.shape == ():
-            return bool(data)
-        if data.shape == (1,):
-            return bool(data[0])
-        raise ValueError("The truth value of an array with more than one element is ambiguous.")
+        return bool(self._item())
 
     @staticmethod
     def _convert_scalar_(data, func, message):
@@ -385,13 +382,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
     def __pos__(self):
         return self
 
-    def __abs__(self):
-        return tensor_operator_registry.get('abs')(self)
-
-    @add_mint
-    def __add__(self, other):
-        return tensor_operator_registry.get('__add__')(self, other)
-
     def __and__(self, other):
         if isinstance(other, (int, bool, float, Tensor)):
             return tensor_operator_registry.get('bitwise_and')(self, other)
@@ -410,28 +400,15 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
     def __radd__(self, other):
         return self.__add__(other)
 
-    def __iadd__(self, other):
-        return self.__add__(other)
-
-    @sub_mint
-    def __sub__(self, other):
-        return tensor_operator_registry.get('__sub__')(self, other)
-
     def __rsub__(self, other):
         return tensor_operator_registry.get('__sub__')(other, self)
 
-    def __isub__(self, other):
-        return self.__sub__(other)
-
     def __mul__(self, other):
         return tensor_operator_registry.get('__mul__')(self, other)
 
     def __rmul__(self, other):
         return self.__mul__(other)
 
-    def __imul__(self, other):
-        return self.__mul__(other)
-
     def __matmul__(self, other):
         return tensor_operator_registry.get('__matmul__')(self, other)
 
@@ -456,9 +433,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
     def __imod__(self, other):
         return self.__mod__(other)
 
-    def __pow__(self, other):
-        return tensor_operator_registry.get('__pow__')(self, other)
-
     def __rpow__(self, other):
         return tensor_operator_registry.get('__rpow__')(self, other)
 
@@ -479,25 +453,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         out = tensor_operator_registry.get('__le__')(self, other)
         return out
 
-    def __getitem__(self, index):
-        out = tensor_operator_registry.get('__getitem__')(self, index)
-        if out is not self:
-            out.parent_tensor_ = self
-            out.index_of_parent_ = index
-        return out
-
-    def __setitem__(self, index, value):
-        out = tensor_operator_registry.get('__setitem__')(self, index, value)
-        if isinstance(out, tuple):
-            if self.parent_tensor_ is not None and self.index_of_parent_ is not None:
-                self.parent_tensor_.__setitem__(self.index_of_parent_, out[0])
-                return self
-            return self
-        self.assign_value(out)
-        if self.parent_tensor_ is not None and self.index_of_parent_ is not None:
-            self.parent_tensor_.__setitem__(self.index_of_parent_, self)
-        return self
-
     def __gt__(self, other):
         out = tensor_operator_registry.get('__gt__')(self, other)
         return out
@@ -530,10 +485,58 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             self.__dict__.update(state)
         Tensor_.__setstate__(self, value)
 
+    def __array__(self, dtype=None):
+        """support create numpy array from tensor."""
+        if dtype is None:
+            return self.asnumpy()
+        return self.asnumpy().astype(dtype, copy=False)
+
+    def __contains__(self, element):
+        """support 'in' operator."""
+        if isinstance(element, (Tensor, numbers.Number)):
+            return (element == self).any().item()
+        return False
+
+    def _getitem_origin(self, index):
+        """__getitem__ origin process, called by TensorPy::TensorGetItem"""
+        out = tensor_operator_registry.get('_tensor_getitem_origin')(self, index)
+        if out is not self:
+            out.parent_tensor_ = self
+            out.index_of_parent_ = index
+        return out
+
+    def _setitem_origin(self, index, value):
+        """__setitem__ origin process, called by TensorPy::TensorSetItem"""
+        out = tensor_operator_registry.get('_tensor_setitem_origin')(self, index, value)
+        if isinstance(out, tuple):
+            if self.parent_tensor_ is not None and self.index_of_parent_ is not None:
+                self.parent_tensor_.__setitem__(self.index_of_parent_, out[0])
+                return self
+            return self
+        self.assign_value(out)
+        if self.parent_tensor_ is not None and self.index_of_parent_ is not None:
+            self.parent_tensor_.__setitem__(self.index_of_parent_, self)
+        return self
+
+    def _getitem(self, index):
+        """__getitem__ process, called by TensorPy::TensorGetItem"""
+        return tensor_operator_registry.get('_tensor_getitem')(self, index)
+
+    def _setitem(self, index, value):
+        """__setitem__ process, called by TensorPy::TensorSetItem"""
+        return tensor_operator_registry.get('_tensor_setitem')(self, index, value)
+
     @property
     def shape(self):
         """
         For details, please refer to :func:`mindspore.ops.shape`.
+
+        Examples:
+            >>> from mindspore import Tensor
+            >>> import numpy as np
+            >>> x = Tensor(np.array([[1, 2], [3, 4]]))
+            >>> print(x.shape)
+            (2, 2)
         """
         return self._shape
 
@@ -546,7 +549,16 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
     @property
     def dtype(self):
-        """Return the dtype of the tensor (:class:`mindspore.dtype`)."""
+        """
+        Return the dtype of the tensor (:class:`mindspore.dtype`).
+
+        Examples:
+            >>> from mindspore import Tensor
+            >>> import numpy as np
+            >>> x = Tensor(np.array([1, 2], dtype=np.float32))
+            >>> print(x.dtype)
+            Float32
+        """
         return self._dtype
 
     @property
@@ -789,7 +801,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
     def ndimension(self):
         r"""
-        Alias for :func:`mindspore.Tensor.ndim`.
+        Alias for :attr:`mindspore.Tensor.ndim`.
         """
         return len(self._shape)
 
@@ -821,30 +833,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         self.const_arg = const_arg
         return self
 
-    def arccosh(self):
-        r"""
-        For details, please refer to :func:`mindspore.ops.arccosh`.
-        """
-        return tensor_operator_registry.get('acosh')(self)
-
-    def arcsin(self):
-        r"""
-        For details, please refer to :func:`mindspore.ops.arcsin`.
-        """
-        return tensor_operator_registry.get('asin')(self)
-
-    def arctan(self):
-        r"""
-        For details, please refer to :func:`mindspore.ops.arctan`.
-        """
-        return tensor_operator_registry.get('atan')(self)
-
-    def arctan2(self, other):
-        r"""
-        For details, please refer to :func:`mindspore.ops.arctan2`.
-        """
-        return tensor_operator_registry.get('atan2')(self, other)
-
     def cauchy(self, median=0.0, sigma=1.0):
         r"""
         Fills the tensor with numbers drawn from the Cauchy distribution. It is
@@ -942,31 +930,17 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         self.assign_value_cpp(value)
         return self
 
-    def bincount(self, weights=None, minlength=0):
-        r"""
-        For details, please refer to :func:`mindspore.ops.bincount`.
-        """
-        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`.
+    def item(self):
         """
-        return tensor_operator_registry.get('chunk')(self, chunks, axis)
-
-    @item_mint
-    def item(self, index=None):
-        """
-        Get the item at the specified index of the tensor.
-
-        Args:
-            index (Union[None, int, tuple(int)]): The index in Tensor. Default: ``None``.
+        Return the value of this tensor as standard Python number.
+        This only works for tensors with one element.
 
         Returns:
             A scalar, type is defined by the dtype of the Tensor.
 
         Raises:
-            ValueError: If the length of the `index` is not equal to self.ndim.
+            ValueError: If the count of value in tensor is more than one.
+            TypeError: The type of element in tensor is not supported.
 
         Supported Platforms:
             ``Ascend`` ``GPU`` ``CPU``
@@ -974,19 +948,11 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         Examples:
             >>> import mindspore as ms
             >>> from mindspore import Tensor
-            >>> x = Tensor([[1, 2, 3], [4, 5, 6]], ms.float32)
-            >>> print(x.item((0, 1)))
-            2.0
             >>> x = Tensor(1.2, ms.float32)
             >>> print(x.item())
             1.2
         """
-
-        if index is not None:
-            output = self.asnumpy().item(index)
-        else:
-            output = self.asnumpy().item()
-        return output
+        return self._item()
 
     def itemset(self, *args):
         r"""
@@ -998,7 +964,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         Args:
             args (Union[(numbers.Number), (int/tuple(int), numbers.Number)]): The arguments that
                 specify the index and value. If `args` contain one argument (a scalar),
-                it is only used in case tensor is of size 1. If `args` contain two
+                it is only used in case tensor is of size 1. If `args` contains two
                 arguments, the last argument is the value to be set and must be a
                 scalar, the first argument specifies a single tensor element location.
                 It is either an int or a tuple.
@@ -1069,7 +1035,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             self.init_data()
         return Tensor_.asnumpy(self)
 
-    def numpy(self, *, force=False):
+    def numpy(self):
         """
         Alias for :func:`mindspore.Tensor.asnumpy`.
         """
@@ -1118,14 +1084,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('select_scatter')(self, src, axis, index)
 
-    def histc(self, bins=100, min=0., max=0.):
-        """
-        For details, please refer to :func:`mindspore.ops.histc`.
-        """
-        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`.
@@ -1175,6 +1133,8 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(z.is_contiguous())
             True
         """
+        if not self._need_contiguous():
+            return self
         return tensor_operator_registry.get('contiguous')(self)
 
     def is_contiguous(self):
@@ -1236,26 +1196,33 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return Tensor_.storage_offset(self)
 
-    def register_hook(self, hook_fn):
+    def register_hook(self, hook):
         """
         Registers a backward hook for tensor.
 
         Note:
-            - The `register_backward_hook(hook_fn)` does not work in graph mode or functions decorated with 'jit'.
-            - The 'hook_fn' must be defined as the following code. `grad` is the gradient passed to the tensor,
+            - The `hook` must be defined as the following code. `grad` is the gradient passed to the tensor,
               which may be modified by returning a new output gradient.
-            - The 'hook_fn' should have the following signature:
-              hook_fn(grad) -> New output gradient, but can not return None or not set return value.
+            - The `hook` should have the following signature:
+              hook(grad) -> New output gradient, but can not return None or not set return value.
+            - The following constraints must be met under graph mode:
+
+              - The `hook` must satisfy the syntax constraints of the graph mode.
+              - Registering `hook` for `Parameter` is not supported in the graph (i.e., function `Cell.construct` or
+                function decorated by `@jit`).
+              - It is not supported to delete `hook` inside graph.
+
+              - Register `hook` in the graph will return then `Tensor` it self.
 
         Args:
-            hook_fn (function): Python function. Tensor backward hook function.
+            hook (function): Python function. Tensor backward hook function.
 
         Returns:
-            A handle corresponding to the `hook_fn` . The handle can be used to remove the added `hook_fn` by calling
+            A handle corresponding to the `hook` . The handle can be used to remove the added `hook` by calling
             `handle.remove()` .
 
         Raises:
-            TypeError: If the `hook_fn` is not a function of python.
+            TypeError: If the `hook` is not a function of python.
 
         Supported Platforms:
             ``Ascend`` ``GPU`` ``CPU``
@@ -1278,12 +1245,15 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(output)
             (Tensor(shape=[], dtype=Float32, value=8), Tensor(shape=[], dtype=Float32, value=6))
         """
-        if not check_hook_fn("register_hook", hook_fn):
-            return _TensorHookHandle()
-        handle = _TensorHookHandle()
-        handle.id = Tensor_.register_hook(self, hook_fn)
+        if not check_hook_fn("register_hook", hook):
+            return _TensorHookHandle(self)
+        handle = _TensorHookHandle(self)
+        handle.id = Tensor_.register_hook(self, hook)
         return handle
 
+    def _remove_hook(self):
+        pass
+
     def flush_from_cache(self):
         """
         Flush cache data to host if tensor is cache enable.
@@ -1310,94 +1280,12 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('addcmul')(self, tensor1, tensor2, value)
 
-    @add_mint
-    def add(self, other):
-        r"""
-        For details, please refer to :func:`mindspore.ops.add`.
-        """
-        return tensor_operator_registry.get('add')(self, other)
-
-    def add_(self, other, *, alpha=1):
-        """
-        inplace update self by following compute:
-            self = self + other * alpha.
-
-        .. warning::
-            This is an experimental API that is subject to change or deletion.
-            The `other` tensor must be broadcastable with the `self` tensor. It may be of a different data type.
-
-        Args:
-            other (Tensor): the source tensor Add to self Tensor.
-            alpha (Number): no effect currently.
-
-        Returns:
-            Return self Tensor.
-
-        Supported Platforms:
-            ``Ascend``
-
-        Examples:
-            >>> import numpy as np
-            >>> from mindspore import Tensor
-            >>> a = Tensor(np.ones((2,3)).astype("float32"))
-            >>> b = Tensor(np.ones((2,3)).astype("float32"))
-            >>> a.add_(b)
-            >>> print(a)
-            [[2. 2. 2.]
-            [2. 2. 2.]]
-        """
-        if isinstance(other, (int, float)):
-            ret = tensor_operator_registry.get("adds_")(self, other, alpha)
-        else:
-            ret = tensor_operator_registry.get("add_")(self, other, alpha)
-        return ret
-
-    def subtract(self, other, *, alpha=1):
-        r"""
-        For details, please refer to :func:`mindspore.ops.subtract`.
-        """
-        return tensor_operator_registry.get('sub')(self, alpha * other)
-
-    def true_divide(self, value):
-        r"""
-        Alias for Tensor.div() with :math:`rounding\_mode=None`.
-        For details, please refer to :func:`mindspore.ops.div`.
-        """
-        return tensor_operator_registry.get('div')(self, value, rounding_mode=None)
-
-    def triu(self, diagonal=0):
-        r"""
-        For details, please refer to :func:`mindspore.ops.triu`.
-
-        .. warning::
-            This is an experimental API that is subject to change or deletion.
-
-        """
-        validator.check_value_type('diagonal', diagonal, [int], 'triu')
-        return tensor_operator_registry.get('triu')(self, diagonal)
-
-    def addbmm(self, batch1, batch2, *, beta=1, alpha=1):
-        r"""
-        For details, please refer to :func:`mindspore.ops.addbmm`.
-        """
-        return tensor_operator_registry.get('addbmm')(self, batch1, batch2, beta=beta, alpha=alpha)
-
-    def addmm(self, mat1, mat2, *, beta=1, alpha=1):
-        r"""
-        For details, please refer to :func:`mindspore.ops.addmm`.
-        """
-        return tensor_operator_registry.get('addmm')(self, mat1, mat2, beta=beta, alpha=alpha)
-
     def addmm_(self, mat1, mat2, *, beta=1, alpha=1):
         r"""
-        For details, please refer to :func:`mindspore.ops.addmm`.
-
-        .. note::
-            The output results are directly updated in the Tensor.
+        In-place version of :func:`mindspore.Tensor.addmm`.
 
         .. warning::
             This is an experimental API that is subject to change or deletion.
-
         """
         return tensor_operator_registry.get('addmm_')(self, mat1, mat2, beta=beta, alpha=alpha)
 
@@ -1413,32 +1301,12 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('adjoint')(self)
 
-    def all(self, axis=None, keep_dims=False):
-        r"""
-        For details, please refer to :func:`mindspore.ops.all`.
-        """
-        return tensor_operator_registry.get('all')(self, axis, keep_dims)
-
     def angle(self):
         r"""
         For details, please refer to :func:`mindspore.ops.angle`.
         """
         return tensor_operator_registry.get('angle')(self)
 
-    def any(self, axis=None, keep_dims=False):
-        r"""
-        For details, please refer to :func:`mindspore.ops.any`.
-        """
-        if axis is None:
-            axis = ()
-        return tensor_operator_registry.get('any')(self, axis, keep_dims)
-
-    def atan2(self, other):
-        r"""
-        For details, please refer to :func:`mindspore.ops.atan2`.
-        """
-        return tensor_operator_registry.get('atan2')(self, other)
-
     def baddbmm(self, batch1, batch2, beta=1, alpha=1):
         r"""
         For details, please refer to :func:`mindspore.ops.baddbmm`.
@@ -1474,41 +1342,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             shape = shape[0]
         return tensor_operator_registry.get('reshape')(self, shape)
 
-    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:
-            >>> from mindspore import Tensor
-            >>> from mindspore import dtype as mstype
-            >>> 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.]
-        """
-        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`.
-        """
-        return tensor_operator_registry.get("t")(self)
-
     def bitwise_and(self, other):
         """
         For details, please refer to :func:`mindspore.ops.bitwise_and`.
@@ -1541,12 +1374,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         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`.
-        """
-        return tensor_operator_registry.get('scatter')(self, axis, index, src)
-
     def scatter_mul(self, indices, updates):
         """
         For details, please refer to :func:`mindspore.ops.scatter_mul`.
@@ -1565,12 +1392,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('ger')(self, vec2)
 
-    def gt(self, x):
-        """
-        For details, please refer to :func:`mindspore.ops.gt`.
-        """
-        return tensor_operator_registry.get('gt')(self, x)
-
     def ge(self, x):
         """
         For details, please refer to :func:`mindspore.ops.ge`.
@@ -1583,108 +1404,49 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('broadcast_to')(self, shape)
 
-    def expand_as(self, x):
-        """
-        Expand the dimension of target tensor to the dimension of input tensor.
-
-        Args:
-            x (Tensor): The input tensor. The shape of the input tensor must obey
-                the broadcasting rule.
-
-        Returns:
-            Tensor, has the same dimension as input tensor.
-
-        Examples:
-            >>> import numpy as np
-            >>> from mindspore import Tensor
-            >>> from mindspore import dtype as mstype
-            >>> x = Tensor([1, 2, 3], dtype=mstype.float32)
-            >>> y = Tensor(np.ones((2, 3)), dtype=mstype.float32)
-            >>> output = x.expand_as(y)
-            >>> print(output)
-            [[1. 2. 3.]
-            [1. 2. 3.]]
-        """
-        return tensor_operator_registry.get('broadcast_to')(self, x.shape)
-
-    def exp(self):
-        """
-        For details, please refer to :func:`mindspore.ops.exp`.
-        """
-        return tensor_operator_registry.get('exp')(self)
-
     def real(self):
         r"""
         For details, please refer to :func:`mindspore.ops.real`.
         """
         return tensor_operator_registry.get('real')(self)
 
-    def rsqrt(self):
+    def tanh_(self):
         r"""
-        For details, please refer to :func:`mindspore.ops.rsqrt`.
-        """
-        return tensor_operator_registry.get('rsqrt')(self)
+        Computes hyperbolic tangent of self inplace element-wise. The Tanh function is defined as:
 
-    def reciprocal(self):
-        r"""
-        For details, please refer to :func:`mindspore.ops.reciprocal`.
-        """
-        return tensor_operator_registry.get('reciprocal')(self)
+        .. math::
 
-    def sqrt(self):
-        """
-        For details, please refer to :func:`mindspore.ops.sqrt`.
-        """
-        return tensor_operator_registry.get('sqrt')(self)
+            tanh(x_i) = \frac{\exp(x_i) - \exp(-x_i)}{\exp(x_i) + \exp(-x_i)} = \frac{\exp(2x_i) - 1}{\exp(2x_i) + 1},
 
-    def square(self):
-        """
-        For details, please refer to :func:`mindspore.ops.square`.
-        """
-        return tensor_operator_registry.get('square')(self)
+        where :math:`x_i` is an element of the input Tensor.
 
-    @sub_mint
-    def sub(self, y):
-        r"""
-        For details, please refer to :func:`mindspore.ops.sub`.
-        """
-        return tensor_operator_registry.get('sub')(self, y)
+        Tanh Activation Function Graph:
 
-    def tan(self):
-        """
-        For details, please refer to :func:`mindspore.ops.tan`.
-        """
-        return tensor_operator_registry.get('tan')(self)
+        .. image:: ../../images/Tanh.png
+            :align: center
 
-    def tanh(self):
-        r"""
-        For details, please refer to :func:`mindspore.ops.tanh`.
-        """
-        return tensor_operator_registry.get('tanh')(self)
+        .. warning::
+            - This is an experimental API that is subject ot change or deletion.
 
-    def cosh(self):
-        r"""
-        For details, please refer to :func:`mindspore.ops.cosh`.
-        """
-        return tensor_operator_registry.get('cosh')(self)
+        Returns:
+            Tensor, with the same type and shape as the `self`.
 
-    def acos(self):
-        r"""
-        For details, please refer to :func:`mindspore.ops.acos`.
-        """
-        return tensor_operator_registry.get('acos')(self)
+        Raises:
+            TypeError: If `self` is not a Tensor.
 
-    def arccos(self):
-        r"""
-        Alias for :func:`mindspore.Tensor.acos`.
-        """
-        return self.acos()
+        Supported Platforms:
+            ``Ascend``
 
-    def cos(self):
-        r"""
-        For details, please refer to :func:`mindspore.ops.cos`.
+        Examples:
+            >>> import mindspore
+            >>> import numpy as np
+            >>> from mindspore import Tensor
+            >>> x = Tensor(np.array([1, 2, 3, 4, 5]), mindspore.float32)
+            >>> output = x.tanh_()
+            >>> print(output)
+            [0.7615941 0.9640276 0.9950547 0.9993293 0.9999092]
         """
-        return tensor_operator_registry.get('cos')(self)
+        return tensor_operator_registry.get('tanh_')(self)
 
     def cov(self, *, correction=1, fweights=None, aweights=None):
         r"""
@@ -1692,41 +1454,14 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('cov')(self, correction=correction, fweights=fweights, aweights=aweights)
 
-    def acosh(self):
-        """
-        For details, please refer to :func:`mindspore.ops.acosh`.
-        """
-        return tensor_operator_registry.get('acosh')(self)
-
-    def asin(self):
+    def floor_(self):
         r"""
-        For details, please refer to :func:`mindspore.ops.asin`.
-        """
-        return tensor_operator_registry.get('asin')(self)
-
-    def abs(self):
-        """
-        For details, please refer to :func:`mindspore.ops.abs`.
-        """
-        return tensor_operator_registry.get('abs')(self)
-
-    def absolute(self):
-        """
-        Alias for :func:`mindspore.Tensor.abs`.
-        """
-        return self.abs()
-
-    def ceil(self):
-        """
-        For details, please refer to :func:`mindspore.ops.ceil`.
-        """
-        return tensor_operator_registry.get('ceil')(self)
+        In-place version of :func:`mindspore.Tensor.floor`.
 
-    def floor(self):
-        """
-        For details, please refer to :func:`mindspore.ops.floor`.
+        .. warning::
+            This is an experimental API that is subject to change or deletion.
         """
-        return tensor_operator_registry.get('floor')(self)
+        return tensor_operator_registry.get('floor_')(self)
 
     def floor_divide(self, other):
         """
@@ -1737,18 +1472,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('floor_divide')(self, other)
 
-    def lerp(self, end, weight):
-        """
-        For details, please refer to :func:`mindspore.ops.lerp`.
-        """
-        return tensor_operator_registry.get('lerp')(self, end, weight)
-
-    def negative(self):
-        r"""
-        For details, please refer to :func:`mindspore.ops.negative`.
-        """
-        return tensor_operator_registry.get("negative")(self)
-
     # pylint: disable=redefined-builtin
     def norm(self, ord=None, dim=None, keepdim=False, *, dtype=None):
         """
@@ -1764,7 +1487,8 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
     def approximate_equal(self, other, tolerance=1e-5):
         r"""
-        For details, please refer to :func:`mindspore.ops.approximate_equal`.
+        For details, please refer to :func:`mindspore.ops.approximate_equal`,
+        The parameter `other` of current interface is the same as the parameter `y` of the reference interface.
         """
         validator.check_isinstance("x", self, Tensor)
         validator.check_isinstance("y", other, Tensor)
@@ -1775,12 +1499,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             tensor_operator_registry.get('__sub__')(input_x, input_y)
         ), tolerance)
 
-    def log1p(self):
-        r"""
-        For details, please refer to :func:`mindspore.ops.log1p`.
-        """
-        return tensor_operator_registry.get('log1p')(self)
-
     def logit(self, eps=None):
         r"""
         For details, please refer to :func:`mindspore.ops.logit`.
@@ -1814,6 +1532,10 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
     def logsumexp(self, axis, keepdims=False):
         r"""
         For details, please refer to :func:`mindspore.ops.logsumexp`.
+
+        Note:
+            The input parameter `keepdims` of the inputs has the same meaning as the input parameter `keep_dims` in
+            :func:`mindspore.ops.logsumexp`.
         """
         return tensor_operator_registry.get('logsumexp')(self, axis, keepdims)
 
@@ -1825,22 +1547,10 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
     def i0(self):
         r"""
-        For details, please refer to :func:`mindspore.ops.i0`.
+        For details, please refer to :func:`mindspore.ops.bessel_i0`.
         """
         return tensor_operator_registry.get('i0')(self)
 
-    def isclose(self, x2, rtol=1e-05, atol=1e-08, equal_nan=False):
-        """
-        For details, please refer to :func:`mindspore.ops.isclose`.
-        """
-        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`.
-        """
-        return tensor_operator_registry.get('isneginf')(self)
-
     def isposinf(self):
         r"""
         For details, please refer to :func:`mindspore.ops.isposinf`.
@@ -1853,15 +1563,9 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('isreal')(self)
 
-    def isfinite(self):
+    def is_complex(self):
         r"""
-        For details, please refer to :func:`mindspore.ops.isfinite`.
-        """
-        return tensor_operator_registry.get('isfinite')(self)
-
-    def is_complex(self):
-        r"""
-        For details, please refer to :func:`mindspore.ops.is_complex`.
+        For details, please refer to :func:`mindspore.ops.is_complex`.
         """
         return tensor_operator_registry.get('is_complex')(self)
 
@@ -1871,49 +1575,12 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('inv')(self)
 
-    def inverse(self):
-        r"""
-        For details, please refer to :func:`mindspore.ops.inverse`.
-        """
-        return tensor_operator_registry.get('inverse')(self)
-
     def invert(self):
         r"""
         For details, please refer to :func:`mindspore.ops.invert`.
         """
         return tensor_operator_registry.get('invert')(self)
 
-    def pow(self, exponent):
-        r"""
-        For details, please refer to :func:`mindspore.ops.pow`.
-        """
-        return tensor_operator_registry.get('pow')(self, exponent)
-
-    def log(self):
-        """
-        For details, please refer to :func:`mindspore.ops.log`.
-        """
-        return tensor_operator_registry.get('log')(self)
-
-    def log10(self):
-        r"""
-        For details, please refer to :func:`mindspore.ops.log10`.
-        """
-        return tensor_operator_registry.get('log10')(self)
-
-    def log2(self):
-        r"""
-        For details, please refer to :func:`mindspore.ops.log2`.
-        """
-        return tensor_operator_registry.get('log2')(self)
-
-    @mean_mint
-    def mean(self, axis=None, keep_dims=False):
-        """
-        For details, please refer to :func:`mindspore.ops.mean`.
-        """
-        return tensor_operator_registry.get('mean')(self, axis, keep_dims)
-
     def amin(self, axis=None, keepdims=False, *, initial=None, where=None):
         """
         For details, please refer to :func:`mindspore.ops.amin`.
@@ -1925,6 +1592,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
     def reverse(self, axis):
         """
         For details, please refer to :func:`mindspore.ops.flip`.
+        The `axis` parameter in `Tensor.reverse` is equivalent to the `dims` parameter in :func:`mindspore.ops.flip`.
         """
         return tensor_operator_registry.get('flip')(self, axis)
 
@@ -1948,84 +1616,12 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get("reverse_sequence")(self, seq_lengths, seq_dim, batch_dim)
 
-    def prod(self, axis=None, keep_dims=False, dtype=None):
-        """
-        For details, please refer to :func:`mindspore.ops.prod`.
-        """
-        return tensor_operator_registry.get('prod')(self, axis, keep_dims, dtype)
-
-    def select(self, condition, y):
-        r"""
-        For details, please refer to :func:`mindspore.ops.select`.
-        """
-        if not isinstance(condition, Tensor):
-            raise TypeError(f"For 'Tensor.select', the argument 'condition' should be Tensor,"
-                            f" but got {type(condition)}.")
-        if not isinstance(y, (Tensor, int, float)):
-            raise TypeError(f"For 'Tensor.select', the argument 'y' should be Tensor, int or float,"
-                            f" but got {type(y)}.")
-        if isinstance(y, int) and self.dtype != mstype.int32:
-            raise TypeError(f"For 'Tensor.select', if the argument 'y' is int,"
-                            f" then the tensor type should be int32 but got {self.dtype}")
-        if isinstance(y, float) and self.dtype != mstype.float32:
-            raise TypeError(f"For 'Tensor.select', if the argument 'y' is float,"
-                            f" then the tensor type should be float32 but got {self.dtype}")
-        input_y = y
-        if isinstance(y, (int, float)):
-            input_y = tensor_operator_registry.get('zeros_like')(self) + y
-            if isinstance(y, int):
-                input_y = tensor_operator_registry.get('cast')(input_y, mstype.int32)
-            else:
-                input_y = tensor_operator_registry.get('cast')(input_y, mstype.float32)
-        return tensor_operator_registry.get('select')(condition, self, input_y)
-
-    def transpose(self, *axes):
-        r"""
-        For details, please refer to :func:`mindspore.ops.transpose`.
-        """
-        perm = validator.check_transpose_axis(axes, self.ndim)
-        return tensor_operator_registry.get('transpose')(self, perm)
-
     def col2im(self, output_size, kernel_size, dilation, padding_value, stride):
         """
         For details, please refer to :func:`mindspore.ops.col2im`.
         """
         return tensor_operator_registry.get('col2im')(self, output_size, kernel_size, dilation, padding_value, stride)
 
-    def reshape(self, *shape):
-        r"""
-        Rearranges the input Tensor based on the given `shape` .
-
-        The `shape` can only have one -1 at most, in which case it's inferred from the remaining dimensions and
-        the number of elements in the input.
-
-        Args:
-            shape (Union[int, tuple[int], list[int]]): If `shape` is a tuple or list, its elements should be
-                integers, and only constant value is allowed. i.e., :math:`(y_1, y_2, ..., y_S)`.
-
-        Returns:
-            Tensor, If the given `shape` does not contain -1, the `shape` of tensor is :math:`(y_1, y_2, ..., y_S)`.
-            If the k-th position in the given `shape` is -1, the `shape` of tensor is :math:`(y_1, ..., y_{k-1},
-            \frac{\prod_{i=1}^{R}x_{i}}{y_1\times ...\times y_{k-1}\times y_{k+1}\times...\times y_S} , y_{k+1},
-            ..., y_S)`, in where the shape of input tensor is :math:`(x_1, x_2, ..., x_R)`.
-
-        Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
-
-        Examples:
-            >>> import mindspore
-            >>> import numpy as np
-            >>> from mindspore import Tensor, ops
-            >>> input = Tensor(np.array([[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]]), mindspore.float32)
-            >>> output = input.reshape(3, 2)
-            >>> print(output)
-            [[-0.1  0.3]
-             [ 3.6  0.4]
-             [ 0.5 -3.2]]
-        """
-        new_shape = validator.check_reshape_shp(shape)
-        return tensor_operator_registry.get('reshape')(self, new_shape)
-
     def reshape_as(self, other):
         """
         Change the shape of the Tensor to the shape of `other` without changing the data.
@@ -2078,12 +1674,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         reshape_op = tensor_operator_registry.get('reshape')
         return reshape_op(self, (-1,))
 
-    def round(self, decimals=0):
-        """
-        For details, please refer to :func:`mindspore.ops.round`.
-        """
-        return tensor_operator_registry.get('round')(self, decimals=decimals)
-
     def roll(self, shifts, dims):
         """
         For details, please refer to :func:`mindspore.ops.roll`.
@@ -2102,18 +1692,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('deg2rad')(self)
 
-    def dot(self, other):
-        r"""
-        For details, please refer to :func:`mindspore.ops.dot`.
-        """
-        return tensor_operator_registry.get('dot')(self, other)
-
-    def outer(self, vec2):
-        r"""
-        For details, please refer to :func:`mindspore.ops.outer`.
-        """
-        return tensor_operator_registry.get('outer')(self, vec2)
-
     def rad2deg(self):
         r"""
         For details, please refer to :func:`mindspore.ops.rad2deg`.
@@ -2130,16 +1708,32 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         r"""
         Alias for :func:`mindspore.Tensor.numel`.
         """
-        return tensor_operator_registry.get('nelement')(self)
+        return self.size
 
     def numel(self):
         r"""
-        For details, please refer to :func:`mindspore.ops.numel`.
+        Returns a Scalar of type int that represents the total number of elements in the Tensor.
+
+        Returns:
+            int. A scalar representing the total of elements in the Tensor.
+
+        Supported Platforms:
+            ``Ascend`` ``GPU`` ``CPU``
+
+        Examples:
+            >>> import mindspore
+            >>> import numpy as np
+            >>> from mindspore import Tensor
+            >>> input_x = Tensor(np.array([[2, 2], [2, 2]]), mindspore.float32)
+            >>> print(input_x.numel())
+            4
         """
-        return tensor_operator_registry.get('numel')(self)
+        return self.size
 
     def permute(self, *axis):
         """
+        Tensor.permute supports unpacking the `axis` argument automatically when it is passed as an indefinite number of
+        positional arguments, which has a slight difference from the input parameter of :func:`mindspore.ops.permute`.
         For details, please refer to :func:`mindspore.ops.permute`.
         """
         perm = validator.check_transpose_axis(axis, self.ndim)
@@ -2151,19 +1745,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get("positive")(self)
 
-    def remainder(self, divisor):
-        r"""
-        For details, please refer to :func:`mindspore.ops.remainder`.
-        """
-        return tensor_operator_registry.get('remainder')(self, divisor)
-
-    @flatten_mint
-    def flatten(self, order='C', *, start_dim=0, end_dim=-1):
-        r"""
-        For details, please refer to :func:`mindspore.ops.flatten`.
-        """
-        return tensor_operator_registry.get('flatten')(self, order, start_dim=start_dim, end_dim=end_dim)
-
     def float_power(self, other):
         r"""
         For details, please refer to :func:`mindspore.ops.float_power`.
@@ -2178,22 +1759,10 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
     def fmin(self, other):
         r"""
-        For details, please refer to :func:`mindspore.ops.fmin`.
+        This interface is deprecated from version 2.4 and will be removed in a future version.
         """
         return tensor_operator_registry.get('fmin')(self, other)
 
-    def fmod(self, other):
-        r"""
-        For details, please refer to :func:`mindspore.ops.fmod`.
-        """
-        return tensor_operator_registry.get('fmod')(self, other)
-
-    def narrow(self, axis, start, length):
-        """
-        For details, please refer to :func:`mindspore.ops.narrow`.
-        """
-        return tensor_operator_registry.get('narrow')(self, axis, start, length)
-
     def swapaxes(self, axis0, axis1):
         """
         For details, please refer to :func:`mindspore.ops.swapaxes`.
@@ -2218,20 +1787,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('slogdet')(self)
 
-    def tril(self, diagonal=0):
-        """
-        For details, please refer to :func:`mindspore.ops.tril`.
-        """
-        return tensor_operator_registry.get('tril')(self, diagonal)
-
-    def unsqueeze(self, dim):
-        """
-        For details, please refer to :func:`mindspore.ops.unsqueeze`.
-        """
-        validator.check_is_int(dim, '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):
         """
         For details, please refer to :func:`mindspore.ops.expand_dims`.
@@ -2271,26 +1826,10 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         dtype = _check_astype_and_convert(dtype)
         if not copy and dtype == self.dtype:
             return self
-        return tensor_operator_registry.get('cast')(self, dtype)
-
-    def argmax(self, axis=None, keepdims=False):
-        """
-        For details, please refer to :func:`mindspore.ops.argmax`.
-        """
-        out = tensor_operator_registry.get('argmax')(self, axis, keepdims)
-        return out
-
-    def argmin(self, axis=None, keepdims=False):
-        """
-        For details, please refer to :func:`mindspore.ops.argmin`.
-        """
-        out = tensor_operator_registry.get('argmin')(self, axis, keepdims)
-        return out
+        return self.to(dtype)
 
     def argmax_with_value(self, axis=0, keep_dims=False):
         """
-        Returns the maximum value with corresponding index.
-
         Compute the max value of input Tensor on the specified axis, and return the max value and index.
 
         Note:
@@ -2299,9 +1838,9 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             - The value range of `axis` is [-dims, dims - 1]. `dims` is the dimension length of this tensor.
 
         Args:
-            axis (int): The dimension to reduce. Default: ``0`` .
-            keep_dims (bool): Whether to reduce dimension, if ``true`` the output will keep the same dimension as the
-                            input, the output will reduce dimension if ``false`` . Default: ``False`` .
+            axis (int, optional): The dimension to reduce. Default: ``0`` .
+            keep_dims (bool, optional): Whether to reduce dimension, if ``true`` the output will keep the same dimension
+                as the input, the output will reduce dimension if ``false`` . Default: ``False`` .
 
         Returns:
             tuple (Tensor), tuple of 2 tensors, containing the corresponding index and the maximum value of the input
@@ -2338,7 +1877,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
     def argmin_with_value(self, axis=0, keep_dims=False):
         """
-        Returns the minimum value with corresponding index.
+        Compute the max value of input Tensor on the specified axis, return the minimum value and index.
 
         Note:
             - In auto_parallel and semi_auto_parallel mode, the first output index can not be used.
@@ -2346,9 +1885,9 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             - The value range of `axis` is [-dims, dims - 1]. `dims` is the dimension length of this tensor.
 
         Args:
-            axis (int): The dimension to reduce. Default: 0.
-            keep_dims (bool): Whether to reduce dimension, if true the output will keep the same dimension as the input,
-                            the output will reduce dimension if false. Default: ``False``.
+            axis (int, optional): The dimension to reduce. Default: ``0``.
+            keep_dims (bool, optional): Whether to reduce dimension, if true the output will keep the same dimension
+                as the input, the output will reduce dimension if false. Default: ``False``.
 
         Returns:
             tuple (Tensor), tuple of 2 tensors, containing the corresponding index and the minimum value of the input
@@ -2383,23 +1922,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             return (self, Tensor(0))
         return tensor_operator_registry.get('argmin_with_value')(self, axis, keep_dims)
 
-    def cumsum(self, axis=None, dtype=None):
-        """
-        For details, please refer to :func:`mindspore.ops.cumsum`.
-        """
-        x = self
-        original_dtype = x.dtype
-        # If original tensor is int, and has precision less then int32, convert to int32
-        if x.dtype in (mstype.bool_, mstype.int8, mstype.int16, mstype.uint8, mstype.int16):
-            x = x.astype(mstype.int32)
-        if axis is None:
-            x = x.ravel()
-            axis = 0
-        validator.check_axis_in_range(axis, x.ndim)
-        if dtype is not None and original_dtype != dtype:
-            return tensor_operator_registry.get('cumsum')()(x, axis).astype(dtype, copy=False)
-        return tensor_operator_registry.get('cumsum')()(x, axis)
-
     def cummin(self, axis):
         r"""
         For details, please refer to :func:`mindspore.ops.cummin`.
@@ -2418,12 +1940,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         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`.
-        """
-        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`.
@@ -2497,158 +2013,77 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get("copy_")(self, src)
 
-    @max_mint
-    def max(self, axis=None, keepdims=False, *, initial=None, where=True, return_indices=False):
+    def scatter_add_(self, dim, index, src):
         """
-        Return the maximum of a tensor or maximum along an axis.
-
-        Note:
-            When `axis` is ``None``, `keepdims` and subsequent parameters
-            have no effect. At the same time, the index is fixed to return 0.
-
-        Args:
-            axis (Union[None, int, list, tuple of ints], optional): Axis or
-                axes along which to operate. By default, flattened input is used. If
-                this is a tuple of ints, the maximum is selected over multiple axes,
-                instead of a single axis or all the axes as before. Default: ``None`` .
-            keepdims (bool, optional):
-                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):
-                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
-            value. If `axis` is given, the result is a tensor of dimension ``self.ndim - 1``.
+        Add all elements in `src` to the index specified by `index` to `self` along dimension specified by `dim`,
+        `scatter_add` is an in-place operation.
+        The ranks of `self`, `index` and `src` must be greater or equal to 1.
 
-        Raises:
-            TypeError: If arguments have types not specified above.
+        For a 3-D tensor, the operation updates `self` as follows:
 
-        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.min`: Return the minimum of a tensor or minimum along an axis.
+        .. code-block::
 
-        Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
+            self[index[i][j][k]][j][k] += src[i][j][k]  # if dim == 0
 
-        Examples:
-            >>> import numpy as np
-            >>> from mindspore import Tensor
-            >>> a = Tensor(np.arange(4).reshape((2, 2)).astype('float32'))
-            >>> output = a.max()
-            >>> print(output)
-            3.0
-            >>> value, indices = a.max(axis=0, return_indices=True)
-            >>> print(value)
-            [2. 3.]
-            >>> print(indices)
-            [1 1]
-        """
-        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
-
-    @min_mint
-    def min(self, axis=None, keepdims=False, *, initial=None, where=True, return_indices=False):
-        """
-        Return the minimum of a tensor or minimum along an axis.
+            self[i][index[i][j][k]][k] += src[i][j][k]  # if dim == 1
 
-        Note:
-            When `axis` is ``None``, `keepdims` and subsequent parameters
-            have no effect. At the same time, the index is fixed to return 0.
+            self[i][j][index[i][j][k]] += src[i][j][k]  # if dim == 2
 
         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 (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 minimum value. Default: ``False`` .
-                If `axis` is a list or tuple of ints, it must be ``False`` .
+            dim (int): Which dim to scatter. Accepted range is [-r, r) where r = rank(`self`).
+            index (Tensor): The index of `self` to do scatter operation whose data type must
+                be int32 or int64. Same rank as `self`. Except for the dimension
+                specified by `dim`, size of each dimension of `index` must be less than or equal to the size of
+                the corresponding dimension of `self`.
+            src (Tensor): The tensor doing the scatter operation with `self`, has the same type as `self` and
+                the size of each dimension must be greater than or equal to that of `index`.
 
         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``.
+            Tensor, has the same shape and type as `self`.
 
         Raises:
-            TypeError: If arguments have types not specified above.
-
-        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.
+            TypeError: If `index` is neither int32 nor int64.
+            ValueError: If anyone of the rank among `self`, `index` and `src` is less than 1.
+            ValueError: If the ranks of `self`, `index` and `src` are not the same.
+            ValueError: The size of any dimension of `index` except the dimension specified by `dim` is
+                greater than the size of the corresponding dimension of `self`.
+            ValueError: If the size of any dimension of `src` is less than that of `index`.
 
         Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
+            ``Ascend``
 
         Examples:
             >>> import numpy as np
+            >>> import mindspore as ms
             >>> 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]
-        """
-        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):
-        """
-        For details, please refer to :func:`mindspore.ops.scatter_add`.
+            >>> input = Tensor(np.array([[1, 2, 3, 4, 5]]), dtype=ms.float32)
+            >>> src = Tensor(np.array([[8, 8]]), dtype=ms.float32)
+            >>> index = Tensor(np.array([[2, 4]]), dtype=ms.int64)
+            >>> out = input.scatter_add_(1, index, src)
+            >>> print(out)
+            [[1. 2. 11. 4. 13.]]
+            >>> input = Tensor(np.zeros((5, 5)), dtype=ms.float32)
+            >>> src = Tensor(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), dtype=ms.float32)
+            >>> index = Tensor(np.array([[0, 0, 0], [2, 2, 2], [4, 4, 4]]), dtype=ms.int64)
+            >>> out = input.scatter_add_(0, index, src)
+            >>> print(out)
+            [[1. 2. 3. 0. 0.]
+            [0. 0. 0. 0. 0.]
+            [4. 5. 6. 0. 0.]
+            [0. 0. 0. 0. 0.]
+            [7. 8. 9. 0. 0.]]
+            >>> input = Tensor(np.zeros((5, 5)), dtype=ms.float32)
+            >>> src = Tensor(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), dtype=ms.float32)
+            >>> index = Tensor(np.array([[0, 2, 4], [0, 2, 4], [0, 2, 4]]), dtype=ms.int64)
+            >>> out = input.scatter_add_(1, index, src)
+            >>> print(out)
+            [[1. 0. 2. 0. 3.]
+            [4. 0. 5. 0. 6.]
+            [7. 0. 8. 0. 9.]
+            [0. 0. 0. 0. 0.]
+            [0. 0. 0. 0. 0.]]
         """
-        return tensor_operator_registry.get("tensor_scatter_add")(self, indices, updates)
+        return tensor_operator_registry.get("inplace_scatter_add")(self, dim, index, src)
 
     def scatter_sub(self, indices, updates):
         """
@@ -2774,18 +2209,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('fill_diagonal')(fill_value, wrap)(self)
 
-    def masked_fill(self, mask, value):
-        """
-        For details, please refer to :func:`mindspore.ops.masked_fill`.
-        """
-        if isinstance(value, (float, int)):
-            value = tensor_operator_registry.get("scalar_to_tensor")(value, self.dtype)
-        if not isinstance(mask, Tensor):
-            raise TypeError("For 'Tensor.masked_fill', the type of the argument 'mask' must be Tensor, but "
-                            "got {}.".format(type(mask)))
-        validator.check_type_name('mask', mask.dtype, [mstype.bool_], "Tensor")
-        return tensor_operator_registry.get("masked_fill")(self, mask, value)
-
     def ptp(self, axis=None, keepdims=False):
         """
         The name of the function comes from the acronym for "peak to peak". Calculate the difference between the
@@ -2829,23 +2252,14 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
         return self.max(axis, keepdims) - self.min(axis, keepdims)
 
-    def minimum(self, other):
-        r"""
-        For details, please refer to :func:`mindspore.ops.minimum`.
-        """
-        return tensor_operator_registry.get('minimum')(self, other)
-
-    def clamp(self, min=None, max=None):
+    def clamp_(self, min=None, max=None):
         r"""
-        For details, please refer to :func:`mindspore.ops.clamp`.
-        """
-        return tensor_operator_registry.get('clamp')(self, min, max)
+        In-place version of :func:`mindspore.Tensor.clamp`.
 
-    def clip(self, min=None, max=None):
-        r"""
-        Alias for :func:`mindspore.Tensor.clamp`.
+        .. warning::
+            This is an experimental API that is subject to change or deletion.
         """
-        return self.clamp(min, max)
+        return tensor_operator_registry.get('clamp_')(self, min, max)
 
     def init_data(self, slice_index=None, shape=None, opt_shard_group=None):
         """
@@ -3007,7 +2421,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
     def det(self):
         r"""
-        For details, please refer to :func:`mindspore.ops.det`.
+        This interface is deprecated from version 2.4 and will be removed in a future version.
         """
         return tensor_operator_registry.get('det')(self)
 
@@ -3017,12 +2431,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('diff')(self, n, axis, prepend, append)
 
-    def frac(self):
-        r"""
-        For details, please refer to :func:`mindspore.ops.frac`.
-        """
-        return tensor_operator_registry.get('frac')(self)
-
     def argwhere(self):
         r"""
         For details, please refer to :func:`mindspore.ops.argwhere`.
@@ -3049,13 +2457,15 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
     def lgamma(self):
         r"""
-        For details, please refer to :func:`mindspore.ops.lgamma`.
+        This interface is deprecated from version 2.4 and will be removed in a future version.
         """
         return tensor_operator_registry.get('lgamma')(self)
 
     def diagonal(self, offset=0, axis1=0, axis2=1):
         """
         For details, please refer to :func:`mindspore.ops.diagonal`.
+        The parameter `axis1` of the current interface is the same as the parameter `dim1` of the reference interface,
+        the parameter `axis2` of the current interface is the same as the parameter `dim2` of the reference interface.
         """
         return tensor_operator_registry.get('diagonal')(self, offset, axis1, axis2)
 
@@ -3304,17 +2714,12 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         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, batch_dims=0):
-        r"""
-        For details, please refer to :func:`mindspore.ops.gather`.
-        """
-        validator.check_is_int(axis, 'axis')
-        validator.check_is_int(batch_dims, "batch_dims")
-        return tensor_operator_registry.get('gather')(self, input_indices, axis, batch_dims)
-
     def uniform(self, from_=0., to=1., generator=None):
         r"""
-        Generates random numbers in the half-open interval [from\_, to).
+        Generates random numbers that follows a uniform distribution within the half-open interval :math:`[from\_, to)`.
+
+        .. math::
+            P(x)= \frac{1}{to - from\_}
 
         Args:
             from\_ (number): The lower bound of the interval.
@@ -3341,132 +2746,50 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('uniform')(self, from_, to, generator)
 
-    def var(self, axis=None, ddof=0, keepdims=False):
-        """
-        Compute the variance along the specified axis.
-
-        The variance is the average of the squared deviations from the mean, i.e.,
-        :math:`var = mean(abs(x - x.mean())**2)`.
+    def uniform_(self, from_=0, to=1, *, generator=None):
+        r"""
+        Update the `self` tensor in place by generating random numbers sampled from uniform distribution in the
+        half-open interval :math:`[from\_, to)`.
 
-        Return the variance, which is computed for the flattened array by default,
-        otherwise over the specified axis.
+        .. math::
+            P(x)= \frac{1}{to - from\_}
 
-        Note:
-            Numpy arguments `dtype`, `out` and `where` are not supported.
+        .. warning::
+            This is an experimental API that is subject to change or deletion.
 
         Args:
-            axis (Union[None, int, tuple(int)]): Axis or axes along which the variance is computed.
-                The default is to compute the variance of the flattened array. Default: ``None`` .
-            ddof (int): Means Delta Degrees of Freedom. Default: ``0`` .
-                The divisor used in calculations is :math:`N - ddof`, where :math:`N` represents the number of elements.
-            keepdims (bool): Default: ``False`` .
-
-        Returns:
-            Variance tensor.
-
-        See also:
-            - :func:`mindspore.Tensor.mean`: Reduce a dimension of a tensor by averaging all elements in the dimension.
-            - :func:`mindspore.Tensor.std`: Compute the standard deviation along the specified axis.
-
-        Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
-
-        Examples:
-            >>> import numpy as np
-            >>> from mindspore import Tensor
-            >>> input_x = Tensor(np.array([1., 2., 3., 4.], np.float32))
-            >>> output = input_x.var()
-            >>> print(output)
-            1.25
-        """
-        if 0 in self.shape:
-            return Tensor(float('nan'), self.dtype)
-        if not isinstance(ddof, int):
-            raise TypeError("For 'Tensor.var', the type of the argument 'ddof' must be int, but got "
-                            "{}.".format(type(ddof)))
-        if not isinstance(keepdims, bool):
-            raise TypeError("For 'Tensor.var', the type of the argument 'keepdims' must be bool, but "
-                            "got {}.".format(type(keepdims)))
-
-        if axis is None:
-            axis = ()
-        else:
-            axis = validator.check_and_canonicalize_axes(axis, self.ndim)
-        x_mean = tensor_operator_registry.get('mean')(self, axis, True)
-        x_sub = tensor_operator_registry.get('__sub__')(self, x_mean)
-        x_pow = tensor_operator_registry.get('__pow__')(x_sub, 2)
-        x_sum = tensor_operator_registry.get('reducesum')(bool(keepdims))(x_pow, axis)
-        nums = 1
-        if axis == ():
-            nums = self.size
-        else:
-            for ax in axis:
-                nums *= self.shape[ax]
-        return tensor_operator_registry.get('__truediv__')(x_sum, nums - ddof)
-
-    def std(self, axis=None, ddof=0, keepdims=False):
-        """
-        For details, please refer to :func:`mindspore.ops.std`.
-        """
-        x_var = self.var(axis, ddof, keepdims)
-        return tensor_operator_registry.get('__pow__')(x_var, 0.5)
-
-    def sum(self, axis=None, dtype=None, keepdims=False, initial=None):
-        """
-        Return sum of tensor elements over a given axis.
+            from\_ (Union[number.Number, Tensor], optional): The lower bound of the uniform distribution, it can be a
+                scalar value or a tensor of any dimension with a single element. Default: ``0``.
+            to (Union[number.Number, Tensor], optional): The upper bound of the uniform distribution, it can be a
+                scalar value or a tensor of any dimension with a single element. Default: ``1``.
 
-        Note:
-            Numpy arguments `out`, `where`, `casting`, `order`, `subok`, `signature`, and `extobj` are not supported.
-            The `axis` with tensor type is only used for compatibility with older versions and is not recommended.
-
-        Args:
-            axis (Union[None, int, tuple(int), list(int), Tensor]): Axis or axes along which a sum is performed.
-                Default: ``None`` .
-                If ``None`` , sum all the elements of the input tensor.
-                If the `axis` is negative, it counts from the last to the first `axis`.
-                If the `axis` is a tuple or list of ints, a sum is performed on all the axes specified in the tuple
-                or list instead of a single `axis` or all the axes as before.
-            dtype (:class:`mindspore.dtype`, optional): defaults to ``None`` . Overrides the dtype of the
-                output Tensor.
-            keepdims (bool): 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. If the default value is passed, then `keepdims` will not be passed through to the sum method
-                of sub-classes of ndarray, however any non-default value will be. If the sub-class method does not
-                implement `keepdims` any exceptions will be raised. Default: ``False`` .
-            initial (scalar): Starting value for the sum. Default: ``None`` .
+        Keyword Args:
+            generator (:class:`mindspore.Generator`, optional): a pseudorandom number generator.
+                Default: ``None``, uses the default pseudorandom number generator.
 
         Returns:
-            Tensor. A tensor with the same shape as input, with the specified `axis` removed.
-            If the input tensor is a 0-d array, or if the `axis` is ``None`` , a scalar is returned.
+            Return `self` Tensor.
 
         Raises:
-            TypeError: If input is not array_like, or `axis` is not int, tuple of ints, list of ints or Tensor,
-                or `keepdims` is not integer, or `initial` is not scalar.
-            ValueError: If any `axis` is out of range or duplicate axes exist.
-
-        See also:
-            - :func:`mindspore.Tensor.cumsum`: Return the cumulative sum of the elements along a given `axis`.
+            TypeError: If `from_` or `to` is neither a number nor a Tensor.
+            TypeError: If dtype of `from` or `to` is not one of: bool, int8, int16, int32, int64, uint8, float32,
+                float64.
+            ValueError: If `from_` or `to` is Tensor but contains multiple elements.
+            RuntimeError: If `from_` is larger than `to`.
 
         Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
+            ``Ascend``
 
         Examples:
-            >>> import numpy as np
-            >>> from mindspore import Tensor
-            >>> input_x = Tensor(np.array([-1, 0, 1]).astype(np.float32))
-            >>> print(input_x.sum())
-            0.0
-            >>> input_x = Tensor(np.arange(10).reshape(2, 5).astype(np.float32))
-            >>> print(input_x.sum(axis=1))
-            [10. 35.]
-        """
-        if initial is None:
-            res = tensor_operator_registry.get("sum")(self, axis, keepdims, dtype=dtype)
-        else:
-            res = tensor_operator_registry.get("sum")(self, axis, keepdims, dtype=dtype) + initial
-        if dtype is not None and (dtype == mstype.bool_):
-            res = res.astype(mstype.bool_)
-        return res
+            >>> import mindspore
+            >>> x = mindspore.ops.ones((4, 2))
+            >>> generator = mindspore.Generator()
+            >>> generator.manual_seed(100)
+            >>> output = x.uniform_(1., 2., generator=generator)
+            >>> print(output.shape)
+            (4, 2)
+        """
+        return tensor_operator_registry.get('uniform_')(self, from_=from_, to=to, generator=generator)
 
     def sum_to_size(self, *size):
         r"""
@@ -3512,12 +2835,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             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`.
-        """
-        return tensor_operator_registry.get('nansum')(self, axis=axis, keepdims=keepdims, dtype=dtype)
-
     def nanmean(self, axis=None, keepdims=False, *, dtype=None):
         r"""
         For details, please refer to :func:`mindspore.ops.nanmean`.
@@ -3603,19 +2920,52 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
                 repeated_subs.append(tensor_operator_registry.get('repeat_elements')(sub, rep, axis))
         return tensor_operator_registry.get('concatenate')(repeated_subs, axis)
 
-    @repeat_interleave_mint
-    def repeat_interleave(self, repeats, dim=None):
-        """
-        For details, please refer to :func:`mindspore.ops.repeat_interleave`.
-        """
-        return tensor_operator_registry.get('repeat_interleave')(self, repeats, dim)
-
     def bernoulli(self, p=0.5, seed=None):
         r"""
         For details, please refer to :func:`mindspore.ops.bernoulli`.
         """
         return tensor_operator_registry.get('bernoulli')(self, p, seed)
 
+    def random_(self, from_=0, to=None, *, generator=None):
+        r"""
+        Fill the tensor with numbers sampled from a discrete uniform distribution over an
+        interval :math:`[from\_, to-1]`.
+
+        .. warning::
+            This is an experimental API that is subject to change or deletion.
+
+        Args:
+            from\_ (Union[number.Number, Tensor], optional): the lower bound of the generated random number.
+                It can be a scalar value or a tensor of any dimension with only a single element. Default: 0.
+            to (Union[number.Number, Tensor], optional): the upper bound of the generated random number.
+                By default it's the upper limit of the input data type.
+                It can be a scalar value or a tensor of any dimension with only a single element.
+                Default: ``None``.
+
+        Keyword Args:
+            generator (:class:`mindspore.Generator`, optional): a pseudorandom number generator.
+                Default: ``None``, uses the default pseudorandom number generator.
+
+        Returns:
+            The input tensor.
+
+        Raises:
+            TypeError: If `from_` or `to` is not integer.
+            RuntimeError: If `from_` >= `to`.
+
+        Supported Platforms:
+            ``Ascend``
+
+        Examples:
+            >>> from mindspore import Tensor
+            >>> a = Tensor([[2, 3, 4], [1, 2, 3]])
+            >>> from_ = 0
+            >>> to = 5
+            >>> print(a.random_(from_, to).shape)
+            (2, 3)
+        """
+        return tensor_operator_registry.get('random_')(self, from_=from_, to=to, generator=generator)
+
     def random_categorical(self, num_sample, seed=0, dtype=mstype.int64):
         r"""
         For details, please refer to :func:`mindspore.ops.random_categorical`.
@@ -3624,12 +2974,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         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`.
-        """
-        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`.
@@ -3637,28 +2981,75 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         validator.check_value_type('index', index, (Tensor, Tensor_,), 'Tensor.gather_elements')
         return tensor_operator_registry.get('gather_elements')(self, dim, index)
 
-    def nonzero(self, as_tuple=False):
-        """
-        For details, please refer to :func:`mindspore.ops.nonzero`.
-        """
-        return tensor_operator_registry.get('nonzero')(self, as_tuple)
+    def nonzero(self, *, as_tuple=False):
+        r"""
+        Return the positions of all non-zero values.
 
-    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)
+        Note:
+           The rank of `self`.
 
-        s, _, _ = svd_op(full_matrices, compute_uv)(self)
-        return s
+           - Ascend: its rank can be equal to 0 except O2 mode.
+           - CPU/GPU: its rank should be greater than or eaqual to 1.
 
-    def hardshrink(self, lambd=0.5):
-        r"""
-        For details, please refer to :func:`mindspore.ops.hardshrink`.
+        Keyword Args:
+            as_tuple (bool, optional): Whether the output is tuple.
+                If ``False`` , return Tensor. Default: ``False`` .
+                If ``True`` , return Tuple of Tensor, only support ``Ascend`` .
+
+        Returns:
+            - If `as_tuple` is ``False``, return the Tensor, a 2-D Tensor whose data type is int64,
+              containing the positions of all non-zero values of the `self` .
+            - If `as_tuple` is ``True``, return the Tuple of Tensor and data type is int64.
+              The Tuple length is the dimension of the `self` tensor,
+              and each element is the 1D tensor of the subscript of all non-zero elements of
+              the `self` tensor in that dimension.
+
+        Raises:
+            TypeError: If `self` is not Tensor.
+            TypeError: If `as_tuple` is not bool.
+            RuntimeError: On GPU or CPU or Ascend O2 mode, if dim of `input` equals to 0.
+
+        Supported Platforms:
+            ``Ascend`` ``GPU`` ``CPU``
+
+        Examples:
+            >>> import mindspore
+            >>> import numpy as np
+            >>> from mindspore import Tensor
+            >>> x = Tensor(np.array([[[1,  0], [-5, 0]]]), mindspore.int32)
+            >>> output = x.nonzero()
+            >>> print(output)
+            [[0 0 0]
+            [0 1 0]]
+            >>> x = Tensor(np.array([1, 0, 2, 0, 3]), mindspore.int32)
+            >>> output = x.nonzero(as_tuple=False)
+            >>> print(output)
+            [[0]
+            [2]
+            [4]]
+            >>> x = Tensor(np.array([[[1,  0], [-5, 0]]]), mindspore.int32)
+            >>> output = x.nonzero(as_tuple=True)
+            >>> print(output)
+            (Tensor(shape=[2], dtype=Int64, value=[0, 0]),
+            Tensor(shape=[2], dtype=Int64, value=[0, 1]),
+            Tensor(shape=[2], dtype=Int64, value=[0, 0]))
+            >>> x = Tensor(np.array([1, 0, 2, 0, 3]), mindspore.int32)
+            >>> output = x.nonzero(as_tuple=True)
+            >>> print(output)
+            (Tensor(shape=[3], dtype=Int64, value=[0, 2, 4]), )
+        """
+        return tensor_operator_registry.get('nonzero')(self, as_tuple=as_tuple)
+
+    def svd(self, full_matrices=False, compute_uv=True):
+        """
+        For details, please refer to :func:`mindspore.ops.svd`.
         """
-        return tensor_operator_registry.get('hardshrink')(self, lambd)
+        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
 
     def heaviside(self, values):
         r"""
@@ -3777,12 +3168,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return self.asnumpy().tolist()
 
-    def unbind(self, dim=0):
-        r"""
-        For details, please refer to :func:`mindspore.ops.unbind`.
-        """
-        return tensor_operator_registry.get('unbind')(self, dim)
-
     def unsorted_segment_min(self, segment_ids, num_segments):
         r"""
         For details, please refer to :func:`mindspore.ops.unsorted_segment_min`.
@@ -3838,13 +3223,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get("xdivy")(self, y)
 
-    @split_mint
-    def split(self, split_size_or_sections, axis=0):
-        """
-        For details, please refer to :func:`mindspore.ops.split`.
-        """
-        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`.
@@ -3873,6 +3251,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
     def xlogy(self, y):
         r"""
         For details, please refer to :func:`mindspore.ops.xlogy`.
+        The parameter `y` of the current interface is the same as the parameter `other` of the reference interface.
         """
         return tensor_operator_registry.get("xlogy")(self, y)
 
@@ -3885,30 +3264,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get("eigvals")()(self)
 
-    def erf(self):
-        r"""
-        For details, please refer to :func:`mindspore.ops.erf`.
-        """
-        return tensor_operator_registry.get("erf")(self)
-
-    def erfc(self):
-        r"""
-        For details, please refer to :func:`mindspore.ops.erfc`.
-        """
-        return tensor_operator_registry.get("erfc")(self)
-
-    def tile(self, reps):
-        r"""
-        For details, please refer to :func:`mindspore.ops.tile`.
-        """
-        return tensor_operator_registry.get('tile')(self, reps)
-
-    def topk(self, k, dim=None, largest=True, sorted=True):
-        r"""
-        For details, please refer to :func:`mindspore.ops.topk`.
-        """
-        return tensor_operator_registry.get("topk")(self, k, dim, largest, sorted)
-
     def top_k(self, k, sorted=True):
         r"""
         `Tensor.top_k` is deprecated, please use `Tensor.topk` instead.
@@ -3917,55 +3272,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         validator.check_bool(sorted, 'sorted')
         return tensor_operator_registry.get("top_k")(self, k, sorted)
 
-    def sigmoid(self):
-        r"""
-        For details, please refer to :func:`mindspore.ops.sigmoid`.
-        """
-        return tensor_operator_registry.get("sigmoid")(self)
-
-    def median(self, axis=-1, keepdims=False):
-        r"""
-        For details, please refer to :func:`mindspore.ops.median`.
-        """
-        validator.check_axis_in_range(axis, self.ndim)
-        return tensor_operator_registry.get('median')(False, axis, keepdims)(self)
-
-    def addmv(self, mat, vec, beta=1, alpha=1):
-        r"""
-        For details, please refer to :func:`mindspore.ops.addmv`.
-        """
-        return tensor_operator_registry.get('addmv')(self, mat, vec, beta=beta, alpha=alpha)
-
-    def asinh(self):
-        r"""
-        For details, please refer to :func:`mindspore.ops.asinh`.
-        """
-        return tensor_operator_registry.get('asinh')(self)
-
-    def arcsinh(self):
-        r"""
-        Alias for :func:`mindspore.Tensor.asinh`.
-        """
-        return tensor_operator_registry.get('arcsinh')(self)
-
-    def atan(self):
-        r"""
-        For details, please refer to :func:`mindspore.ops.atan`.
-        """
-        return tensor_operator_registry.get('atan')(self)
-
-    def atanh(self):
-        r"""
-        For details, please refer to :func:`mindspore.ops.atanh`.
-        """
-        return tensor_operator_registry.get('atanh')(self)
-
-    def arctanh(self):
-        r"""
-        Alias for :func:`mindspore.Tensor.atanh`.
-        """
-        return tensor_operator_registry.get('arctanh')(self)
-
     def bmm(self, mat2):
         r"""
         For details, please refer to :func:`mindspore.ops.bmm`.
@@ -3976,8 +3282,14 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         r"""
         Performs tensor dtype conversion.
 
+        Note:
+            - If the `self` Tensor already has the correct `mindspore.dtype`, then self is returned.
+              Otherwise, the returned tensor is a copy of `self` with the desired mindspore.dtype.
+            - When converting complex numbers to boolean type, the imaginary part of the complex number is not
+              taken into account. As long as the real part is non-zero, it returns True; otherwise, it returns False.
+
         Args:
-            dtype (Number): The valid data type of the output tensor. Only constant value is allowed.
+            dtype (dtype.Number): The valid data type of the output tensor. Only constant value is allowed.
 
         Returns:
             Tensor, converted to the specified `dtype`.
@@ -3999,7 +3311,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(output.dtype)
             Int32
         """
-        return tensor_operator_registry.get('to')(self, dtype)
+        return self if self.dtype == dtype else self._to(dtype)
 
     def type(self, dtype=None):
         r"""
@@ -4029,29 +3341,49 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             return str(self.dtype)
         return self.astype(dtype)
 
+
     def type_as(self, other):
         r"""
-        Change the dtype of the Tensor to the dtype of `other`.
+        Returns self tensor cast to the type of the with the input other tensor.
+
+        .. warning::
+            This is an experimental API that is subject to change or deletion.
+
+        Note:
+            When converting complex numbers to boolean type, the imaginary part of the complex number is not
+            taken into account. As long as the real part is non-zero, it returns True; otherwise, it returns False.
 
         Args:
-            other (Tensor): The return tensor has the same dtype as `other`.
+            other (Tensor): The tensor whose data type is specified.
+                The shape of tensor is :math:`(x_0, x_1, ..., x_R)`.
 
         Returns:
-            Tensor, has the same dtype as `other`.
+            Tensor, the shape of tensor is the same as `self`, :math:`(x_0, x_1, ..., x_R)`.
+
+        Raises:
+            TypeError: If `other` is not a Tensor.
 
         Supported Platforms:
             ``Ascend`` ``GPU`` ``CPU``
 
         Examples:
             >>> import mindspore
+            >>> import numpy as np
             >>> from mindspore import Tensor
-            >>> x = Tensor([[1, 2], [3, 4]], dtype=mindspore.float32)
-            >>> y = Tensor([[1, 2], [3, 4]], dtype=mindspore.int32)
-            >>> x = x.type_as(y)
-            >>> print(x.dtype)
+            >>> input_np = np.random.randn(2, 3, 4, 5).astype(np.float32)
+            >>> self = Tensor(input_np)
+            >>> other_np = np.random.randn(2, 3, 4).astype(np.int32)
+            >>> other = Tensor(other_np)
+            >>> output = self.type_as(other)
+            >>> print(output.dtype)
             Int32
+            >>> print(output.shape)
+            (2, 3, 4, 5)
         """
-        return self.astype(other.dtype)
+        if self.dtype == other.dtype:
+            return self
+        return Tensor_.type_as(self, other)
+
 
     def bool(self):
         r"""
@@ -4073,7 +3405,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(output.dtype)
             Bool
         """
-        return tensor_operator_registry.get('bool')(self, mstype.bool_)
+        return self.to(mstype.bool_)
 
     def float(self):
         r"""
@@ -4094,7 +3426,49 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(output.dtype)
             Float32
         """
-        return tensor_operator_registry.get('float')(self, mstype.float32)
+        return self.to(mstype.float32)
+
+    def bfloat16(self):
+        r"""
+        Converts input tensor dtype to `bfloat16`.
+
+        Returns:
+            Tensor, converted to the `bfloat16` dtype.
+
+        Supported Platforms:
+            ``Ascend`` ``GPU`` ``CPU``
+
+        Examples:
+            >>> import numpy as np
+            >>> import mindspore
+            >>> from mindspore import Tensor
+            >>> input_x = Tensor(np.ones([2,2]), mindspore.int32)
+            >>> output = input_x.bfloat16()
+            >>> print(output.dtype)
+            BFloat16
+        """
+        return self.to(mstype.bfloat16)
+
+    def double(self):
+        r"""
+        Converts input tensor dtype to `float64`.
+
+        Returns:
+            Tensor, converted to the `float64` dtype.
+
+        Supported Platforms:
+            ``Ascend`` ``GPU`` ``CPU``
+
+        Examples:
+            >>> import numpy as np
+            >>> import mindspore
+            >>> from mindspore import Tensor
+            >>> input_x = Tensor(np.ones([2,2]), mindspore.int32)
+            >>> output = input_x.double()
+            >>> print(output.dtype)
+            Float64
+        """
+        return self.to(mstype.float64)
 
     def half(self):
         r"""
@@ -4115,7 +3489,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(output.dtype)
             Float16
         """
-        return tensor_operator_registry.get('half')(self, mstype.float16)
+        return self.to(mstype.float16)
 
     def int(self):
         r"""
@@ -4136,7 +3510,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(output.dtype)
             Int32
         """
-        return tensor_operator_registry.get('int')(self, mstype.int32)
+        return self.to(mstype.int32)
 
     def byte(self):
         r"""
@@ -4155,9 +3529,9 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> input_x = Tensor(np.ones([2,2]), mindspore.float32)
             >>> output = input_x.byte()
             >>> print(output.dtype)
-            uint8
+            UInt8
         """
-        return tensor_operator_registry.get('byte')(self, mstype.uint8)
+        return self.to(mstype.uint8)
 
     def long(self):
         r"""
@@ -4178,7 +3552,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(output.dtype)
             Int64
         """
-        return tensor_operator_registry.get('long')(self, mstype.int64)
+        return self.to(mstype.int64)
 
     def short(self):
         r"""
@@ -4200,7 +3574,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> output
             Tensor(shape=[5], dtype=Int16, value= [1, 2, 3, 4, 5])
         """
-        return tensor_operator_registry.get('cast')(self, mstype.int16)
+        return self.to(mstype.int16)
 
     def cholesky(self, upper=False):
         r"""
@@ -4210,7 +3584,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
     def cholesky_inverse(self, upper=False):
         r"""
-        For details, please refer to :func:`mindspore.ops.cholesky_inverse`.
+        This interface is deprecated from version 2.4 and will be removed in a future version.
         """
         return tensor_operator_registry.get('cholesky_inverse')(self, upper=upper)
 
@@ -4247,11 +3621,14 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('erfinv')(self)
 
-    def less_equal(self, other):
+    def erfinv_(self):
         r"""
-        For details, please refer to :func:`mindspore.ops.less_equal`.
+        In-place version of erfinv(), for details, please refer to :func:`mindspore.ops.erfinv`.
+
+        .. warning::
+            This is an experimental API that is subject to change or deletion.
         """
-        return tensor_operator_registry.get('less_equal')(self, other)
+        return tensor_operator_registry.get('erfinv_')(self)
 
     def lcm(self, other):
         r"""
@@ -4284,6 +3661,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
     def expand(self, size):
         r"""
         For details, please refer to :func:`mindspore.ops.broadcast_to`.
+        The parameter `size` of the current interface is the same as the parameter `shape` of the reference interface.
         """
         if isinstance(size, Tensor):
             size = tensor_operator_registry.get('tensortotuple')()(size)
@@ -4297,59 +3675,90 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
     def multiply(self, value):
         r"""
-        For details, please refer to :func:`mindspore.ops.multiply`.
+        For details, please refer to :func:`mindspore.ops.mul`.
+        The parameter `value` of the current interface is the same as the parameter `other` of the reference interface.
         """
         return tensor_operator_registry.get('multiply')(self, value)
 
-    def div(self, value, *, rounding_mode=None):
-        r"""
-        For details, please refer to :func:`mindspore.ops.div`.
-        """
-        return tensor_operator_registry.get('div')(self, value, rounding_mode=rounding_mode)
-
-    def divide(self, value, *, rounding_mode=None):
-        r"""
-        Alias for :func:`mindspore.Tensor.div`.
-        """
-        return tensor_operator_registry.get('div')(self, value, rounding_mode=rounding_mode)
-
-    def eq(self, other):
-        r"""
-        For details, please refer to :func:`mindspore.ops.eq`.
-        """
-        return tensor_operator_registry.get('equal')(self, other)
-
     def equal(self, other):
         r"""
         For details, please refer to :func:`mindspore.ops.equal`.
         """
         return tensor_operator_registry.get('equal')(self, other)
 
-    def expm1(self):
-        r"""
-        For details, please refer to :func:`mindspore.ops.expm1`.
-        """
-        return tensor_operator_registry.get('expm1')(self)
-
     def index_add(self, dim, index, source, *, alpha=1):
         r"""
         For details, please refer to :func:`mindspore.ops.index_add`.
+        The corresponding relationships between the parameters of `Tensor.index_add` and :func:`mindspore.ops.index_add`
+        are as follows: `dim` -> `axis`, `index` -> `indices`, `source * alpha` -> `y`.
         """
         check_is_number(alpha, (int, float))
         source = tensor_operator_registry.get('__mul__')(source, alpha)
         return tensor_operator_registry.get('index_add')(self, indices=index, y=source, axis=dim)
 
-    def greater(self, other):
+    def index_add_(self, dim, index, source, *, alpha=1):
         r"""
-        For details, please refer to :func:`mindspore.ops.greater`.
-        """
-        return tensor_operator_registry.get('greater')(self, other)
+        Accumulate the elements of `alpha` times `source` into the `self` by adding to the index
+        in the order given in `index`. For example, if `dim == 0`, `index[i] == j`, and `alpha = -1`,
+        then the `i` th row of `source` is subtracted from the `j` th row of `self` .
+        The `dim` th dimension of `source` must have the same size as the length of `index` ,
+        and all other dimensions must match `self`, or an error will be raised.
+        For a 3-D tensor the output is defined as follows:
 
-    def greater_equal(self, other):
-        r"""
-        For details, please refer to :func:`mindspore.ops.greater_equal`.
+        .. math::
+            \begin{array}{ll}
+            self[index[i],\ :,\ :]\ +=\ alpha * src[i,\ :,\ :]  \qquad \#if\ dim == 0 \\
+            self[:,\ \ index[i],\ :]\ +=\ alpha * src[:,\ \ i,\ :]  \qquad \#if\ dim == 1 \\
+            self[:,\ :,\ \ index[i]]\ +=\ alpha * src[:,\ :,\ \ i]  \qquad\#if\ dim == 2 \\
+            \end{array}
+
+        .. warning::
+            This is an experimental API that is subject to change or deletion.
+
+        Args:
+            dim (int): The dimension along which to index.
+            index (Tensor): Add the value of `self` and `source` along the dimension of the `dim` according to
+                the specified index value, with data type int32. The `index` must be 1D with the same size as
+                the size of `source` in the `dim` dimension. The values of `index` should be in [0, b),
+                where the b is the size of `self` in the `dim` dimension.
+            source (Tensor): The input tensor with the value to add. Must have same data type as `self`.
+                The shape must be the same as `self` except the `dim` th dimension.
+
+        Keyword Args:
+            alpha (number, optional): The scalar multiplier for source. Default: ``1``.
+
+        Returns:
+            Tensor, has the same shape and dtype as `self`.
+
+        Raises:
+            TypeError: If neither `index` nor `source` is a Tensor.
+            ValueError: If dim is out of `self` rank's range.
+            ValueError: If `self` rank is not the same as `source` rank.
+            ValueError: If shape of `index` is not 1D or size of `index` is not equal to dimension
+                of `source[dim]`.
+            ValueError: If `source`'s shape is not the same as `self` except the `dim` th dimension.
+
+        Supported Platforms:
+            ``Ascend``
+
+        Examples:
+            >>> import numpy as np
+            >>> import mindspore
+            >>> from mindspore import Tensor
+            >>> x = Tensor(np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), mindspore.float32)
+            >>> index = Tensor(np.array([0, 2]), mindspore.int32)
+            >>> y = Tensor(np.array([[0.5, 1.0], [1.0, 1.5], [2.0, 2.5]]), mindspore.float32)
+            >>> output = x.index_add_(1, index, y, alpha=1)
+            >>> print(output)
+            [[ 1.5  2.   4. ]
+             [ 5.   5.   7.5]
+             [ 9.   8.  11.5]]
+            >>> print(x)
+            [[ 1.5  2.   4. ]
+             [ 5.   5.   7.5]
+             [ 9.   8.  11.5]]
         """
-        return tensor_operator_registry.get('greater_equal')(self, other)
+        return tensor_operator_registry.get('index_add_')(self, dim, index, source, alpha)
 
     def igamma(self, other):
         r"""
@@ -4363,18 +3772,11 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('igammac')(self, other)
 
-    def isinf(self):
-        r"""
-        For details, please refer to :func:`mindspore.ops.isinf`.
-        """
-        return tensor_operator_registry.get('isinf')(self)
-
-    @isnan_mint
     def isnan(self):
         r"""
-        For details, please refer to :func:`mindspore.ops.isnan`.
+        For details, please refer to :func:`mindspore.ops.ne`.
         """
-        return tensor_operator_registry.get('isnan')(self)
+        return self.ne(self)
 
     def flip(self, dims):
         """
@@ -4423,42 +3825,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return self.dtype in mstype.signed_type
 
-    def le(self, other):
-        r"""
-        For details, please refer to :func:`mindspore.ops.le`.
-        """
-        return tensor_operator_registry.get('le')(self, other)
-
-    def less(self, other):
-        r"""
-        For details, please refer to :func:`mindspore.ops.less`.
-        """
-        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`.
-        """
-        return tensor_operator_registry.get('logical_and')(self, other)
-
-    def logical_not(self):
-        r"""
-        For details, please refer to :func:`mindspore.ops.logical_not`.
-        """
-        return tensor_operator_registry.get('logical_not')(self)
-
-    def logical_or(self, other):
-        r"""
-        For details, please refer to :func:`mindspore.ops.logical_or`.
-        """
-        return tensor_operator_registry.get('logical_or')(self, other)
-
     def logical_xor(self, other):
         r"""
         For details, please refer to :func:`mindspore.ops.logical_xor`.
@@ -4467,7 +3833,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
     def lstsq(self, A):
         r"""
-        For details, please refer to :func:`mindspore.ops.lstsq`.
+        This interface is deprecated from version 2.4 and will be removed in a future version.
         """
         return tensor_operator_registry.get('lstsq')(self, A)
 
@@ -4476,6 +3842,15 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         r"""
         Accessing this property is equivalent to Calling self.adjoint().
         For details, please refer to :func:`mindspore.ops.adjoint`.
+
+        Examples:
+            >>> from mindspore import Tensor
+            >>> import numpy as np
+            >>> x = Tensor(np.array([[0. + 0.j, 1. + 1.j], [2. + 2.j, 3. + 3.j]]))
+            >>> output = x.mH
+            >>> print(output)
+            [[0.-0.j 2.-2.j]
+             [1.-1.j 3.-3.j]]
         """
         return self.adjoint()
 
@@ -4485,6 +3860,14 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         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`.
+
+        Examples:
+            >>> from mindspore import Tensor
+            >>> import numpy as np
+            >>> x = Tensor(np.ones((2, 3, 4)))
+            >>> output = x.mT
+            >>> print(output.shape)
+            (2, 4, 3)
         """
         return self.swapaxes(-2, -1)
 
@@ -4494,12 +3877,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('mvlgamma')(self, p)
 
-    def matmul(self, tensor2):
-        r"""
-        For details, please refer to :func:`mindspore.ops.matmul`.
-        """
-        return tensor_operator_registry.get('matmul')(self, tensor2)
-
     def inner(self, other):
         r"""
         For details, please refer to :func:`mindspore.ops.inner`.
@@ -4514,95 +3891,16 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
     def matrix_power(self, n):
         r"""
-        For details, please refer to :func:`mindspore.ops.matrix_power`.
-
-        .. warning::
-            This is an experimental API that is subject to change or deletion.
-
+        This interface is deprecated from version 2.4 and will be removed in a future version.
         """
         return tensor_operator_registry.get('matrix_power')(self, n)
 
-    def maximum(self, other):
-        r"""
-        For details, please refer to :func:`mindspore.ops.maximum`.
-        """
-        return tensor_operator_registry.get('maximum')(self, other)
-
-    def mm(self, mat2):
-        r"""
-        For details, please refer to :func:`mindspore.ops.mm`.
-        """
-        return tensor_operator_registry.get('mm')(self, mat2)
-
     def msort(self):
         r"""
         For details, please refer to :func:`mindspore.ops.msort`.
         """
         return tensor_operator_registry.get('msort')(self)
 
-    def mul(self, value):
-        r"""
-        For details, please refer to :func:`mindspore.ops.mul`.
-        """
-        return tensor_operator_registry.get('mul')(self, value)
-
-    def nan_to_num(self, nan=None, 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"""
-        For details, please refer to :func:`mindspore.ops.neg`.
-        """
-        return tensor_operator_registry.get('neg')(self)
-
-    def ne(self, other):
-        r"""
-        For details, please refer to :func:`mindspore.ops.ne`.
-        """
-        return tensor_operator_registry.get('ne')(self, other)
-
-    def not_equal(self, other):
-        r"""
-        For details, please refer to :func:`mindspore.ops.not_equal`.
-        """
-        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.
-
-        .. warning::
-            For argument `size`, Tensor type input will be deprecated in the future version.
-
-        Args:
-            size (Union[int, tuple, list, Tensor]): An int, list or tuple of integers defining the output shape.
-            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 and dtype is defined above and filled with zeros.
-
-        Raises:
-            TypeError: If `size` is neither an int nor an tuple/list/Tensor of int.
-
-        Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
-
-        Examples:
-            >>> import numpy as np
-            >>> import mindspore
-            >>> from mindspore import Tensor
-            >>> x = Tensor(np.array([1, 2, 3]), mindspore.float32)
-            >>> output = x.new_zeros((2, 2))
-            >>> print(output)
-            [[0. 0.]
-             [0. 0.]]
-        """
-        return tensor_operator_registry.get('zeros')(size, dtype)
-
     def zero_(self):
         r"""
         Return a tensor filled with zeros.
@@ -4623,43 +3921,52 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> x = Tensor(np.array([2, 2]))
             >>> output = x.zero_()
             >>> print(output)
-            [[0. 0.]
-             [0. 0.]]
+            [0 0]
         """
         return tensor_operator_registry.get('zero_')(self)
 
-    def new_ones(self, size, dtype=None):
+    def new_empty(self, size, *, dtype=None, device=None):
         r"""
-        Return a tensor of `size` filled with ones.
+        Returns an uninitialized Tensor of `size`. Its dtype is specified by `dtype` and its
+        device is specified by `device`.
 
         .. warning::
-            For argument `size`, Tensor type input will be deprecated in the future version.
+            This is an experimental API that is subject to change or deletion.
 
         Args:
-            size (Union[int, tuple, list, Tensor]): An int, list or tuple of integers defining the output shape.
-            dtype (mindspore.dtype, optional): The desired dtype of the output tensor. If None, the returned
-                tensor has the same dtype as `self`. Default: ``None``.
+            size (Union[tuple[int], list[int], int]): The specified shape of output tensor. Only positive integer or
+                tuple or list containing positive integers are allowed.
+
+        Keyword Args:
+            dtype (:class:`mindspore.dtype`, optional): The specified dtype of the output tensor. If `dtype = None`,
+                the tensor will have the same dtype as `self`. Default ``None``.
+            device (string, optional): The specified device of the output tensor. Support ``CPU`` and ``Ascend``. If
+                `device = None`, the tensor will have the same device as `self` and if the device of `self` is not
+                defined, the value set by :func:`mindspore.set_device` will be used. Default ``None``.
 
         Returns:
-            Tensor, the shape and dtype is defined above and filled with ones.
+            Tensor, the shape, dtype and device is defined above but with uninitialized data (May be a random value).
 
         Raises:
-            TypeError: If `size` is neither an int nor an tuple/list/Tensor of int.
+            TypeError: If `size` is neither an int nor a tuple or list of int.
 
         Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
+            ``Ascend``
 
         Examples:
-            >>> import numpy as np
             >>> import mindspore
             >>> from mindspore import Tensor
-            >>> x = Tensor(np.array([1, 2, 3]), mindspore.float32)
-            >>> output = x.new_ones((2, 2))
-            >>> print(output)
-            [[1. 1.]
-             [1. 1.]]
+            >>> x = Tensor([[1, 2, 3], [4, 5, 6]])
+            >>> output1 = x.new_empty((2, 3))
+            >>> print(output1)
+            [[0 0 0]
+             [0 0 0]]
+            >>> output2 = x.new_empty((2, 3), dtype=mindspore.float64)
+            >>> print(output2)
+            [[0. 0. 0.]
+             [0. 0. 0.]]
         """
-        return tensor_operator_registry.get('ones')(size, dtype)
+        return tensor_operator_registry.get('new_empty')(self, size, dtype, device)
 
     def sign(self):
         r"""
@@ -4679,48 +3986,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('sgn')(self)
 
-    def sin(self):
-        r"""
-        For details, please refer to :func:`mindspore.ops.sin`.
-        """
-        return tensor_operator_registry.get('sin')(self)
-
-    def sinc(self):
-        r"""
-        For details, please refer to :func:`mindspore.ops.sinc`.
-        """
-        return tensor_operator_registry.get('sinc')(self)
-
-    def sinh(self):
-        r"""
-        For details, please refer to :func:`mindspore.ops.sinh`.
-        """
-        return tensor_operator_registry.get('sinh')(self)
-
-    def sort(self, axis=-1, descending=False):
-        r"""
-        For details, please refer to :func:`mindspore.ops.sort`.
-        """
-        return tensor_operator_registry.get('sort')(self, axis=axis, descending=descending)
-
-    def argsort(self, axis=-1, descending=False):
-        """
-        For details, please refer to :func:`mindspore.ops.argsort`.
-        """
-        return tensor_operator_registry.get('argsort')(self, axis, descending)
-
-    def trunc(self):
-        r"""
-        For details, please refer to :func:`mindspore.ops.trunc`.
-        """
-        return tensor_operator_registry.get('trunc')(self)
-
-    def where(self, condition, y):
-        r"""
-        For details, please refer to :func:`mindspore.ops.where`.
-        """
-        return tensor_operator_registry.get('where')(condition, self, y)
-
     def imag(self):
         r"""
         For details, please refer to :func:`mindspore.ops.imag`.
@@ -4729,13 +3994,13 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
     def quantile(self, q, axis=None, keepdims=False):
         r"""
-        For details, please refer to :func:`mindspore.ops.quantile`.
+        This interface is deprecated from version 2.4 and will be removed in a future version.
         """
         return tensor_operator_registry.get('quantile')(self, q, axis, keepdims)
 
     def nanquantile(self, q, axis=None, keepdims=False):
         """
-        For details, please refer to :func:`mindspore.ops.nanquantile`.
+        This interface is deprecated from version 2.4 and will be removed in a future version.
         """
         return tensor_operator_registry.get('nanquantile')(self, q, axis, keepdims)
 
@@ -4762,7 +4027,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
     def qr(self, some=True):
         r"""
-        For details, please refer to :func:`mindspore.ops.qr`.
+        This interface is deprecated from version 2.4 and will be removed in a future version.
         """
         validator.check_value_type('some', some, bool, 'Tensor.qr')
         return tensor_operator_registry.get('qr')(self, 'reduced' if some else 'complete')
@@ -4776,7 +4041,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
     def masked_scatter(self, mask, x):
         r"""
-        Returns a Tensor. Updates the value in the "self Tensor" with the `tensor` value according to the mask.
+        Updates the value in the "self Tensor" with the `tensor` value according to the mask, and returns a Tensor.
         The shape of `mask` and the "self Tensor" must be the same or `mask` is broadcastable.
 
         .. warning::
@@ -4816,35 +4081,39 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
     def index_put(self, indices, values, accumulate=False):
         r"""
-        Returns a Tensor. According to the index number of `indices` ,
-        replace the value corresponding to the "self Tensor" with the value in `values`.
+        Based on the indices in `indices`, replace the corresponding elements in Tensor `self`
+        with the values in `values`. Outplace version of  :func:`mindspore.Tensor.index_put_` 。
+
+        .. warning::
+            The behavior is unpredictable in the following scenario:
+
+            - If `accumulate` is `False` and `indices` contains duplicate elements.
 
         Args:
-            indices (tuple[Tensor], list[Tensor]): the indices of type int32 or int64, used to index into the "self
-                Tensor". The rank of tensors in indices should be 1-D, size of indices should <= "self Tensor".rank
+            indices (tuple[Tensor], list[Tensor]): the indices of type int32 or int64, used to index into the `self`.
+                The rank of tensors in indices should be 1-D, size of indices should <= `self.rank`
                 and the tensors in indices should be broadcastable.
-            values (Tensor): 1-D Tensor of the same type as "self Tensor". if size == 1 will be broadcast
-            accumulate (bool): If `accumulate` is True, the elements in values are added to "self Tensor",
-                else the elements in `values` replace the corresponding element in the "self Tensor".
+            values (Tensor): 1-D Tensor with the same type as `self`. `values` should be broadcastable with size 1.
+            accumulate (bool, optional): If `accumulate` is `True`, the elements in `values` will be added to `self`,
+                otherwise the elements in `values` will replace the corresponding elements in the `self`.
                 Default: ``False``.
 
         Returns:
             Tensor, with the same type and shape as the "self Tensor".
 
         Raises:
-            TypeError: If the dtype of the "self Tensor" is not equal to the dtype of `values`.
+            TypeError: If the dtype of the `self` is not equal to the dtype of `values`.
             TypeError: If the dtype of `indices` is not tuple[Tensor], list[Tensor].
             TypeError: If the dtype of tensors in `indices` are not int32 or int64.
             TypeError: If the dtype of tensors in `indices` are inconsistent.
             TypeError: If the dtype of `accumulate` is not bool.
             ValueError: If rank(`values`) is not 1-D.
             ValueError: If size(`values`) is not 1 or max size of the tensors in `indices` when
-                rank("self Tensor") == size(`indices`).
-            ValueError: If size(`values`) is not 1 or "self Tensor".shape[-1] when
-                rank("self Tensor") > size(`indices`).
+                rank(`self`) == size(`indices`).
+            ValueError: If size(`values`) is not 1 or `self`.shape[-1] when rank(`self`) > size(`indices`).
             ValueError: If the rank of tensors in `indices` is not 1-D.
             ValueError: If the tensors in `indices` is not be broadcastable.
-            ValueError: If size(`indices`) > rank("self Tensor").
+            ValueError: If size(`indices`) > rank(`self`).
 
         Supported Platforms:
             ``Ascend`` ``CPU``
@@ -4866,6 +4135,60 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         _index_put = tensor_operator_registry.get('index_put')(0 if accumulate is False else 1)
         return _index_put(self, values, indices)
 
+    def index_put_(self, indices, values, accumulate=False):
+        r"""
+        Based on the indices in `indices`, replace the corresponding elements in Tensor `self` with the values
+        in `values`. The expression `Tensor.index_put_(indices, values)` is equivalent to `tensor[indices] = values`.
+        Update and return `self`.
+
+        .. warning::
+            The behavior is unpredictable in the following scenario:
+
+            - If `accumulate` is `False` and `indices` contains duplicate elements.
+
+        Args:
+            indices (tuple[Tensor], list[Tensor]): the indices of type is bool, uint8, int32 or int64,
+                used to index into the `self`. The size of indices should <=  the rank of `self`
+                and the tensors in indices should be broadcastable.
+            values (Tensor): Tensor with the same type as `self`. If size == 1, it will be broadcastable.
+            accumulate (bool, optional): If `accumulate` is `True`, the elements in `values` will be added to `self`,
+                otherwise the elements in `values` will replace the corresponding elements in the `self`.
+                Default: ``False``.
+
+        Returns:
+            Tensor `self`.
+
+        Raises:
+            TypeError: If the dtype of the `self` is not equal to the dtype of `values`.
+            TypeError: If the dtype of `indices` is not tuple[Tensor], list[Tensor].
+            TypeError: If the dtype of tensors in `indices` are not bool, uint8, int32 or int64.
+            TypeError: If the dtypes of tensors in `indices` are inconsistent.
+            TypeError: If the dtype of `accumulate` is not bool.
+            ValueError: If size(`values`) is not 1 or max size of the tensors in `indices` when
+                rank(`self`) == size(`indices`).
+            ValueError: If size(`values`) is not 1 or `self`.shape[-1] when rank(`self`) > size(`indices`).
+            ValueError: If the tensors in `indices` is not be broadcastable.
+            ValueError: If size(`indices`) > rank(`self`).
+
+        Supported Platforms:
+            ``Ascend``
+
+        Examples:
+            >>> import numpy as np
+            >>> import mindspore
+            >>> from mindspore import Tensor
+            >>> x = Tensor(np.array([[1, 2, 3], [4, 5, 6]]).astype(np.int32))
+            >>> values = Tensor(np.array([3]).astype(np.int32))
+            >>> indices = [Tensor(np.array([0, 1, 1]).astype(np.int32)), Tensor(np.array([1, 2, 1]).astype(np.int32))]
+            >>> accumulate = True
+            >>> x.index_put_(indices, values, accumulate)
+            >>> print(x)
+            [[1 5 3]
+             [4 8 9]]
+        """
+        index_put_ = tensor_operator_registry.get('index_put_')
+        return index_put_(self, indices, values, accumulate)
+
     def move_to(self, to, blocking=True):
         r"""
         Copy Tensor to target device synchronously or asynchronously, default synchronously. only support PyNative mode.
@@ -4916,6 +4239,62 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return Tensor_._offload(self)
 
+    def _data_ptr(self):
+        r"""
+        Get the data ptr address of tensor, for CPU is host address, GPU/NPU is device address.
+        User should know how to use the data ptr address.
+        Note: this api is an experimental api, users need understatnd it before use.
+
+        Supported Platforms:
+            ``CPU/GPU/Ascend``
+
+        Examples:
+            >>> import mindspore as ms
+            >>> from mindspore import Tensor
+            >>> x = ms.Tensor([1, 2, 3], ms.int64)
+            >>> data_ptr = x._data_ptr()
+        """
+        return Tensor_._data_ptr(self)
+
+    def normal_(self, mean=0, std=1, *, generator=None):
+        r"""
+        Update the `self` tensor in place by generating random numbers sampled from the normal
+        distribution which constructed by the parameters `mean` and `std`.
+
+        .. warning::
+            This is an experimental API that is subject to change or deletion.
+
+        Args:
+            mean (number, optional): the mean of normal distribution. With float data type.
+                Default: ``0``.
+            std (number, optional): the std of normal distribution. With float data type.
+                Default: ``1``.
+
+        Keyword Args:
+            generator (:class:`mindspore.Generator`, optional): a pseudorandom number generator.
+                Default: ``None``, uses the default pseudorandom number generator.
+
+        Returns:
+            A tensor that is filled with random numbers that follow a normal distribution and
+            that has the same type and shape as the `self` tensor.
+
+        Raises:
+            TypeError: If the dtype of `mean` or `std` is not one of: bool, int, float, complex.
+
+        Supported Platforms:
+            ``Ascend``
+
+        Examples:
+            >>> import mindspore
+            >>> import numpy as np
+            >>> x = mindspore.Tensor(np.array([[1, 2], [3, 4]]), dtype=mindspore.float32)
+            >>> output = x.normal_()
+            >>> print(output)
+            [[0.2788825 1.3305743]
+             [1.244194 1.16303174]]
+        """
+        return tensor_operator_registry.get('normal_')(self, mean=mean, std=std, generator=generator)
+
 
 def _vm_compare(*args):
     """Implement `vm_compare` for tensor."""
@@ -4926,12 +4305,16 @@ def _vm_compare(*args):
     if obj_str == "shape":
         fn = getattr(args[0].asnumpy(), obj_str)
         return fn
-    if obj_str == "__setitem__":
-        fn = getattr(args[0].asnumpy(), obj_str)
+    if obj_str == "_tensor_setitem" or obj_str == "_tensor_setitem_origin":
+        fn = getattr(args[0].asnumpy(), "__setitem__")
         index = args[1].asnumpy() if isinstance(args[1], Tensor) else args[1]
         value = args[2].asnumpy() if isinstance(args[2], Tensor) else args[2]
         fn(index, value)
         return args[0]
+    if obj_str == "_tensor_getitem" or obj_str == "_tensor_getitem_origin":
+        fn = getattr(args[0].asnumpy(), "__getitem__")
+        index = args[1].asnumpy() if isinstance(args[1], Tensor) else args[1]
+        return Tensor(np.array(fn(index)))
     if len(args) == 2:
         fn = getattr(args[0].asnumpy(), obj_str)
         return Tensor(fn())
@@ -4955,20 +4338,13 @@ def _check_tensor_input(input_data=None, dtype=None, shape=None, init=None):
         raise ValueError("init, dtype and shape must have values at the same time.")
 
     if input_data is not None:
-        if isinstance(input_data, np.ndarray) and input_data.ndim >= 1 and input_data.size == 0:
-            raise ValueError("input_data can not contain zero dimension.")
         if isinstance(input_data, (tuple, list)):
             try:
-                np_data = np.array(input_data)
+                _ = np.array(input_data)
             except ValueError as e:
                 if "The requested array has an inhomogeneous shape" in str(e):
                     raise TypeError(f"For Tensor, the input_data is {input_data} that contain unsupported element.")
                 raise
-            if np_data.ndim >= 1 and np_data.size == 0:
-                raise ValueError("input_data can not contain zero dimension.")
-
-    if shape is not None and not (hasattr(init, "__enable_zero_dim__") and init.__enable_zero_dim__) and 0 in shape:
-        raise ValueError("Shape can not contain zero value.")
 
 
 def _check_tensor_dynamic_shape(dtype=None, shape=None, init=None):