mindspore 2.4.10__cp39-cp39-win_amd64.whl → 2.6.0rc1__cp39-cp39-win_amd64.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._c_expression import TensorPy as TensorPy_
 from mindspore import _checkparam as validator
-from mindspore._checkparam import check_is_number, is_stub_tensor, check_hook_fn
+from mindspore._checkparam import 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)
@@ -46,8 +45,8 @@ 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),
+    validator.check_value_type('input_data', input_data, (TensorPy_, 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)
@@ -73,13 +72,116 @@ def _check_input_data_type(input_data):
             f"For Tensor, the input_data is {input_data} that contain unsupported element.")
 
 
-class _TensorMeta(type(Tensor_), abc.ABCMeta):
+def _set_symbolic_shape(shape):
+    """Set symbolic_shape"""
+    symbolic_shape = None
+    if shape is None:
+        return None, None
+    if isinstance(shape, numbers.Number):
+        shape = (shape,)
+        symbolic_shape = None
+        return shape, symbolic_shape
+    if isinstance(shape, Symbol):
+        symbolic_shape = [shape]
+        shape = (None,)
+        return shape, symbolic_shape
+    if isinstance(shape, (list, tuple)) and any(isinstance(s, Symbol) for s in shape):
+        symbolic_shape = [item.to_dict() if isinstance(item, Symbol) else item for item in shape]
+        shape_without_symbol = (None if isinstance(item, Symbol) else item for item in shape)
+        shape = list(shape_without_symbol) if isinstance(shape, list) else tuple(shape_without_symbol)
+        return shape, symbolic_shape
+    return shape, symbolic_shape
+
+
+def _convert_stub_tensor(input_data):
+    """Convert input to stub tensor"""
+    if not is_stub_tensor(input_data):
+        return input_data
+    return input_data.stub_sync()
+
+
+def _convert_numpy_array(input_data):
+    """Convert inpyt to numpy array"""
+    if not isinstance(input_data, np_types):
+        return input_data
+    return np.array(input_data)
+
+
+def _check_device(device):
+    """Check device"""
+    if device is not None and device != "CPU":
+        raise ValueError(f"Only 'CPU' is supported for device, but got {device}.")
+
+
+def _set_default_dtype(input_data, dtype):
+    """Set tensor default dtype"""
+    if isinstance(input_data, (float, list, tuple)):
+        if np.array(input_data).dtype == np.float64:
+            return mstype.float32
+    if isinstance(input_data, (int, list, tuple)):
+        if np.array(input_data).dtype in (np.int32, np.int64):
+            return mstype.int64
+    return dtype
+
+
+def _set_dtype(input_data, dtype):
+    """Set and check dtype"""
+    if dtype is not None:
+        validator.check_type_name('dtype', dtype, mstype.number_type + (mstype.bool_, mstype.string), "Tensor")
+        return dtype
+    return _set_default_dtype(input_data, dtype)
+
+
+def _init(input_data=None, dtype=None, shape=None, init=None, const_arg=False, device=None):
     """
-    Meta class for Tensor. Used internally.
+    Verifying parameters. Will sink to C++
     """
+    validator.check_value_type('const_arg', const_arg, bool, 'Tensor')
+    _check_device(device)
+
+    if isinstance(input_data, (Tensor, TensorPy_)) and dtype is not None:
+        logger.info("It is suggested to use 'Tensor.astype()' to convert the dtype of a Tensor.")
+        _cast = tensor_operator_registry.get("cast")
+        input_data = _cast(input_data, dtype)
+
+    input_data = _convert_stub_tensor(input_data)
+
+    if input_data is None and shape is None and init is None and dtype is not None:
+        validator.check_type_name('dtype', dtype, mstype.number_type + (mstype.bool_, mstype.string), "Tensor")
+        logger.warning(f"For 'Tensor', if 'dtype' is not None, 'input_data', 'shape' or 'init' must not be None.")
+        return {"dtype": dtype, "shape": [-2], "init": init, "const_arg": const_arg, "device": device}
+
+    # If input data is numpy number, convert it to np array
+    input_data = _convert_numpy_array(input_data)
+    shape, symbolic_shape = _set_symbolic_shape(shape)
+    _check_tensor_input(input_data, dtype, shape, init)
+
+    # If input_data is tuple/list/numpy.ndarray, it's support in check_type method.
+    if (isinstance(shape, (list, tuple)) and None in shape) or init is not None:
+        shape = _check_tensor_dynamic_shape(dtype, shape, init)
+        return {"dtype": dtype, "shape": shape, "init": init, "const_arg": const_arg, "device": device,
+                "symbolic_shape": symbolic_shape}
+
+    if input_data is None and dtype is not None and shape is not None:
+        validator.check_type_name('dtype', dtype, mstype.number_type + (mstype.bool_, mstype.string), "Tensor")
+        return {"dtype": dtype, "shape": shape, "init": init, "const_arg": const_arg, "device": device,
+                "symbolic_shape": symbolic_shape}
+
+    _check_input_data_type(input_data)
+    dtype = _set_dtype(input_data, dtype)
+
+    if isinstance(input_data, np.ndarray) and (not input_data.flags['FORC']):
+        input_data = np.ascontiguousarray(input_data)
 
+    if dtype is not None:
+        return {"input_data": input_data, "dtype": dtype, "init": init, "const_arg": const_arg, "device": device,
+                "symbolic_shape": symbolic_shape}
 
-def tensor(input_data=None, dtype=None, shape=None, init=None, internal=False, const_arg=False):
+    return {"input_data": input_data, "init": init, "const_arg": const_arg, "device": device,
+            "symbolic_shape": symbolic_shape}
+
+
+def tensor(input_data=None, dtype=None, shape=None, init=None, const_arg=False):
     """
     Create a new Tensor in Cell.construct() or function decorated by @jit.
 
@@ -87,11 +189,11 @@ def tensor(input_data=None, dtype=None, shape=None, init=None, internal=False, c
     based on the `dtype` argument.
 
     Please refer to `Creating and Using Tensor
-    <https://www.mindspore.cn/docs/en/master/model_train/program_form/static_graph.html#mindspore-user-defined-data-types>`_ .
+    <https://www.mindspore.cn/tutorials/en/master/compile/static_graph.html#mindspore-user-defined-data-types>`_ .
 
     The difference between it and the Tensor class is that it adds
     `Annotation
-    <https://www.mindspore.cn/docs/en/master/model_train/program_form/static_graph.html#annotation-type>`_
+    <https://www.mindspore.cn/tutorials/en/master/compile/static_graph.html#annotation-type>`_
     which can prevent the generation of AnyType compared to the Tensor class.
 
     The arguments and return values are the same as the Tensor class. Also see: :class:`mindspore.Tensor`.
@@ -111,20 +213,29 @@ def tensor(input_data=None, dtype=None, shape=None, init=None, internal=False, c
         >>> print(y)
         [1. 2. 3.]
     """
-    return Tensor(input_data, dtype, shape, init, internal, const_arg)  # @jit.typing: () -> tensor_type[{dtype}]
+    return Tensor(input_data, dtype, shape, init, const_arg)  # @jit.typing: () -> tensor_type[{dtype}]
+
+
+class _TensorMeta(abc.ABCMeta, type(TensorPy_)):
+    """
+    Meta class for Tensor. Used internally.
+    """
 
 
-class Tensor(Tensor_, metaclass=_TensorMeta):
+class Tensor(TensorPy_, 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/tutorials/en/master/compile/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
-          `Tensor(sourceTensor, dtype=newDtype)`.
+        To convert dtype of a `Tensor`, it is recommended to use `Tensor.astype()` rather than
+        `Tensor(sourceTensor, dtype=newDtype)`.
 
     Args:
         input_data (Union[Tensor, float, int, bool, tuple, list, numpy.ndarray]): The data to be stored. It can be
@@ -139,10 +250,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         init (Initializer): The information of init data.
             `init` is used for delayed initialization in parallel mode, when using init, `dtype` and `shape` must be
             set. Default: ``None`` .
-        internal (bool): Whether it is created by the framework.
-            ``'True'`` means that the tensor is created by framework.
-            ``'False'`` means that the tensor is created by user.
-            Default: ``False`` .
         const_arg (bool): Whether the tensor is a constant when it is used for the argument of a network.
             Default: ``False`` .
         device(str): This parameter is reserved and does not need to be configured.
@@ -153,8 +260,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
     Note:
         The default value ``None`` of `input_data` works as a placeholder,
-        it does not mean that we can create a NoneType
-        Tensor.
+        it does not mean that we can create a NoneType Tensor.
         Tensor with `shape` contains 0 is not fully tested and supported.
 
     Examples:
@@ -209,89 +315,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
     """
     delta_seed = 0
 
-    def __init__(self, input_data=None, dtype=None, shape=None, init=None, internal=False, const_arg=False,
-                 device=None):
-        self.init_finished = False
-        if isinstance(input_data, (Tensor, Tensor_)) and dtype is not None:
-            logger.info("It is suggested to use 'Tensor.astype()' to convert the dtype of a Tensor.")
-            _cast = tensor_operator_registry.get("cast")
-            input_data = _cast(input_data, dtype)
-
-        if is_stub_tensor(input_data):
-            input_data = input_data.stub_sync()
-
-        if internal:
-            if input_data is not None:
-                Tensor_.__init__(self, input_data)
-        else:
-            if input_data is None and shape is None and init is None and dtype is not None:
-                validator.check_type_name('dtype', dtype, mstype.number_type +
-                                          (mstype.bool_, mstype.string), "Tensor")
-                Tensor_.__init__(self, dtype, [-2])
-                logger.warning(f"For 'Tensor', if 'dtype' is not None, 'input_data', 'shape' "
-                               f"or 'init' must not be None.")
-            else:
-                # If input data is numpy number, convert it to np array
-                if isinstance(input_data, np_types):
-                    input_data = np.array(input_data)
-
-                if shape is not None:
-                    if isinstance(shape, numbers.Number):
-                        shape = (shape,)
-                    elif isinstance(shape, Symbol):
-                        self.symbolic_shape = [shape]
-                        shape = (None,)
-                    elif isinstance(shape, (list, tuple)) and any(isinstance(s, Symbol) for s in shape):
-                        self.symbolic_shape = [item.to_dict() if isinstance(item, Symbol) else item for item in shape]
-                        shape_without_symbol = (None if isinstance(item, Symbol) else item for item in shape)
-                        shape = list(shape_without_symbol) if isinstance(shape, list) else tuple(shape_without_symbol)
-
-                _check_tensor_input(input_data, dtype, shape, init)
-
-                # If input_data is tuple/list/numpy.ndarray, it's support in check_type method.
-                if (isinstance(shape, (list, tuple)) and None in shape) or init is not None:
-                    shape = _check_tensor_dynamic_shape(dtype, shape, init)
-                    Tensor_.__init__(self, dtype, shape)
-                else:
-                    _check_input_data_type(input_data)
-                    if dtype is not None:
-                        validator.check_type_name('dtype', dtype, mstype.number_type +
-                                                  (mstype.bool_, mstype.string), "Tensor")
-                    else:
-                        dtype = self._set_default_dtype(input_data, dtype)
-
-                    if isinstance(input_data, np.ndarray) and (not input_data.flags['FORC']):
-                        input_data = np.ascontiguousarray(input_data)
-
-                    if dtype is not None:
-                        Tensor_.__init__(self, input_data, dtype)
-                    else:
-                        Tensor_.__init__(self, input_data)
-                    validator.check_value_type('const_arg', const_arg, bool, 'Tensor')
-
-        if device is not None and device != "CPU":
-            raise ValueError(f"Only 'CPU' is supported for device, but got {device}.")
-
-        self.const_arg = const_arg
-        self.virtual_flag = False
-        self.init = init
-        self.init_finished = True
-
-        # if cur Tensor is a index value of another Tensor,
-        # parent_tensor_ set to another Tensor
-        # index_of_parent_ will set to the index
-        self.parent_tensor_ = None
-        self.index_of_parent_ = None
-
-        self.slice_num_of_persistent_data_ = None
-        self.slice_shape_of_persistent_data_ = None
-
-        # the auto gradient information
-        self._grad = None
-        self._grad_fn = None
-        self._requires_grad = False
-        self._retain_grad = False
-
     @classmethod
     def __subclasshook__(cls, sub):
         """
@@ -302,16 +325,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
                 return True
         return NotImplemented
 
-    @staticmethod
-    def _set_default_dtype(input_data, dtype):
-        """Set tensor default dtype"""
-        if isinstance(input_data, (float, list, tuple)):
-            if np.array(input_data).dtype == np.float64:
-                return mstype.float32
-        if isinstance(input_data, (int, list, tuple)):
-            if np.array(input_data).dtype in (np.int32, np.int64):
-                return mstype.int64
-        return dtype
 
     def __deepcopy__(self, memodict):
         new_obj = Tensor(self)
@@ -322,8 +335,8 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
     def __repr__(self):
         if self.init_finished:
-            Tensor_.data_sync(self, True)
-            return Tensor_.__repr__(self)
+            TensorPy_.data_sync(self, True)
+            return TensorPy_.__repr__(self)
         return ''
 
     def __eq__(self, other):
@@ -352,12 +365,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):
@@ -368,79 +376,50 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         raise ValueError(message)
 
     def __int__(self):
-        data = self.asnumpy()
-        return self._convert_scalar_(data, int, "Only one element tensors can be converted to Python scalars")
+        try:
+            data = self._item()
+            return int(data)
+        except ValueError:
+            raise ValueError("Only one element tensors can be converted to Python scalars")
+
 
     def __float__(self):
-        data = self.asnumpy()
-        return self._convert_scalar_(data, float, "Only one element tensors can be converted to Python scalars")
+        try:
+            data = self._item()
+            return float(data)
+        except ValueError:
+            raise ValueError("Only one element tensors can be converted to Python scalars")
 
     def __index__(self):
-        data = self.asnumpy()
-        if data.dtype not in ["int8", "int16", "int32", "int64", "bool"]:
+        try:
+            data = self._item()
+            if not isinstance(data, (int, bool)):
+                raise ValueError
+            return int(data)
+        except ValueError:
             raise ValueError("Only integer tensors of a single element can be converted to an index.")
-        return self._convert_scalar_(data, int,
-                                     "Only integer tensors of a single element can be converted to an index.")
 
     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)
-        raise TypeError("Unsupported operand type(s) for &: 'Tensor' and '{}'".format(type(other)))
-
-    def __xor__(self, other):
-        if isinstance(other, (int, bool, float, Tensor)):
-            return tensor_operator_registry.get('bitwise_xor')(self, other)
-        raise TypeError("Unsupported operand type(s) for ^: 'Tensor' and '{}'".format(type(other)))
-
-    def __or__(self, other):
-        if isinstance(other, (int, bool, float, Tensor)):
-            return tensor_operator_registry.get('bitwise_or')(self, other)
-        raise TypeError("Unsupported operand type(s) for |: 'Tensor' and '{}'".format(type(other)))
-
     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)
 
     def __rmatmul__(self, other):
         return tensor_operator_registry.get('__matmul__')(other, self)
 
-    def __imatmul__(self, other):
-        return self.__matmul__(other)
-
     def __truediv__(self, other):
         return tensor_operator_registry.get('__truediv__')(self, other)
 
@@ -456,9 +435,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)
 
@@ -468,9 +444,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
     def __rfloordiv__(self, other):
         return tensor_operator_registry.get('__floordiv__')(other, self)
 
-    def __ifloordiv__(self, other):
-        return self.__floordiv__(other)
-
     def __lt__(self, other):
         out = tensor_operator_registry.get('__lt__')(self, other)
         return out
@@ -479,25 +452,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
@@ -519,7 +473,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
     def __getstate__(self):
         state = self.__dict__.copy()
-        state["value"] = Tensor_.__getstate__(self)
+        state["value"] = TensorPy_.__getstate__(self)
         return state
 
     def __setstate__(self, state):
@@ -528,12 +482,96 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         else:
             value = state.pop("value")
             self.__dict__.update(state)
-        Tensor_.__setstate__(self, value)
+        TensorPy_.__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 _dtensor_info(self):
+        """
+        Return the distributed tensor information. For details,
+        please refer to :class:`mindspore.parallel.DistributedTensorInfo`.
+
+        Examples:
+            >>> from mindspore import Tensor
+            >>> import numpy as np
+            >>> x = Tensor(np.array([[1, 2], [3, 4]]))
+            >>> print(x._dtensor_info)
+            None
+        """
+        if not hasattr(self, '_dist_tensor_info'):
+            self._dist_tensor_info = None
+        return self._dist_tensor_info
+
+    @_dtensor_info.setter
+    def _dtensor_info(self, input_dtensor_info):
+        """
+        Set the distributed tensor information to current tensor.
+
+        Args:
+            input_dtensor_info (DistributedTensorInfo): The distributed tensor information.
+
+        Examples:
+            >>> from mindspore import Tensor, Layout, _DistributedTensorInfo
+            >>> import numpy as np
+            >>> layout = Layout((2, 2), ("dp", "mp"))
+            >>> src_layout = layout("dp", "mp")
+            >>> distributed_info = _DistributedTensorInfo(src_layout)
+            >>> x = Tensor(np.array([[1, 2], [3, 4]]))
+            >>> x._dtensor_info = distributed_info
+        """
+        self._dist_tensor_info = input_dtensor_info
 
     @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 +584,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
@@ -579,83 +626,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return len(self._shape)
 
-    @property
-    def grad(self):
-        r"""
-        Get the gradient value.
-        """
-        return self._grad
-
-    @grad.setter
-    def grad(self, grad):
-        r"""
-        Set the gradient value.
-        """
-        self._grad = grad
-
-    @property
-    def grad_fn(self):
-        r"""
-        The function for backward.
-        """
-        return self._grad_fn
-
-    @grad_fn.setter
-    def grad_fn(self, grad_fn):
-        r"""
-        Set the function for backward.
-        """
-        self._grad_fn = grad_fn
-
-    @property
-    def is_leaf(self):
-        r"""
-        Whether the stub tensor is leaf.
-        They will be a leaf if they have requires_grad and requires_grad is False,
-        Or they were created by user.
-        """
-        return self._requires_grad is False or self._grad_fn is None
-
-    @property
-    def requires_grad(self):
-        r"""
-        Whether the stub tensor need requires grad.
-        """
-        return self._requires_grad
-
-    @requires_grad.setter
-    def requires_grad(self, requires_grad):
-        r"""
-        Mark the stub tensor whether need requires gradient.
-        """
-        self._requires_grad = requires_grad
-
-    def retain_grad(self):
-        r"""
-        Enable the stub tensor which is not non-leaf to have the grad during backward().
-        """
-        if not self._requires_grad:
-            RuntimeError("can't retain_grad on Tensor that has requires_grad = False.")
-        self._retain_grad = self._grad_fn is not None
-
-    @property
-    def retains_grad(self):
-        r"""
-        Is True if the stub tensor is non-leaf and its grad is enabled to be populated during backward().
-        """
-        return self._retain_grad
-
-    def backward(self, grad=None):
-        r"""
-        Calculate the gradient.
-        """
-        if grad is None:
-            grad = Tensor(np.ones(self.shape), self.dtype)
-        if self._grad_fn is not None:
-            self._grad_fn.apply(grad)
-        elif self._requires_grad:
-            self._grad = grad
-
     @property
     def H(self):
         """
@@ -785,11 +755,11 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         if isinstance(array, np.ndarray) and not array.flags['C_CONTIGUOUS']:
             array = np.ascontiguousarray(array)
 
-        return Tensor(Tensor_.from_numpy(array))
+        return TensorPy_.from_numpy(array)
 
     def ndimension(self):
         r"""
-        Alias for :func:`mindspore.Tensor.ndim`.
+        Alias for :attr:`mindspore.Tensor.ndim`.
         """
         return len(self._shape)
 
@@ -821,30 +791,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 +888,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`.
-        """
-        return tensor_operator_registry.get('chunk')(self, chunks, axis)
-
-    @item_mint
-    def item(self, index=None):
+    def item(self):
         """
-        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 +906,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 +922,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.
@@ -1044,7 +968,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(x.get_bytes())
             b'\x01\x00\x02\x00\x03\x00'
         """
-        return Tensor_.get_bytes(self)
+        return TensorPy_.get_bytes(self)
 
     def asnumpy(self):
         """
@@ -1067,9 +991,9 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         if self.has_init:
             self.init_data()
-        return Tensor_.asnumpy(self)
+        return TensorPy_.asnumpy(self)
 
-    def numpy(self, *, force=False):
+    def numpy(self):
         """
         Alias for :func:`mindspore.Tensor.asnumpy`.
         """
@@ -1084,7 +1008,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         Returns:
             True or False
         """
-        return Tensor_.is_persistent_data(self)
+        return TensorPy_.is_persistent_data(self)
 
     def asnumpy_of_slice_persistent_data(self, param_key, slice_index):
         """
@@ -1095,7 +1019,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         Returns:
             A numpy ndarray which shares the same underlying storage with the slice of tensor data.
         """
-        return Tensor_.asnumpy_of_slice_persistent_data(self, param_key, slice_index)
+        return TensorPy_.asnumpy_of_slice_persistent_data(self, param_key, slice_index)
 
     def slice_num_of_persistent_data(self):
         """
@@ -1118,14 +1042,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 +1091,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):
@@ -1193,7 +1111,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(y.is_contiguous())
             False
         """
-        return Tensor_.is_contiguous(self)
+        return TensorPy_.is_contiguous(self)
 
     def stride(self, dim=None):
         """
@@ -1201,10 +1119,10 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         When no parameters are passed in, a list of stride for all dimensions is returned.
 
         Args:
-            dim (int): The dim of stride from one element to the next.
+            dim (int, optional): The dim of stride from one element to the next. Default: ``None``.
 
         Returns:
-            Int, the stride of tensor.
+            Int, returns the step size necessary to jump from one element to the next in the specified dimension.
 
         Raises:
             TypeError: `dim` is not an int.
@@ -1215,7 +1133,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> x.stride()
             [5, 1]
         """
-        stride = Tensor_.stride(self)
+        stride = TensorPy_.stride(self)
         if dim is None:
             return stride
         return stride[dim]
@@ -1234,28 +1152,35 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(ret)
             0
         """
-        return Tensor_.storage_offset(self)
+        return TensorPy_.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.
+            - Higher-order differentiation does not support tensor `register_hook`.
+            - The following constraints must be met under graph mode:
+
+              - The `hook` must satisfy the syntax constraints of the graph mode.
+              - It is not supported to delete `hook` inside graph.
+              - It is not supported to register `hook` after the `Tensor` is used before.
+              - It is not supported to register multiple `hooks` for a `Tensor` 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 +1203,14 @@ 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)
+        check_hook_fn(hook)
+        handle = _TensorHookHandle(self)
+        handle.id = TensorPy_.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.
@@ -1296,13 +1223,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(y)
             None
         """
-        Tensor_._flush_from_cache(self)
-
-    def addcdiv(self, tensor1, tensor2, value=1):
-        r"""
-        For details, please refer to :func:`mindspore.ops.addcdiv`.
-        """
-        return tensor_operator_registry.get('addcdiv')(self, tensor1, tensor2, value)
+        TensorPy_._flush_from_cache(self)
 
     def addcmul(self, tensor1, tensor2, value=1):
         r"""
@@ -1310,94 +1231,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,38 +1252,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`.
-        """
-        return tensor_operator_registry.get('baddbmm')(self, batch1, batch2, beta=beta, alpha=alpha)
-
     def view(self, *shape):
         """
         Reshape the tensor according to the input shape. It's the same as :func:`mindspore.Tensor.reshape`,
@@ -1474,64 +1287,11 @@ 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`.
-        """
-        return tensor_operator_registry.get('bitwise_and')(self, other)
-
-    def bitwise_or(self, other):
-        """
-        For details, please refer to :func:`mindspore.ops.bitwise_or`.
-        """
-        return tensor_operator_registry.get('bitwise_or')(self, other)
-
-    def bitwise_xor(self, other):
-        """
-        For details, please refer to :func:`mindspore.ops.bitwise_xor`.
-        """
-        return tensor_operator_registry.get('bitwise_xor')(self, other)
-
-    def bitwise_left_shift(self, other):
-        """
-        For details, please refer to :func:`mindspore.ops.bitwise_left_shift`.
-        """
-        return tensor_operator_registry.get('bitwise_left_shift')(self, other)
+    def bitwise_left_shift(self, other):
+        """
+        For details, please refer to :func:`mindspore.ops.bitwise_left_shift`.
+        """
+        return tensor_operator_registry.get('bitwise_left_shift')(self, other)
 
     def bitwise_right_shift(self, other):
         """
@@ -1541,12 +1301,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,126 +1319,55 @@ 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`.
-        """
-        return tensor_operator_registry.get('ge')(self, x)
-
     def broadcast_to(self, shape):
         """
         For details, please refer to :func:`mindspore.ops.broadcast_to`.
         """
         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,62 +1375,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)
-
-    def floor(self):
-        """
-        For details, please refer to :func:`mindspore.ops.floor`.
-        """
-        return tensor_operator_registry.get('floor')(self)
-
-    def floor_divide(self, other):
-        """
-        For details, please refer to :func:`mindspore.ops.floor_divide`.
+        In-place version of :func:`mindspore.Tensor.floor`.
 
         .. warning::
             This is an experimental API that is subject to change or deletion.
         """
-        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)
+        return tensor_operator_registry.get('floor_')(self)
 
     # pylint: disable=redefined-builtin
     def norm(self, ord=None, dim=None, keepdim=False, *, dtype=None):
@@ -1764,7 +1399,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 +1411,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`.
@@ -1790,18 +1420,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         validator.check_value_type('eps', eps, (float,), 'Tensor.logit')
         return tensor_operator_registry.get('logit')(self, eps)
 
-    def logaddexp(self, other):
-        r"""
-        For details, please refer to :func:`mindspore.ops.logaddexp`.
-        """
-        return tensor_operator_registry.get('logaddexp')(self, other)
-
-    def logaddexp2(self, other):
-        r"""
-        For details, please refer to :func:`mindspore.ops.logaddexp2`.
-        """
-        return tensor_operator_registry.get('logaddexp2')(self, other)
-
     def logcumsumexp(self, axis):
         r"""
         For details, please refer to :func:`mindspore.ops.logcumsumexp`.
@@ -1811,12 +1429,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('logcumsumexp')(self, axis)
 
-    def logsumexp(self, axis, keepdims=False):
-        r"""
-        For details, please refer to :func:`mindspore.ops.logsumexp`.
-        """
-        return tensor_operator_registry.get('logsumexp')(self, axis, keepdims)
-
     def logdet(self):
         r"""
         For details, please refer to :func:`mindspore.ops.logdet`.
@@ -1825,22 +1437,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,67 +1453,18 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('isreal')(self)
 
-    def isfinite(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`.
-        """
-        return tensor_operator_registry.get('is_complex')(self)
-
     def inv(self):
         r"""
         For details, please refer to :func:`mindspore.ops.inv`.
         """
         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 +1476,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 +1500,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,18 +1558,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`.
-        """
-        return tensor_operator_registry.get('roll')(shifts, dims)(self)
-
     def rot90(self, k, dims):
         r"""
         For details, please refer to :func:`mindspore.ops.rot90`.
@@ -2102,18 +1570,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 +1586,18 @@ 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`.
         """
-        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 +1609,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 +1623,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 +1651,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,66 +1690,53 @@ 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:
-            - In auto_parallel and semi_auto_parallel mode, the first output index can not be used.
-            - If there are multiple maximum values, the index of the first maximum value is used.
-            - The value range of `axis` is [-dims, dims - 1]. `dims` is the dimension length of this tensor.
+        Return the maximum values and their indices along the given axis of the 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 (Union[int, None], optional): Specify the axis for computation. If ``None`` , compute all elements in
+                the tensor. Default ``0`` .
+            keep_dims (bool, optional): Whether the output tensor has dim retained. Default ``False`` .
 
         Returns:
-            tuple (Tensor), tuple of 2 tensors, containing the corresponding index and the maximum value of the input
-            tensor.
-
-            - **index** (Tensor) - The index for the maximum value of the input tensor.
-              If `keep_dims` is ``true`` , the shape of
-              output tensors is :math:`(x_1, x_2, ..., x_{axis-1}, 1, x_{axis+1}, ..., x_N)`. Otherwise, the shape is
-              :math:`(x_1, x_2, ..., x_{axis-1}, x_{axis+1}, ..., x_N)` .
-            - **value** (Tensor) - The maximum value of input tensor, with the same shape as index.
-
-        Raises:
-            TypeError: If `keep_dims` is not a bool.
-            TypeError: If `axis` is not an int.
+            Tuple(max, max_indices) of 2 tensors.
 
         Supported Platforms:
             ``Ascend`` ``GPU`` ``CPU``
 
         Examples:
-            >>> import numpy as np
             >>> import mindspore
-            >>> from mindspore import Tensor
-            >>> x = Tensor(np.array([0.0, 0.4, 0.6, 0.7, 0.1]), mindspore.float32)
-            >>> output, index = x.argmax_with_value()
-            >>> print(output, index)
-            0.7 3
-            >>> output, index = x.argmax_with_value(keep_dims=True)
-            >>> print(output, index)
-            [0.7] [3]
+            >>> x = mindspore.tensor([[9, 3, 4, 5],
+            ...                       [5, 2, 7, 4],
+            ...                       [8, 1, 3, 6]])
+            >>> # case 1: By default, compute the maximum along axis 0.
+            >>> x.argmax_with_value()
+            (Tensor(shape=[4], dtype=Int64, value= [9, 3, 7, 6]),
+             Tensor(shape=[4], dtype=Int64, value= [0, 0, 1, 2]))
+            >>>
+            >>> # case 2: Compute the maximum along axis 1.
+            >>> x.argmax_with_value(axis=1)
+            (Tensor(shape=[3], dtype=Int64, value= [9, 7, 8]),
+             Tensor(shape=[3], dtype=Int64, value= [0, 2, 0]))
+            >>>
+            >>> # case 3: If keep_dims=True, the output shape will be same of that of the input.
+            >>> x.argmax_with_value(axis=1, keep_dims=True)
+            (Tensor(shape=[3, 1], dtype=Int64, value=
+             [[9],
+              [7],
+              [8]]),
+             Tensor(shape=[3, 1], dtype=Int64, value=
+             [[0],
+              [2],
+              [0]]))
+            >>>
+            >>> # case 4: If axis=None, compute the maximum of all elements.
+            >>> x.argmax_with_value(axis=None, keep_dims=True)
+            (Tensor(shape=[], dtype=Int64, value= 9),
+             Tensor(shape=[], dtype=Int64, value= 0))
         """
         if self.shape == ():
             return (self, Tensor(0))
@@ -2338,68 +1744,54 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
     def argmin_with_value(self, axis=0, keep_dims=False):
         """
-        Returns the minimum value with corresponding index.
-
-        Note:
-            - In auto_parallel and semi_auto_parallel mode, the first output index can not be used.
-            - If there are multiple minimum values, the index of the first minimum value is used.
-            - The value range of `axis` is [-dims, dims - 1]. `dims` is the dimension length of this tensor.
+        Return the minimum values and their indices along the given axis of the 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 (Union[int, None], optional): Specify the axis for computation. If ``None`` , compute all elements in
+                the tensor. Default ``0`` .
+            keep_dims (bool, optional): Whether the output tensor has dim retained. Default ``False`` .
 
         Returns:
-            tuple (Tensor), tuple of 2 tensors, containing the corresponding index and the minimum value of the input
-            tensor.
-
-            - **index** (Tensor) - The index for the minimum value of the input tensor.
-              If `keep_dims` is true, the shape of
-              output tensors is :math:`(x_1, x_2, ..., x_{axis-1}, 1, x_{axis+1}, ..., x_N)`. Otherwise, the shape is
-              :math:`(x_1, x_2, ..., x_{axis-1}, x_{axis+1}, ..., x_N)` .
-            - **value** (Tensor) - The minimum value of input tensor, with the same shape as index.
-
-        Raises:
-            TypeError: If `keep_dims` is not a bool.
-            TypeError: If `axis` is not an int.
+            Tuple(min, min_indices) of 2 tensors.
 
         Supported Platforms:
             ``Ascend`` ``GPU`` ``CPU``
 
         Examples:
-            >>> import numpy as np
             >>> import mindspore
-            >>> from mindspore import Tensor
-            >>> x = Tensor(np.array([0.0, 0.4, 0.6, 0.7, 0.1]), mindspore.float32)
-            >>> output, index = x.argmin_with_value()
-            >>> print(output, index)
-            0.0 0
-            >>> output, index = x.argmin_with_value(keep_dims=True)
-            >>> print(output, index)
-            [0.0] [0]
+            >>> x = mindspore.tensor([[2, 5, 1, 6],
+            ...                       [3, -7, -2, 4],
+            ...                       [8, -4, 1, -3]])
+            >>> # case 1: By default, compute the minimum along axis 0.
+            >>> x.argmin_with_value()
+            (Tensor(shape=[4], dtype=Int64, value= [ 2, -7, -2, -3]),
+             Tensor(shape=[4], dtype=Int64, value= [0, 1, 1, 2]))
+            >>>
+            >>> # case 2: Compute the minimum along axis 1.
+            >>> x.argmin_with_value(axis=1)
+            (Tensor(shape=[3], dtype=Int64, value= [ 1, -7, -4]),
+             Tensor(shape=[3], dtype=Int64, value= [2, 1, 1]))
+            >>>
+            >>> # case 3: If keep_dims=True, the output shape will be same of that of the input.
+            >>> x.argmin_with_value(axis=1, keep_dims=True)
+            (Tensor(shape=[3, 1], dtype=Int64, value=
+             [[ 1],
+              [-7],
+              [-4]]),
+             Tensor(shape=[3, 1], dtype=Int64, value=
+             [[2],
+              [1],
+              [1]]))
+            >>>
+            >>> # case 4: If axis=None, compute the minimum of all elements.
+            >>> x.argmin_with_value(axis=None, keep_dims=True)
+            (Tensor(shape=[], dtype=Int64, value= -7),
+             Tensor(shape=[], dtype=Int64, value= 0))
         """
         if self.shape == ():
             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 +1810,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`.
@@ -2466,234 +1852,81 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         x = x.astype(origin_dtype)
         return x
 
-    def copy_(self, src, non_blocking=False):
+    def scatter_add_(self, dim, index, src):
         """
-        Copies the elements from src into self tensor and returns self.
+        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.
 
-        .. warning::
-            This is an experimental API that is subject to change or deletion.
-            The `src` tensor must be broadcastable with the `self` tensor. It may be of a different data type.
+        For a 3-D tensor, the operation updates `self` as follows:
 
-        Args:
-            src (Tensor): the source tensor to copy from.
-            non_blocking (bool): no effect currently.
+        .. code-block::
 
-        Returns:
-            Return self Tensor.
+            self[index[i][j][k]][j][k] += src[i][j][k]  # if dim == 0
 
-        Supported Platforms:
-            ``Ascend``
+            self[i][index[i][j][k]][k] += src[i][j][k]  # if dim == 1
 
-        Examples:
-            >>> import numpy as np
-            >>> from mindspore import Tensor
-            >>> a = Tensor(np.ones((3,3)).astype("float32"))
-            >>> b = Tensor(np.zeros((3,3)).astype("float32"))
-            >>> a.copy_(b)
-            >>> print(a)
-            [[0. 0. 0.]
-            [0. 0. 0.]
-            [0. 0. 0.]]
-        """
-        return tensor_operator_registry.get("copy_")(self, src)
-
-    @max_mint
-    def max(self, axis=None, keepdims=False, *, initial=None, where=True, return_indices=False):
-        """
-        Return the maximum of a tensor or maximum along an axis.
-
-        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): 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``.
-
-        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.min`: Return the minimum of a tensor or minimum along an axis.
-
-        Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
-
-        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.
-
-        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): 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):
         """
-        Creates a new tensor by subtracting the values from the positions in self tensor indicated by
-        `indices`, with values from `updates`. When multiple values are provided for the same
-        index, the result of the update will be to subtract these values respectively. This operation is almost
-        equivalent to using :class:`mindspore.ops.ScatterNdSub` , except that the updates are applied on output `Tensor`
-        instead of input `Parameter`.
-
-        The last axis of `indices` is the depth of each index vectors. For each index vector,
-        there must be a corresponding value in `updates`. The shape of `updates` should be
-        equal to the shape of `self[indices]`. For more details, see Examples.
-
-        Note:
-            On GPU, if some values of the `indices` are out of bound, instead of raising an index error,
-            the corresponding `updates` will not be updated to self tensor. On CPU, if some values of
-            the `indices` are out of bound, raising an index error. On Ascend, out of bound checking is
-            not supported, if some values of the `indices` are out of bound, unknown errors may be caused.
-
-        Args:
-            indices (Tensor): The index of input tensor whose data type is int32 or int64.
-                The rank must be at least 2.
-            updates (Tensor): The tensor to update the input tensor, has the same type as input,
-                and updates.shape should be equal to indices.shape[:-1] + self.shape[indices.shape[-1]:].
-
-        Returns:
-            Tensor, has the same shape and type as self tensor.
-
-        Raises:
-            TypeError: If dtype of `indices` is neither int32 nor int64.
-            ValueError: If length of shape of self tensor is less than the last dimension of shape of `indices`.
-
-        Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
-
-        Examples:
-            >>> import numpy as np
-            >>> from mindspore import Tensor
-            >>> x = Tensor(np.array([[-0.1, 0.3, 3.6], [0.4, 0.5, -3.2]]).astype('float32'))
-            >>> indices = Tensor(np.array([[0, 0], [0, 0]]).astype('int32'))
-            >>> updates = Tensor(np.array([1.0, 2.2]).astype('float32'))
-            >>> output = x.scatter_sub(indices, updates)
-            >>> print(output)
-            [[-3.3000002  0.3        3.6      ]
-            [ 0.4        0.5       -3.2      ]]
+        For details, please refer to :func:`mindspore.ops.tensor_scatter_sub`.
         """
         return tensor_operator_registry.get('tensor_scatter_sub')(self, indices, updates)
 
@@ -2774,18 +2007,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
@@ -2827,25 +2048,16 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             validator.check_axis_type(axis, True, True, False)
             axis = validator.check_axis_valid(axis, self.ndim)
 
-        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)
+        return self.max(axis, keepdims) - self.min(axis, keepdims)
 
-    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):
         """
@@ -2863,7 +2075,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             opt_shard_group(str): Optimizer shard group which is used in auto or semi auto parallel mode
                 to get one shard of a parameter's slice. For more information about optimizer parallel, please refer to:
                 `Optimizer Parallel
-                <https://www.mindspore.cn/docs/en/master/model_train/parallel/optimizer_parallel.html>`_.
+                <https://www.mindspore.cn/tutorials/en/master/parallel/optimizer_parallel.html>`_.
                 Default: ``None``.
 
         Returns:
@@ -2944,9 +2156,9 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
         # At embedding cache scenes. When size of tensor is out of range, we store data to persistent storage
         if slice_num_of_persistent_data > 1:
-            self.assign_value(Tensor_.persistent_data_from_numpy(data, slice_num_of_persistent_data))
+            self.assign_value(TensorPy_.persistent_data_from_numpy(data, slice_num_of_persistent_data))
         else:
-            self.assign_value(Tensor_.from_numpy(data))
+            self.assign_value(TensorPy_.from_numpy(data))
         return self
 
     def resize(self, *new_shape):
@@ -3007,7 +2219,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 +2229,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 +2255,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)
 
@@ -3102,73 +2310,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('tracev2')(self, offset, axis1, axis2, dtype)
 
-    def take(self, indices, axis=None, mode='clip'):
-        """
-        Takes elements from a tensor along an axis.
-
-        Args:
-            indices (Tensor): The indices with shape :math:`(Nj...)` of the values to extract.
-            axis (int, optional): The axis over which to select values. By default,
-                the flattened input tensor is used. Default: ``None`` .
-            mode (str, optional): Support ``'raise'``, ``'wrap'``, ``'clip'``.
-
-                - ``raise``: Raises an error;
-
-                - ``wrap``: Wraps around;
-
-                - ``clip``: Clips to the range. ``'clip'`` mode means that all indices that are
-                  too large are replaced by the index that addresses the last element
-                  along that axis. Note that this disables indexing with negative numbers.
-
-                Default: ``'clip'`` .
-
-        Returns:
-            Tensor, the indexed result.
-
-        Raises:
-            ValueError: If `axis` is out of range, or `mode` has values other than ('raise', 'wrap', 'clip')
-
-        Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
-
-        Examples:
-            >>> import numpy as np
-            >>> from mindspore import Tensor
-            >>> a = Tensor(np.array([4, 3, 5, 7, 6, 8]))
-            >>> indices = Tensor(np.array([0, 1, 4]))
-            >>> output = a.take(indices)
-            >>> print(output)
-            [4 3 6]
-        """
-        if mode not in ('raise', 'wrap', 'clip'):
-            raise ValueError(f"For 'Tensor.take', the argument 'mode' should be one of in ['raise', 'wrap', 'clip'],"
-                             f" but got {mode}.")
-        if axis is None:
-            a = self.ravel()
-            axis = 0
-        else:
-            a = self
-        ndim = a.ndim
-        validator.check_axis_in_range(axis, ndim)
-        axis = axis + ndim if axis < 0 else axis
-
-        shape_a = a.shape
-        shape_indices = indices.shape
-        size_indices = indices.size
-        indices = tensor_operator_registry.get('check_indices')(shape_a[axis], indices, mode)
-
-        # reshapes indices to shape (Ni..., Nj..., Nk)
-        shape_ni = shape_a[:axis]
-        shape_nk = shape_a[axis + 1:]
-        shape_out = shape_ni + shape_indices + shape_nk
-        shape_indices = tuple(size_indices if i == axis else 1 for i in range(ndim))
-        indices = indices.reshape(shape_indices)
-        shape_indices = shape_ni + (indices.size,) + shape_nk
-        indices = tensor_operator_registry.get('broadcast_to')(indices, shape_indices)
-
-        res = tensor_operator_registry.get('gather_d')(a, axis, indices)
-        return res.reshape(shape_out)
-
     def choose(self, choices, mode='clip'):
         """
         Construct a tensor from an index tensor and a list of tensors to choose from.
@@ -3249,34 +2390,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
     def searchsorted(self, v, side='left', sorter=None):
         """
-        Finds indices where elements should be inserted to maintain order.
-
-        Args:
-            v (Union[int, float, bool, list, tuple, Tensor]): Values to insert into the tensor.
-            side (str, optional): If 'left', the index of the first suitable
-                location found is given. If 'right', return the last such index. If there is
-                no suitable index, return either 0 or N (where N is the length of the tensor).
-                Default: ``left`` .
-            sorter (Union[int, list, tuple, Tensor]): optional tensor of
-                integer indices that sort the tensor into ascending order on the innermost dimension
-                and the type must be int64. They are typically the result of argsort. Default: ``None`` .
-                CPU and GPU can only use default values
-
-        Returns:
-            Tensor, array of insertion points with the same shape as `v`.
-
-        Raises:
-            ValueError: If argument for `side` or `sorter` is invalid.
-
-        Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
-
-        Examples:
-            >>> import numpy as np
-            >>> from mindspore import Tensor
-            >>> x = Tensor(np.array([1, 2, 3, 4, 5]))
-            >>> print(x.searchsorted(3))
-            2
+        For details, please refer to :func:`mindspore.ops.searchsorted`.
         """
         if side not in ('left', 'right'):
             raise ValueError(f"For 'Tensor.searchsorted', the argument 'side' should be one of in "
@@ -3301,20 +2415,15 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         r"""
         For details, please refer to :func:`mindspore.ops.gather_nd`.
         """
-        validator.check_value_type('indices', indices, (Tensor, Tensor_,), 'Tensor.gather_nd')
+        validator.check_value_type('indices', indices, (Tensor, TensorPy_,), '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 +2450,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.
+            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``.
 
-        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.
-
-        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 +2539,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`.
@@ -3530,91 +2551,51 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('nanmedian')(self, axis, keepdims)
 
-    def repeat(self, repeats, axis=None):
+    def bernoulli(self, *, generator=None):
+        r"""
+        For details, please refer to :func:`mindspore.mint.bernoulli`.
         """
-        Repeat elements of a tensor.
+        return tensor_operator_registry.get('bernoulli')(self, generator=generator)
+
+    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:
-            repeats (Union[int, tuple, list]): The number of repetitions for each element.
-                `repeats` is broadcasted to fit the shape of the given axis.
-            axis (int, optional): The axis along which to repeat values. By default,
-                use the flattened input tensor, and return a flat output tensor. Default: ``None``.
+            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:
-            Tensor, has the same shape as input tensor except along the given axis.
+            The input tensor.
 
         Raises:
-            ValueError: If the axis is out of range.
-            TypeError: If arguments have types not specified above.
-
-        See also:
-            - :func:`mindspore.Tensor.reshape`: Give a new shape to a tensor without changing its data.
-            - :func:`mindspore.Tensor.resize`: Changes shape and size of tensor in-place.
+            TypeError: If `from_` or `to` is not integer.
+            RuntimeError: If `from_` >= `to`.
 
         Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
+            ``Ascend``
 
         Examples:
-            >>> import numpy as np
             >>> from mindspore import Tensor
-            >>> x = Tensor(np.array(3))
-            >>> print(x.repeat(4))
-            [3 3 3 3]
-            >>> x = Tensor(np.array([[1, 2],[3, 4]]))
-            >>> print(x.repeat(2))
-            [1 1 2 2 3 3 4 4]
-            >>> print(x.repeat(3, axis=1))
-            [[1 1 1 2 2 2]
-            [3 3 3 4 4 4]]
-            >>> print(x.repeat([1,2], axis=0))
-            [[1 2]
-            [3 4]
-            [3 4]]
+            >>> a = Tensor([[2, 3, 4], [1, 2, 3]])
+            >>> from_ = 0
+            >>> to = 5
+            >>> print(a.random_(from_, to).shape)
+            (2, 3)
         """
-        if not isinstance(repeats, (tuple, list)):
-            repeats = (repeats,)
-        for index, element in enumerate(repeats):
-            if not isinstance(element, int):
-                raise TypeError(f"For 'Tensor.repeat', each element in {repeats} should be int, but got "
-                                f"{type(element)} at index {index}.")
-        input_x = self
-        if axis is None:
-            input_x = self.ravel()
-            axis = 0
-        if axis is not None and not isinstance(axis, int):
-            raise TypeError(f"For 'Tensor.repeat', the argument 'axis' should be int, but got {type(axis)}.")
-        validator.check_axis_in_range(axis, input_x.ndim)
-        axis = axis + input_x.ndim if axis < 0 else axis
-
-        if len(repeats) == 1:
-            repeats = repeats[0]
-            if repeats == 0:
-                return Tensor_(input_x.dtype, (0,))
-            return tensor_operator_registry.get('repeat_elements')(input_x, repeats, axis)
-        size = input_x.shape[axis]
-        if len(repeats) != size:
-            raise ValueError(f"For 'Tensor.repeat', the length of 'repeats' must be the same as the shape of the "
-                             f"original tensor in the 'axis' dimension, but got the length of 'repeats' "
-                             f"{len(repeats)}, the shape of the original tensor in the 'axis' dimension {size}.")
-        subs = tensor_operator_registry.get('tensor_split')(input_x, size, axis)
-        repeated_subs = []
-        for sub, rep in zip(subs, repeats):
-            if rep != 0:
-                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)
+        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"""
@@ -3624,24 +2605,71 @@ 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`.
         """
-        validator.check_value_type('index', index, (Tensor, Tensor_,), 'Tensor.gather_elements')
+        validator.check_value_type('index', index, (Tensor, TensorPy_,), '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`.
+    def nonzero(self, *, as_tuple=False):
+        r"""
+        Return the positions of all non-zero values.
+
+        Note:
+           The rank of `self`.
+
+           - Ascend: its rank can be equal to 0 except O2 mode.
+           - CPU/GPU: its rank should be greater than or eaqual to 1.
+
+        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)
+        return tensor_operator_registry.get('nonzero')(self, as_tuple=as_tuple)
 
     def svd(self, full_matrices=False, compute_uv=True):
         """
@@ -3654,12 +2682,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         s, _, _ = svd_op(full_matrices, compute_uv)(self)
         return s
 
-    def hardshrink(self, lambd=0.5):
-        r"""
-        For details, please refer to :func:`mindspore.ops.hardshrink`.
-        """
-        return tensor_operator_registry.get('hardshrink')(self, lambd)
-
     def heaviside(self, values):
         r"""
         For details, please refer to :func:`mindspore.ops.heaviside`.
@@ -3775,13 +2797,10 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(out2)
             1
         """
-        return self.asnumpy().tolist()
+        if self.ndim == 1 and self.size == 0:
+            return []
+        return self._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"""
@@ -3801,14 +2820,15 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('unsorted_segment_prod')(self, segment_ids, num_segments)
 
-    def unique_consecutive(self, return_idx=False, return_counts=False, axis=None):
+    def unique_consecutive(self, return_inverse=False, return_counts=False, dim=None):
         """
         For details, please refer to :func:`mindspore.ops.unique_consecutive`.
         """
-        output, idx, counts = tensor_operator_registry.get("unique_consecutive")(return_idx, return_counts, axis)(self)
-        if return_idx and return_counts:
+        output, idx, counts =\
+            tensor_operator_registry.get("unique_consecutive")(return_inverse, return_counts, dim)(self)
+        if return_inverse and return_counts:
             return output, idx, counts
-        if return_idx:
+        if return_inverse:
             return output, idx
         if return_counts:
             return output, counts
@@ -3820,12 +2840,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get("unique_with_pad")(self, pad_num)
 
-    def diag(self):
-        r"""
-        For details, please refer to :func:`mindspore.ops.diag`.
-        """
-        return tensor_operator_registry.get('diag')(self)
-
     def diagflat(self, offset=0):
         r"""
         For details, please refer to :func:`mindspore.ops.diagflat`.
@@ -3838,13 +2852,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`.
@@ -3870,12 +2877,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('dsplit')(self, indices_or_sections)
 
-    def xlogy(self, y):
-        r"""
-        For details, please refer to :func:`mindspore.ops.xlogy`.
-        """
-        return tensor_operator_registry.get("xlogy")(self, y)
-
     def eigvals(self):
         r"""
         For details, please refer to :func:`mindspore.ops.eigvals`.
@@ -3885,30 +2886,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 +2894,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 +2904,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 +2933,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 +2963,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 TensorPy_.type_as(self, other)
+
 
     def bool(self):
         r"""
@@ -4073,14 +3027,56 @@ 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"""
+        Converts input tensor dtype to `float32`.
+
+        Returns:
+            Tensor, converted to the `float32` 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.float()
+            >>> print(output.dtype)
+            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 float(self):
+    def double(self):
         r"""
-        Converts input tensor dtype to `float32`.
+        Converts input tensor dtype to `float64`.
 
         Returns:
-            Tensor, converted to the `float32` dtype.
+            Tensor, converted to the `float64` dtype.
 
         Supported Platforms:
             ``Ascend`` ``GPU`` ``CPU``
@@ -4090,11 +3086,11 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> import mindspore
             >>> from mindspore import Tensor
             >>> input_x = Tensor(np.ones([2,2]), mindspore.int32)
-            >>> output = input_x.float()
+            >>> output = input_x.double()
             >>> print(output.dtype)
-            Float32
+            Float64
         """
-        return tensor_operator_registry.get('float')(self, mstype.float32)
+        return self.to(mstype.float64)
 
     def half(self):
         r"""
@@ -4115,7 +3111,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 +3132,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 +3151,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 +3174,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 +3196,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 +3206,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)
 
@@ -4229,12 +3225,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('conj')(self)
 
-    def count_nonzero(self, axis=(), keep_dims=False, dtype=mstype.int32):
-        r"""
-        For details, please refer to :func:`mindspore.ops.count_nonzero`.
-        """
-        return tensor_operator_registry.get('count_nonzero')(self, axis, keep_dims, dtype)
-
     def cross(self, other, dim=None):
         r"""
         For details, please refer to :func:`mindspore.ops.cross`.
@@ -4247,11 +3237,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 +3277,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 +3291,80 @@ 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):
+    def index_add_(self, dim, index, source, *, alpha=1):
         r"""
-        For details, please refer to :func:`mindspore.ops.expm1`.
-        """
-        return tensor_operator_registry.get('expm1')(self)
+        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 index_add(self, dim, index, source, *, alpha=1):
-        r"""
-        For details, please refer to :func:`mindspore.ops.index_add`.
-        """
-        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)
+        .. 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}
 
-    def greater(self, other):
-        r"""
-        For details, please refer to :func:`mindspore.ops.greater`.
-        """
-        return tensor_operator_registry.get('greater')(self, other)
+        .. warning::
+            This is an experimental API that is subject to change or deletion.
 
-    def greater_equal(self, other):
-        r"""
-        For details, please refer to :func:`mindspore.ops.greater_equal`.
+        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 +3378,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):
         """
@@ -4400,74 +3408,9 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get('is_floating_point')(self)
 
-    def is_signed(self):
-        """
-        Judge whether the data type of tensor is a signed data type.
-
-        Returns:
-            Bool. If the dtype of `self` is a signed data type, return True. Otherwise, return False.
-
-        Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
-
-        Examples:
-            >>> import mindspore as ms
-            >>> x = ms.Tensor([1, 2, 3], ms.int64)
-            >>> y = ms.Tensor([1, 2, 3], ms.uint64)
-            >>> output = x.is_signed()
-            >>> output2 = y.is_signed()
-            >>> print(output)
-            True
-            >>> print(output2)
-            False
-        """
-        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`.
-        """
-        return tensor_operator_registry.get('logical_xor')(self, other)
-
     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 +3419,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 +3437,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 +3454,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 +3468,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 +3498,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 +3563,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 +3571,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 +3604,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 +3618,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 +3658,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 +3712,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.
@@ -4899,7 +3799,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         mode = context.get_context("mode")
         if mode != context.PYNATIVE_MODE:
             raise ValueError(f"The method of 'move_to' only supported in pynative mode, but got: {mode}.")
-        return Tensor_.move_to(self, to, blocking)
+        return TensorPy_.move_to(self, to, blocking)
 
     def _offload(self):
         r"""
@@ -4914,9 +3814,71 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> x = ms.Tensor([1, 2, 3], ms.int64)
             >>> x._offload()
         """
-        return Tensor_._offload(self)
+        return TensorPy_._offload(self, False)
+
+    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 TensorPy_._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 triangular_solve(self, A, upper=True, transpose=False, unitriangular=False):
+        r"""
+        For details, please refer to :func:`mindspore.mint.triangular_solve`.
+        """
+        return tensor_operator_registry.get('triangular_solve')(self, A, upper, transpose, unitriangular)
+
 def _vm_compare(*args):
     """Implement `vm_compare` for tensor."""
     if args:
@@ -4926,12 +3888,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 +3921,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):