mindspore 2.0.0rc1__cp38-cp38-manylinux1_x86_64.whl → 2.2.0__cp38-cp38-manylinux1_x86_64.whl

mindspore/common/tensor.py

@@ -74,32 +74,69 @@ class _TensorMeta(type(Tensor_), abc.ABCMeta):
     """
 
 
+def tensor(input_data=None, dtype=None, shape=None, init=None, internal=False, const_arg=False):
+    """
+    Create a new Tensor in Cell.construct() or function decorated by @jit.
+
+    In graph mode, MindSpore would create a new Tensor object at runtime dynamically,
+    based on the `dtype` argument.
+
+    Please refer to `Creating and Using Tensor
+    <https://www.mindspore.cn/docs/en/r2.2/note/static_graph_syntax_support.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/r2.2/design/dynamic_graph_and_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`.
+    internally to indicate the type of the Tensor currently being created,
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> from mindspore import jit, tensor
+        >>> @jit
+        ... def func(x):
+        ...    return tensor(x.asnumpy(), dtype=ms.float32)
+        >>> x = tensor([1, 2, 3])
+        >>> y = func(x)
+        >>> print(y)
+        [1. 2. 3.]
+    """
+    return Tensor(input_data, dtype, shape, init, internal, const_arg)  # @jit.typing: () -> tensor_type[{dtype}]
+
+
 class Tensor(Tensor_, metaclass=_TensorMeta):
     """
     Tensor is a data structure that stores an n-dimensional array.
 
+    Note:
+        If 'init' interface is used to initialize Tensor, the `Tensor.init_data` API needs to be called to load the
+        actual data to `Tensor`.
+
     Args:
         input_data (Union[Tensor, float, int, bool, tuple, list, numpy.ndarray]): The data to be stored. It can be
-            another Tensor, Python number or NumPy ndarray. Default: None.
+            another Tensor, Python number or NumPy ndarray. Default: ``None`` .
         dtype (:class:`mindspore.dtype`): Used to indicate the data type of the output Tensor. The argument should
-            be defined in `mindspore.dtype`. If it is None, the data type of the output Tensor will be the same
-            as the `input_data`. Default: None.
+            be defined in `mindspore.dtype`. If it is ``None`` , the data type of the output Tensor will be the same
+            as the `input_data`. Default: ``None`` .
         shape (Union[tuple, list, int]): Used to indicate the shape of the output Tensor. The argument should be
             a list of integers, a tuple of integers or an integer. If `input_data` is available,
             `shape` doesn't need to be set. If None in shape, a tensor of dynamic shape is created, `input_data`
             doesn't need to be set; if None not in shape, a tensor of static shape is created, `input_data` or `init`
-            must be set. Default: None.
+            must be set. Default: ``None`` .
         init (Initializer): The information of init data.
-            'init' is used for delayed initialization in parallel mode. Usually, it is not recommended to use
-            'init' interface to initialize Tensor in the other conditions. If 'init' interface is used to initialize
-            Tensor, the `Tensor.init_data` API needs to be called to convert `Tensor` to the actual data.
-            Default: None.
+            '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
+            ``'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.
+            Default: ``False`` .
 
     Outputs:
         Tensor.
@@ -107,6 +144,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.
+        Tensor with shape contains 0 is not fully tested and supported.
 
     Examples:
         >>> import numpy as np
@@ -169,35 +207,42 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             if input_data is not None:
                 Tensor_.__init__(self, input_data)
         else:
-            # If input data is numpy number, convert it to np array
-            if isinstance(input_data, np_types):
-                input_data = np.array(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")
+                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 isinstance(shape, numbers.Number):
-                shape = (shape,)
+                if isinstance(shape, numbers.Number):
+                    shape = (shape,)
 
-            _check_tensor_input(input_data, dtype, shape, init)
+                _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")
+                # 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:
-                    dtype = self._set_default_dtype(input_data, dtype)
+                    _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 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 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')
 
         self.const_arg = const_arg
         self.virtual_flag = False
@@ -230,7 +275,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             if np.array(input_data).dtype == np.float64:
                 return mstype.float32
         if isinstance(input_data, (int, list, tuple)):
-            if np.array(input_data).dtype == np.int32 or np.array(input_data).dtype == np.int64:
+            if np.array(input_data).dtype in (np.int32, np.int64):
                 return mstype.int64
         return dtype
 
@@ -306,11 +351,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
     def __index__(self):
         data = self.asnumpy()
-        if not (data.dtype == "int8"
-                or data.dtype == "int16"
-                or data.dtype == "int32"
-                or data.dtype == "int64"
-                or data.dtype == "bool"):
+        if data.dtype not in ["int8", "int16", "int32", "int64", "bool"]:
             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.")
@@ -319,10 +360,8 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         return self
 
     def __abs__(self):
-        data = abs(self.asnumpy())
-        if isinstance(data, np.number):
-            data = np.array(data)
-        return Tensor(data)
+        self._init_check()
+        return tensor_operator_registry.get('abs')(self)
 
     def __add__(self, other):
         return tensor_operator_registry.get('__add__')(self, other)
@@ -422,6 +461,11 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
     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)
@@ -444,8 +488,20 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
     def __str__(self):
         if self.dtype == mstype.type_none:
             return "Unknown Tensor type!"
+        if self.dtype == mstype.bfloat16:
+            return str(self.float().asnumpy())
         return str(self.asnumpy())
 
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        state["value"] = Tensor_.__getstate__(self)
+        return state
+
+    def __setstate__(self, state):
+        value = state.pop("value")
+        Tensor_.__setstate__(self, value)
+        self.__dict__.update(state)
+
     @property
     def shape(self):
         """
@@ -462,12 +518,30 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
     def size(self):
         """
         For details, please refer to :func:`mindspore.ops.size`.
+
+        Examples:
+            >>> from mindspore import Tensor
+            >>> import numpy as np
+            >>> x = Tensor(np.array([[1, 2], [3, 4]]))
+            >>> output = x.size
+            >>> print(output)
+            4
         """
         return self._size
 
     @property
     def ndim(self):
-        """Return the number of tensor dimensions."""
+        """
+        Return the number of tensor dimensions.
+
+        Examples:
+            >>> from mindspore import Tensor
+            >>> import numpy as np
+            >>> x = Tensor(np.array([[1, 2], [3, 4]]))
+            >>> output = x.ndim
+            >>> print(output)
+            2
+        """
         return len(self._shape)
 
     @property
@@ -476,6 +550,18 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         Returns a view of a matrix (2-D tensor) conjugated and transposed.
         x.H is equivalent to `mindspore.Tensor.swapaxes(0, 1).conj()` for complex matrices and
         `mindspore.Tensor.swapaxes(0, 1)` for real matrices.
+
+        Supported Platforms:
+            ``Ascend`` ``GPU`` ``CPU``
+
+        Examples:
+            >>> from mindspore import Tensor
+            >>> import numpy as np
+            >>> x = Tensor(np.array([[1, 2], [3, 4]]))
+            >>> output = x.H
+            >>> print(output)
+            [[1 3]
+            [2 4]]
         """
         if self.ndim != 2:
             raise ValueError(f"For tensor.H only support 2-D Tensor, but got {self.ndim}-D.")
@@ -486,27 +572,78 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
     @property
     def has_init(self):
-        """Whether tensor is initialized."""
+        """
+        Whether tensor is initialized.
+
+        Examples:
+            >>> from mindspore import Tensor
+            >>> import numpy as np
+            >>> x = Tensor(np.array([[1, 2], [3, 4]]))
+            >>> output = x.has_init
+            >>> print(output)
+            False
+        """
         return self.init is not None
 
     @property
     def itemsize(self):
-        """Return the length of one tensor element in bytes."""
+        """
+        Return the length of one tensor element in bytes.
+
+        Examples:
+            >>> from mindspore import Tensor
+            >>> import numpy as np
+            >>> x = Tensor(np.array([[1, 2], [3, 4]]))
+            >>> output = x.itemsize
+            >>> print(output)
+            8
+        """
         return self._itemsize
 
     @property
     def strides(self):
-        """Return the tuple of bytes to step in each dimension when traversing a tensor."""
+        """
+        Return the tuple of bytes to step in each dimension when traversing a tensor.
+
+        Examples:
+            >>> from mindspore import Tensor
+            >>> import numpy as np
+            >>> x = Tensor(np.array([[1, 2], [3, 4]]))
+            >>> output = x.strides
+            >>> print(output)
+            (16, 8)
+        """
         return self._strides
 
     @property
     def nbytes(self):
-        """Return the total number of bytes taken by the tensor."""
+        """
+        Return the total number of bytes taken by the tensor.
+
+        Examples:
+            >>> from mindspore import Tensor
+            >>> import numpy as np
+            >>> x = Tensor(np.array([[1, 2], [3, 4]]))
+            >>> output = x.nbytes
+            >>> print(output)
+            32
+        """
         return self._nbytes
 
     @property
     def T(self):
-        """Return the transposed tensor."""
+        """
+        Return the transposed tensor.
+
+        Examples:
+            >>> from mindspore import Tensor
+            >>> import numpy as np
+            >>> x = Tensor(np.array([[1, 2], [3, 4]]))
+            >>> output = x.T
+            >>> print(output)
+            [[1 3]
+            [2 4]]
+        """
         return self.transpose()
 
     @staticmethod
@@ -548,7 +685,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
         Args:
             const_arg (bool): Whether the tensor is a constant when it is used for the argument of a network.
-                Default: True.
+                Default: ``True`` .
 
         Returns:
             Tensor, has been specified whether to be a const network argument.
@@ -597,6 +734,80 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         self._init_check()
         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
+        defined as follows:
+
+        .. math::
+            f(x)= \frac{1}{\pi} \frac{\sigma}{(x-median)^2 +\sigma^2}
+
+        .. warning::
+            This is an experimental API that is subject to change or deletion.
+
+        Args:
+            median (float, optional): the location parameter, specifying the location
+                of the peak of the distribution. Default: 0.0.
+            sigma (float, optional): the scale parameter which specifies the half-width
+                at half-maximum. Default: 1.0.
+
+        Returns:
+            Tensor. A Tensor with the same type and shape of input.
+
+        Supported Platforms:
+            ``Ascend`` ``CPU``
+
+        Examples:
+            >>> import mindspore
+            >>> import numpy as np
+            >>> x = mindspore.Tensor(np.zeros((1, 2)), dtype=mindspore.float32)
+            >>> x.cauchy()
+            Tensor(shape=[1, 2], dtype=Float32, value=
+            [[8.79836142e-01, 9.37541723e-01]])
+
+        """
+        self._init_check()
+        out = tensor_operator_registry.get('cauchy')(list(self.shape), median, sigma)()
+        return out.astype(self.dtype)
+
+    def log_normal(self, mean=1.0, std=2.0):
+        r"""
+        Fills the elements of the input tensor with log normal values initialized by
+        given mean and std:
+
+        .. math::
+            \text{f}(x;1.0,2.0)=\frac{1}{x\delta \sqrt[]{2\pi} }e^{-\frac{(\ln x-\mu )^2}{2\delta ^2} }
+
+        where :math:`\mu`, :math:`\delta` is mean and standard deviation of  lognormal distribution respectively.
+
+        .. warning::
+            This is an experimental API that is subject to change or deletion.
+
+        Args:
+            mean (float, optional): the mean of normal distribution. With float data type.
+                Default: 1.0.
+            std (float, optional): the std of normal distribution. With float data type.
+                Default: 2.0.
+
+        Returns:
+            Tensor. A Tensor with the same type and shape of input.
+
+        Supported Platforms:
+            ``Ascend`` ``GPU`` ``CPU``
+
+        Examples:
+            >>> import mindspore
+            >>> import numpy as np
+            >>> x = mindspore.Tensor(np.array([[1, 2], [3, 4]]), dtype=mindspore.float32)
+            >>> output = x.log_normal()
+            >>> print(output)
+            [[1.2788825 2.3305743]
+            [14.944194 0.16303174]]
+        """
+        self._init_check()
+        return tensor_operator_registry.get('log_normal')(mean, std)(self)
+
+    @jit_forbidden_register
     def assign_value(self, value):
         """
         Assign another tensor value to this tensor.
@@ -606,6 +817,16 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
         Returns:
             Tensor, Tensor that's been assigned.
+
+        Examples:
+            >>> from mindspore import Tensor
+            >>> import numpy as np
+            >>> x = Tensor([1, 2, 3, 4])
+            >>> y = Tensor(np.array([[1, 2], [3, 4]]))
+            >>> output = x.assign_value(y)
+            >>> print(x)
+            [[1 2]
+            [3 4]]
         """
         if is_stub_tensor(value):
             value = value.stub_sync()
@@ -631,10 +852,11 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         Get the item at the specified index of the tensor.
 
         Note:
-            Tensor.item returns a Tensor scalar instead of a Python scalar.
+            Tensor.item returns a Tensor scalar instead of a Python scalar. And if the tensor is a Tensor scalar,
+            Tensor.item will return the numpy.ndarray.
 
         Args:
-            index (Union[None, int, tuple(int)]): The index in Tensor. Default: None.
+            index (Union[None, int, tuple(int)]): The index in Tensor. Default: ``None``.
 
         Returns:
             A Tensor scalar, dtype is the same with the original Tensor.
@@ -646,12 +868,14 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             ``Ascend`` ``GPU`` ``CPU``
 
         Examples:
-            >>> import numpy as np
+            >>> import mindspore as ms
             >>> from mindspore import Tensor
-            >>> x = Tensor(np.array([[1,2,3],[4,5,6]], dtype=np.float32))
-            >>> x = x.item((0,1))
-            >>> print(x)
+            >>> 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
         """
         output = tensor_operator_registry.get('item')(self, index)
         return output
@@ -695,6 +919,26 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         output = tensor_operator_registry.get('itemset')(self, *args)
         return output
 
+    def get_bytes(self):
+        r"""
+        Get raw data of tensor with type of bytes.
+
+        Supported Platforms:
+            ``CPU`` ``GPU`` ``Ascend``
+
+        Returns:
+            Bytes of tensor.
+
+        Examples:
+            >>> import mindspore as ms
+            >>> from mindspore import Tensor
+            >>> x = ms.Tensor([1, 2, 3], ms.int16)
+            >>> print(x.get_bytes())
+            b'\x01\x00\x02\x00\x03\x00'
+        """
+        self._init_check()
+        return Tensor_.get_bytes(self)
+
     def asnumpy(self):
         """
         Convert tensor to numpy array. Returns self tensor as a NumPy ndarray. This tensor and the returned ndarray
@@ -715,6 +959,8 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             [11.  2.]
         """
         self._init_check()
+        if self.dtype == mstype.bfloat16:
+            raise TypeError(f"For asnumpy, the type of tensor cannot be BFloat16, but got {self.dtype}.")
         return Tensor_.asnumpy(self)
 
     def numpy(self):
@@ -754,6 +1000,20 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return self.slice_num_of_persistent_data_
 
+    def slice_scatter(self, src, axis=0, start=None, end=None, step=1):
+        """
+        For details, please refer to :func:`mindspore.ops.slice_scatter`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('slice_scatter')(self, src, axis, start, end, step)
+
+    def select_scatter(self, src, axis, index):
+        """
+        For details, please refer to :func:`mindspore.ops.select_scatter`.
+        """
+        self._init_check()
+        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`.
@@ -796,6 +1056,46 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return self
 
+    def contiguous(self):
+        """
+        Converts a Tensor into a continuous-memory Tensor that contains the same data as the original Tensor.
+
+        Returns:
+            A contiguous in memory tensor containing the same data as self tensor.
+
+        Examples:
+            >>> import mindspore as ms
+            >>> import numpy as np
+            >>> from mindspore import Tensor, ops
+            >>> x = Tensor([[1, 2, 3], [4, 5, 6]], dtype=ms.float32)
+            >>> y = ops.transpose(x, (1, 0))
+            >>> y.contiguous()
+            >>> y[:, 1] = 1
+            >>> print(x)
+            [[1. 2. 3.]
+             [4. 5. 6.]]
+        """
+        Tensor_.contiguous(self)
+        return self
+
+    def is_contiguous(self):
+        """
+        Determines whether the memory of tensor is contiguous.
+
+        Returns:
+            Bool, True if tensor memory is contiguous, False otherwise.
+
+        Examples:
+            >>> import mindspore as ms
+            >>> import numpy as np
+            >>> from mindspore import Tensor, ops
+            >>> x = Tensor([[1, 2, 3], [4, 5, 6]], dtype=ms.float32)
+            >>> y = ops.transpose(x, (1, 0))
+            >>> print(y.is_contiguous())
+            False
+        """
+        return Tensor_.is_contiguous(self)
+
     def flush_from_cache(self):
         """
         Flush cache data to host if tensor is cache enable.
@@ -850,6 +1150,10 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
     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.
+
         """
         self._init_check()
         validator.check_value_type('diagonal', diagonal, [int], 'triu')
@@ -888,9 +1192,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         For details, please refer to :func:`mindspore.ops.all`.
         """
         self._init_check()
-        if axis is None:
-            axis = ()
-        return tensor_operator_registry.get('all')(keep_dims)(self, axis)
+        return tensor_operator_registry.get('all')(self, axis, keep_dims)
 
     def angle(self):
         r"""
@@ -950,7 +1252,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             if len(shape) != 1:
                 raise ValueError(f"Only one tuple is needed, but got {shape}")
             shape = shape[0]
-        return tensor_operator_registry.get('reshape')()(self, shape)
+        return tensor_operator_registry.get('reshape')(self, shape)
 
     def view_as(self, other):
         r"""
@@ -969,6 +1271,8 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             ``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)
@@ -1103,7 +1407,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         For details, please refer to :func:`mindspore.ops.exp`.
         """
         self._init_check()
-        return tensor_operator_registry.get('exp')()(self)
+        return tensor_operator_registry.get('exp')(self)
 
     def real(self):
         r"""
@@ -1214,7 +1518,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         For details, please refer to :func:`mindspore.ops.abs`.
         """
         self._init_check()
-        return tensor_operator_registry.get('abs')()(self)
+        return tensor_operator_registry.get('abs')(self)
 
     def absolute(self):
         """
@@ -1236,6 +1540,16 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         self._init_check()
         return tensor_operator_registry.get('floor')(self)
 
+    def floor_divide(self, other):
+        """
+        For details, please refer to :func:`mindspore.ops.floor_divide`.
+
+        .. warning::
+            This is an experimental API that is subject to change or deletion.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('floor_divide')(self, other)
+
     def lerp(self, end, weight):
         """
         For details, please refer to :func:`mindspore.ops.lerp`.
@@ -1275,7 +1589,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         self._init_check()
         input_x = self.copy() if self.dtype == mstype.float32 else self.astype(mstype.float16)
         input_y = other.copy() if other.dtype == mstype.float32 else other.astype(mstype.float16)
-        return tensor_operator_registry.get('__lt__')(tensor_operator_registry.get('abs')()(
+        return tensor_operator_registry.get('__lt__')(tensor_operator_registry.get('abs')(
             tensor_operator_registry.get('__sub__')(input_x, input_y)
         ), tolerance)
 
@@ -1310,6 +1624,16 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         self._init_check()
         return tensor_operator_registry.get('logaddexp2')(self, other)
 
+    def logcumsumexp(self, axis):
+        r"""
+        For details, please refer to :func:`mindspore.ops.logcumsumexp`.
+
+        .. warning::
+            This is an experimental API that is subject to change or deletion.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('logcumsumexp')(self, axis)
+
     def logsumexp(self, axis, keepdims=False):
         r"""
         For details, please refer to :func:`mindspore.ops.logsumexp`.
@@ -1427,9 +1751,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         For details, please refer to :func:`mindspore.ops.mean`.
         """
         self._init_check()
-        if axis is None:
-            axis = ()
-        return tensor_operator_registry.get('mean')(keep_dims)(self, axis)
+        return tensor_operator_registry.get('mean')(self, axis, keep_dims)
 
     def amin(self, axis=None, keepdims=False, *, initial=None, where=None):
         """
@@ -1456,6 +1778,13 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             axis = ()
         return tensor_operator_registry.get('amax')(self, axis, keepdims, initial=initial, where=where)
 
+    def aminmax(self, *, axis=0, keepdims=False):
+        r"""
+        For details, please refer to :func:`mindspore.ops.aminmax`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('aminmax')(self, axis=axis, keepdims=keepdims)
+
     def reverse_sequence(self, seq_lengths, seq_dim=0, batch_dim=0):
         """
         For details, please refer to :func:`mindspore.ops.reverse_sequence`.
@@ -1517,7 +1846,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         self._init_check()
         new_shape = validator.check_reshape_shp(shape)
-        return tensor_operator_registry.get('reshape')()(self, new_shape)
+        return tensor_operator_registry.get('reshape')(self, new_shape)
 
     def reshape_as(self, other):
         """
@@ -1545,7 +1874,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
              [ 0.5 -3.2]]
         """
         self._init_check()
-        return tensor_operator_registry.get('reshape')()(self, other.shape)
+        return tensor_operator_registry.get('reshape')(self, other.shape)
 
     def ravel(self):
         """
@@ -1571,7 +1900,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             (24,)
         """
         self._init_check()
-        reshape_op = tensor_operator_registry.get('reshape')()
+        reshape_op = tensor_operator_registry.get('reshape')
         return reshape_op(self, (-1,))
 
     def round(self):
@@ -1609,6 +1938,13 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         self._init_check()
         return tensor_operator_registry.get('dot')(self, other)
 
+    def outer(self, vec2):
+        r"""
+        For details, please refer to :func:`mindspore.ops.outer`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('outer')(self, vec2)
+
     def rad2deg(self):
         r"""
         For details, please refer to :func:`mindspore.ops.rad2deg`.
@@ -1673,6 +2009,20 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         self._init_check()
         return tensor_operator_registry.get('float_power')(self, other)
 
+    def fmax(self, other):
+        r"""
+        For details, please refer to :func:`mindspore.ops.fmax`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('fmax')(self, other)
+
+    def fmin(self, other):
+        r"""
+        For details, please refer to :func:`mindspore.ops.fmin`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('fmin')(self, other)
+
     def fmod(self, other):
         r"""
         For details, please refer to :func:`mindspore.ops.fmod`.
@@ -1706,10 +2056,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         For details, please refer to :func:`mindspore.ops.squeeze`.
         """
         self._init_check()
-        if axis is None:
-            return tensor_operator_registry.get('squeeze')(self)
-        new_shape = validator.prepare_shape_for_squeeze(self.shape, axis)
-        return tensor_operator_registry.get('reshape')()(self, new_shape)
+        return tensor_operator_registry.get('squeeze')(self, axis)
 
     def slogdet(self):
         """
@@ -1751,8 +2098,8 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             dtype (Union[:class:`mindspore.dtype`, numpy.dtype, str]): Designated tensor dtype, can be in
                 format of `mindspore.dtype.float32` or `numpy.float32` or `float32`.
             copy (bool, optional): By default, astype always returns a newly allocated
-                tensor. If this is set to false, the input tensor is returned instead
-                of a copy. Default: True.
+                tensor. If this is set to ``false`` , the input tensor is returned instead
+                of a copy. Default:  ``True`` .
 
         Returns:
             Tensor, with the designated dtype.
@@ -1781,37 +2128,16 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         For details, please refer to :func:`mindspore.ops.argmax`.
         """
-        if self.shape == ():
-            return Tensor(0)
-        a = self
-        is_axis_none = False
-        if axis is None:
-            a = a.ravel()
-            axis = 0
-            is_axis_none = True
-        out = tensor_operator_registry.get('argmax')(axis, mstype.int64)(a)
-        if keepdims and not is_axis_none:
-            out = out.expand_dims(axis)
+        self._init_check()
+        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`.
         """
-        if self.shape == ():
-            return Tensor(0)
-        # P.Argmin only supports float
-        is_axis_none = False
-        a = self.astype(mstype.float32)
-        if axis is None:
-            a = a.ravel()
-            axis = 0
-        else:
-            axis = validator.check_axis_in_range(axis, a.ndim)
-        # P.Argmin is currently not supported
-        out = tensor_operator_registry.get('argmin')(axis)(a)
-        if keepdims and not is_axis_none:
-            out = out.expand_dims(axis)
+        self._init_check()
+        out = tensor_operator_registry.get('argmin')(self, axis, keepdims)
         return out
 
     def argmax_with_value(self, axis=0, keep_dims=False):
@@ -1821,23 +2147,21 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         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.
-
-        .. warning::
+            - 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.
 
         Args:
-            axis (int): The dimension to reduce. Default: 0.
-            keep_dims (bool): Whether to reduce dimension, if true the output will keep the same dimension as the input,
-                            the output will reduce dimension if false. Default: False.
+            axis (int): 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`` .
 
         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
+              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.
@@ -1850,6 +2174,9 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             ``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)
@@ -1868,16 +2195,14 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         Returns the minimum value with corresponding index.
 
         Note:
-            In auto_parallel and semi_auto_parallel mode, the first output index can not be used.
-
-        .. warning::
+            - 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.
 
         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.
+                            the output will reduce dimension if false. Default: ``False``.
 
         Returns:
             tuple (Tensor), tuple of 2 tensors, containing the corresponding index and the minimum value of the input
@@ -1897,9 +2222,12 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             ``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
+            >>> print(output, index)
             0.0 0
             >>> output, index = x.argmin_with_value(keep_dims=True)
             >>> print(output, index)
@@ -1999,29 +2327,33 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         Return the maximum of a tensor or maximum along an axis.
 
+        Note:
+            When `axis` is ``None``, `keepdims` and subsequent parameters
+            have no effect. At the same time, the index is fixed to return 0.
+
         Args:
             axis (Union[None, int, list, tuple of ints], optional): Axis or
                 axes along which to operate. By default, flattened input is used. If
                 this is a tuple of ints, the maximum is selected over multiple axes,
-                instead of a single axis or all the axes as before. Default: None.
+                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
+                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.
+                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):
+                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.
+                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
+            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:
@@ -2066,29 +2398,33 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         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.
+                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
+                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.
+                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):
+                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.
+                is passed, initial must also be provided. Default: ``True`` .
+            return_indices (bool, optional): Whether to return the index of the minimum value. Default: ``False`` .
+                If `axis` is a list or tuple of ints, it must be ``False`` .
 
         Returns:
-            Tensor or scalar, minimum of input tensor. If `axis` is None, the result is a scalar
+            Tensor or scalar, minimum of input tensor. If `axis` is ``None`` , the result is a scalar
             value. If `axis` is given, the result is a tensor of dimension ``self.ndim - 1``.
 
         Raises:
@@ -2211,15 +2547,13 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         `Tensor.fill` is deprecated, please use `ops.fill` instead.
         """
+        self._init_check()
         if value is None:
             if self.dtype not in (mstype.float16, mstype.float32, mstype.float64):
                 raise TypeError("For 'Tensor.fill', if the argument 'value' is None, the type of the original "
                                 "tensor must be float, but got {}.".format(self.dtype))
             value = Tensor(float('nan')).astype("float32")
             return tensor_operator_registry.get("tile")()(value, self.shape).astype(self.dtype)
-        if not isinstance(value, (int, float, bool)):
-            raise TypeError("For 'Tensor.fill', the type of the argument 'value' must be int, float or bool, "
-                            "but got {}.".format(type(value)))
         return tensor_operator_registry.get("fill")(self.dtype, self.shape, value)
 
     def fills(self, value):
@@ -2229,6 +2563,48 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         self._init_check()
         return tensor_operator_registry.get('fills')(self, value)
 
+    def fill_diagonal(self, fill_value, wrap=False):
+        """
+        Fills the main diagonal of a Tensor with a specified value and returns the result.
+        The input has at least 2 dimensions, and all dimensions of input must be equal in length
+        when the dimension of input is greater than 2.
+
+        .. warning::
+            This is an experimental API that is subject to change or deletion.
+
+        Args:
+            fill_value (float): The value to fill with the diagonal of `self`.
+            wrap (bool, optional): Controls whether the diagonal elements continue onto the
+                remaining rows in case of a tall matrix(a matrix has more rows than columns). Default: ``False``.
+
+        Returns:
+            - **y** (Tensor) - Tensor, has the same shape and data type as `self`.
+
+        Raises:
+            TypeError: If data type of `self` is not one of the following: float32, int32, int64.
+            ValueError: If the dimension of `self` is not greater than 1.
+            ValueError: If the size of each dimension is not equal, when the dimension is greater than 2.
+
+        Supported Platforms:
+            ``Ascend`` ``GPU`` ``CPU``
+
+        Examples:
+            >>> import numpy as np
+            >>> import mindspore
+            >>> from mindspore import Tensor
+            >>> x = Tensor(np.ones((6, 3)), mindspore.float32)
+            >>> output = x.fill_diagonal(5.0, wrap=True)
+            >>> print(output)
+            [[5. 1. 1.]
+             [1. 5. 1.]
+             [1. 1. 5.]
+             [1. 1. 1.]
+             [5. 1. 1.]
+             [1. 5. 1.]]
+        """
+        self._init_check()
+        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`.
@@ -2252,10 +2628,10 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
         Args:
             axis (Union[None, int, tuple(int)]): Axis or axes along which the range is computed.
-                The default is to compute the variance of the flattened tensor. Default: None.
-            keepdims (bool): If this is set to True, the axes which are reduced are left in the result as
+                The default is to compute the variance of the flattened tensor. Default: ``None`` .
+            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 tensor.
-                Default is False.
+                Default is ``False`` .
 
         Returns:
             Tensor.
@@ -2319,10 +2695,14 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         Args:
             slice_index (int): Slice index of a parameter's slices.
                 It is used when initialize a slice of a parameter, it guarantees that devices
-                using the same slice can generate the same tensor. Default: None.
-            shape (list[int]): Shape of the slice, it is used when initialize a slice of the parameter. Default: None.
+                using the same slice can generate the same tensor. Default: ``None``.
+            shape (list[int]): Shape of the slice, it is used when initialize a slice of the parameter.
+                Default: ``None``.
             opt_shard_group(str): Optimizer shard group which is used in auto or semi auto parallel mode
-                to get one shard of a parameter's slice. Default: None.
+                to get one shard of a parameter's slice. For more information about optimizer parallel, please refer to:
+                `Optimizer Parallel
+                <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/optimizer_parallel.html>`_.
+                Default: ``None``.
 
         Returns:
             Initialized Tensor.
@@ -2391,14 +2771,20 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
                     self.init.seed, _ = self.seed
 
         with seed_context(self.init):
-            self.init(data)
+            if slice_num_of_persistent_data == 1:
+                self.init(data)
         self.init = None
 
         # 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))
         else:
-            self.assign_value(Tensor_.from_numpy(data))
+            if self.dtype == mstype.bfloat16:
+                # The dtype of data is np.float32 when mstype is bfloat16,
+                # so we create tensor_ by init func instead of asnumpy
+                self.assign_value(Tensor_(data, self.dtype))
+            else:
+                self.assign_value(Tensor_.from_numpy(data))
         return self
 
     def resize(self, *new_shape):
@@ -2518,54 +2904,15 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         For details, please refer to :func:`mindspore.ops.diagonal`.
         """
-        ndim = self.ndim
-        if ndim < 2:
-            raise ValueError("For 'Tensor.diagonal', the original tensor requires at least two dimensions, "
-                             "but got {}.".format(ndim))
-        dtype = self.dtype
+        self._init_check()
+        return tensor_operator_registry.get('diagonal')(self, offset, axis1, axis2)
 
-        axes = validator.check_axis_valid((axis1, axis2), ndim)
-        perm = ()
-        for i in range(ndim):
-            if i not in axes:
-                perm += (i,)
-        perm += axes
-        a = self.transpose(perm)
-
-        shape = a.shape
-        n, m = shape[-2:]
-
-        e = tensor_operator_registry.get('eye')(n, m, dtype)
-        if offset >= m or offset <= -n:
-            e = tensor_operator_registry.get('fill')(dtype, (n, m), 0)
-        elif offset != 0:
-            e = e.astype(mstype.float32)
-            if offset > 0:
-                e_left = tensor_operator_registry.get('fill')(mstype.float32, (n, offset), 0)
-                e_right = e[..., 0:m - offset:1]
-                e = tensor_operator_registry.get('concatenate')(1)((e_left, e_right)).astype(dtype)
-            elif offset < 0:
-                e_upper = tensor_operator_registry.get('fill')(mstype.float32, (-offset, m), 0)
-                e_lower = e[0:n + offset:1, ...]
-                e = tensor_operator_registry.get('concatenate')(0)((e_upper, e_lower)).astype(dtype)
-        e = tensor_operator_registry.get('broadcast_to')(shape)(e)
-
-        prod = tensor_operator_registry.get('__mul__')(a, e)
-        res = tensor_operator_registry.get('reduce_sum')(prod.astype(mstype.float32), -1)
-
-        begin = ()
-        for _ in range(ndim - 2):
-            begin += (0,)
-        last_dim_begin = max(0, -offset)
-        begin += (last_dim_begin,)
-        size = res.shape[:-1]
-        last_dim_end = min(
-            shape[-2], max(0, shape[-1] - offset)) - last_dim_begin
-        if last_dim_end <= 0:
-            return Tensor([])
-        size += (last_dim_end,)
-        res = tensor_operator_registry.get('tensor_slice')(res, begin, size)
-        return res.astype(dtype)
+    def diagonal_scatter(self, src, offset=0, dim1=0, dim2=1):
+        r"""
+        For details, please refer to :func:`mindspore.ops.diagonal_scatter`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('diagonal_scatter')(self, src, offset, dim1, dim2)
 
     def trace(self, offset=0, axis1=0, axis2=1, dtype=None):
         """
@@ -2619,20 +2966,20 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         Takes elements from a tensor along an axis.
 
         Args:
-            indices (Tensor): The indices with shape `(Nj...)` of the values to extract.
+            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 ('raise', 'wrap', 'clip', optional):
+                the flattened input tensor is used. Default: ``None`` .
+            mode (str, optional): Support ``'raise'``, ``'wrap'``, ``'clip'``.
 
-                - raise: Raises an error;
+                - ``raise``: Raises an error;
 
-                - wrap: Wraps around;
+                - ``wrap``: Wraps around;
 
-                - clip: Clips to the range. 'clip' mode means that all indices that are
+                - ``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'.
+                Default: ``'clip'`` .
 
         Returns:
             Tensor, the indexed result.
@@ -2690,17 +3037,17 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
                 `choices` must be broadcasted to the same shape. If `choices` is itself a tensor,
                 then its outermost dimension (i.e., the one corresponding to ``choices.shape[0]``)
                 is taken as defining the "sequence".
-            mode ('raise', 'wrap', 'clip', optional): Specifies how indices outside
-                ``[0, n-1]`` will be treated:
+            mode (str, optional): Specifies how indices outside
+                ``[0, n-1]`` will be treated. Support ``'raise'``, ``'wrap'``, ``'clip'``.
 
-                - raise: Raises an error;
+                - ``raise``: Raises an error;
 
-                - wrap: Wraps around;
+                - ``wrap``: Wraps around;
 
-                - clip: Clips to the range. 'clip' mode means that values greater than n-1 are mapped to n-1.
-                  Note that this disables indexing with negative numbers.
+                - ``clip``: Clips to the range. The values greater than n-1 will be mapped to n-1.
+                  Note that this mode disables indexing with negative numbers.
 
-                Default: 'clip'.
+                Default: ``'clip'``.
 
         Returns:
             Tensor, the merged result.
@@ -2768,10 +3115,10 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             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'.
+                Default: ``left`` .
             sorter (Union[int, float, bool, list, tuple, Tensor]): 1-D optional tensor of
                 integer indices that sort the tensor into ascending order. They are typically
-                the result of argsort. Default: None.
+                the result of argsort. Default: ``None`` .
 
         Returns:
             Tensor, array of insertion points with the same shape as `v`.
@@ -2850,10 +3197,10 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
         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 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`.
+            keepdims (bool): Default: ``False`` .
 
         Returns:
             Variance tensor.
@@ -2887,10 +3234,10 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             axis = ()
         else:
             axis = validator.check_and_canonicalize_axes(axis, self.ndim)
-        x_mean = tensor_operator_registry.get('mean')(True)(self, axis)
+        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('sum')(bool(keepdims))(x_pow, axis)
+        x_sum = tensor_operator_registry.get('reducesum')(bool(keepdims))(x_pow, axis)
         nums = 1
         if axis == ():
             nums = self.size
@@ -2915,26 +3262,27 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             `extobj` are not supported.
 
         Args:
-            axis (Union[None, int, tuple(int)]): Axis or axes along which a sum is performed. Default: None.
+            axis (Union[None, int, tuple(int), list(int)]): 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 of ints, a sum is performed on all the axes specified in the tuple
-                instead of a single axis or all the axes as before.
-            dtype (:class:`mindspore.dtype`, optional): defaults to None. Overrides the dtype of the
+                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`.
+            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`` .
 
         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.
+            If the input tensor is a 0-d array, or if the axis is ``None`` , a scalar is returned.
 
         Raises:
-            TypeError: If input is not array_like, or `axis` is not int or tuple of ints,
+            TypeError: If input is not array_like, or `axis` is not int, tuple of ints or list of ints,
                 or `keepdims` is not integer, or `initial` is not scalar.
             ValueError: If any axis is out of range or duplicate axes exist.
 
@@ -2954,27 +3302,14 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(input_x.sum(axis=1))
             [10. 35.]
         """
-        input_x = self.astype(mstype.int32) if self.dtype == mstype.bool_ else self
-        dtype = input_x.dtype if dtype is None else dtype
-        if not isinstance(keepdims, int):
-            raise TypeError("For 'Tensor.sum', the type of the argument 'keepdims' must be int, but "
-                            "got {}.".format(type(keepdims)))
         if initial is not None and not isinstance(initial, (int, float, bool)):
-            raise TypeError("For 'Tensor.sum', when the argument 'initial' is not None, it must be int, "
-                            "float or bool, but got {}.".format(type(initial)))
-        if axis is None:
-            axis = ()
-        else:
-            axis = validator.check_and_canonicalize_axes(axis, self.ndim)
-
-        if not validator.check_type_support(input_x.dtype, 'GPU', (mstype.float64, mstype.float32, mstype.float16)):
-            input_x = input_x.astype(mstype.float32)
-        if 0 in self.shape:
-            input_x = tensor_operator_registry.get('make_tensor')([0], self.dtype)
-        res = tensor_operator_registry.get('sum')(bool(keepdims))(input_x, axis)
+            raise TypeError(f"For Tensor.sum, initial must be int, float or bool, but got {type(initial)}.")
+        res = tensor_operator_registry.get("sum")(self, axis, keepdims)
         if initial is not None:
             res += initial
-        return res.astype(dtype)
+        if dtype is not None:
+            res = res.astype(dtype)
+        return res
 
     def sum_to_size(self, *size):
         r"""
@@ -2993,6 +3328,9 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             ``Ascend`` ``GPU`` ``CPU``
 
         Examples:
+            >>> import numpy as np
+            >>> import mindspore
+            >>> from mindspore import Tensor
             >>> x = Tensor(np.random.randn(3, 3, 3, 3, 3, 3), mindspore.float32)
             >>> output = x.sum_to_size((1, 3, 1, 3))
             >>> print(output.shape)
@@ -3025,6 +3363,20 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         self._init_check()
         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`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('nanmean')(self, axis, keepdims, dtype=dtype)
+
+    def nanmedian(self, axis=-1, keepdims=False):
+        r"""
+        For details, please refer to :func:`mindspore.ops.nanmedian`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('nanmedian')(self, axis, keepdims)
+
     def repeat(self, repeats, axis=None):
         """
         Repeat elements of a tensor.
@@ -3033,7 +3385,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             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.
+                use the flattened input tensor, and return a flat output tensor. Default: ``None``.
 
         Returns:
             Tensor, has the same shape as input tensor except along the given axis.
@@ -3111,7 +3463,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         For details, please refer to :func:`mindspore.ops.bernoulli`.
         """
         self._init_check()
-        validator.check_is_int(seed, 'seed')
         return tensor_operator_registry.get('bernoulli')(self, p, seed)
 
     def random_categorical(self, num_sample, seed=0, dtype=mstype.int64):
@@ -3265,6 +3616,29 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         self._init_check()
         return tensor_operator_registry.get('dense_to_sparse_csr')(self)
 
+    def tolist(self):
+        r"""
+        Convert a Tensor to List. If the input is Tensor scalar, a Python scalar will be returned.
+
+        Returns:
+            List or Python scalar.
+
+        Supported Platforms:
+            ``Ascend`` ``GPU`` ``CPU``
+
+        Examples:
+            >>> import mindspore as ms
+            >>> x = ms.Tensor([[1, 2, 3], [4, 5, 6]])
+            >>> out1 = x.tolist()
+            >>> print(out1)
+            [[1, 2, 3], [4, 5, 6]]
+            >>> out2 = x[0][0].tolist()
+            >>> print(out2)
+            1
+        """
+        self._init_check()
+        return self.asnumpy().tolist()
+
     def unbind(self, dim=0):
         r"""
         For details, please refer to :func:`mindspore.ops.unbind`.
@@ -3376,6 +3750,15 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get("xlogy")()(self, y)
 
+    def eigvals(self):
+        r"""
+        For details, please refer to :func:`mindspore.ops.eigvals`.
+
+        .. warning::
+            This is an experimental API that is subject to change or deletion.
+        """
+        return tensor_operator_registry.get("eigvals")()(self)
+
     def erf(self):
         r"""
         For details, please refer to :func:`mindspore.ops.erf`.
@@ -3388,11 +3771,11 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return tensor_operator_registry.get("erfc")()(self)
 
-    def tile(self, multiples):
+    def tile(self, reps):
         r"""
         For details, please refer to :func:`mindspore.ops.tile`.
         """
-        return tensor_operator_registry.get('tile')()(self, multiples)
+        return tensor_operator_registry.get('tile')(self, reps)
 
     def topk(self, k, dim=None, largest=True, sorted=True):
         r"""
@@ -3490,6 +3873,9 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             ``Ascend`` ``GPU`` ``CPU``
 
         Examples:
+            >>> import numpy as np
+            >>> import mindspore
+            >>> from mindspore import Tensor
             >>> input_np = np.random.randn(2, 3, 4, 5).astype(np.float32)
             >>> input_x = Tensor(input_np)
             >>> dtype = mindspore.int32
@@ -3500,6 +3886,60 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         self._init_check()
         return tensor_operator_registry.get('to')()(self, dtype)
 
+    def type(self, dtype=None):
+        r"""
+        Change the dtype of the Tensor to the `dtype` . Return the type if `dtype` is ``None`` .
+
+        Args:
+            dtype (mindspore.dtype, optional): The specified dtype of output tensor. Default: ``None``.
+
+        Returns:
+            Tensor or str. If `dtype` is ``None`` , return a str, which describes the dtype of Tensor.
+            If `dtype` is not ``None`` , then return a Tensor, and the dtype of returned Tensor is `dtype` .
+
+        Supported Platforms:
+            ``Ascend`` ``GPU`` ``CPU``
+
+        Examples:
+            >>> import mindspore
+            >>> from mindspore import Tensor
+            >>> x = Tensor([[1.2, 2], [3.4, 4]], dtype=mindspore.float32)
+            >>> print(x.type())
+            Float32
+            >>> print(x.type(dtype=mindspore.int32))
+            [[1 2]
+             [3 4]]
+        """
+        self._init_check()
+        if dtype is None:
+            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`.
+
+        Args:
+            other (Tensor): The return tensor has the same dtype as `other`.
+
+        Returns:
+            Tensor, has the same dtype as `other`.
+
+        Supported Platforms:
+            ``Ascend`` ``GPU`` ``CPU``
+
+        Examples:
+            >>> import mindspore
+            >>> 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)
+            Int32
+        """
+        self._init_check()
+        return self.astype(other.dtype)
+
     def bool(self):
         r"""
         Converts input tensor dtype to `bool`.
@@ -3512,6 +3952,9 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             ``Ascend`` ``GPU`` ``CPU``
 
         Examples:
+            >>> import numpy as np
+            >>> import mindspore
+            >>> from mindspore import Tensor
             >>> input_x = Tensor(np.ones([2,2]), mindspore.float32)
             >>> output = input_x.bool()
             >>> print(output.dtype)
@@ -3531,6 +3974,9 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             ``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)
@@ -3550,6 +3996,9 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             ``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.half()
             >>> print(output.dtype)
@@ -3569,6 +4018,9 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             ``Ascend`` ``GPU`` ``CPU``
 
         Examples:
+            >>> import numpy as np
+            >>> import mindspore
+            >>> from mindspore import Tensor
             >>> input_x = Tensor(np.ones([2,2]), mindspore.float32)
             >>> output = input_x.int()
             >>> print(output.dtype)
@@ -3588,6 +4040,9 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             ``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.long()
             >>> print(output.dtype)
@@ -3633,6 +4088,16 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         self._init_check()
         return tensor_operator_registry.get('cholesky_inverse')(upper=upper)(self)
 
+    def cholesky_solve(self, input2, upper=False):
+        r"""
+        For details, please refer to :func:`mindspore.ops.cholesky_solve`.
+
+        .. warning::
+            This is an experimental API that is subject to change or deletion.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('cholesky_solve')(self, input2, upper)
+
     def conj(self):
         r"""
         For details, please refer to :func:`mindspore.ops.conj`.
@@ -3640,6 +4105,13 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         self._init_check()
         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`.
+        """
+        self._init_check()
+        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`.
@@ -3685,13 +4157,17 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
     def unfold(self, kernel_size, dilation=1, padding=0, stride=1):
         r"""
         For details, please refer to :func:`mindspore.ops.unfold`.
+
+        .. warning::
+            This is an experimental API that is subject to change or deletion.
+
         """
         self._init_check()
         return tensor_operator_registry.get('unfold')(self, kernel_size, dilation, padding, stride)
 
     def expand(self, size):
         r"""
-        For details, please refer to :func:`mindspore.ops.expand`.
+        For details, please refer to :func:`mindspore.ops.broadcast_to`.
         """
         self._init_check()
         return tensor_operator_registry.get('expand')(self, size)
@@ -3724,6 +4200,13 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         self._init_check()
         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`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('equal')(self, other)
+
     def equal(self, other):
         r"""
         For details, please refer to :func:`mindspore.ops.equal`.
@@ -3825,7 +4308,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
         Examples:
             >>> import mindspore as ms
-            >>> from mindspore import Tensor
             >>> x = ms.Tensor([1, 2, 3], ms.int64)
             >>> y = ms.Tensor([1, 2, 3], ms.uint64)
             >>> output = x.is_signed()
@@ -3940,6 +4422,10 @@ 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.
+
         """
         self._init_check()
         return tensor_operator_registry.get('matrix_power')(self, n)
@@ -4008,7 +4494,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
         Keyword Args:
             dtype (mindspore.dtype, optional): The desired dtype of the output tensor. If None, the returned tensor has
-                thesame dtype as `self`. Default: None.
+                thesame dtype as `self`. Default: ``None``.
 
         Returns:
             Tensor, the shape and dtype is defined above and filled with zeros.
@@ -4020,6 +4506,9 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             ``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)
@@ -4042,7 +4531,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
         Keyword Args:
             dtype (mindspore.dtype, optional): The desired dtype of the output tensor. If None, the returned
-                tensor has the same dtype as `self`. Default: None.
+                tensor has the same dtype as `self`. Default: ``None``.
 
         Returns:
             Tensor, the shape and dtype is defined above and filled with ones.
@@ -4054,6 +4543,9 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             ``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_ones((2, 2))
             >>> print(output)
@@ -4149,6 +4641,9 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             ``GPU`` ``CPU``
 
         Examples:
+            >>> import numpy as np
+            >>> import mindspore
+            >>> from mindspore import Tensor
             >>> x = Tensor(np.asarray(np.complex(1.3 + 0.4j)), mindspore.complex64)
             >>> output = x.imag()
             >>> print(output)
@@ -4157,6 +4652,37 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         self._init_check()
         return tensor_operator_registry.get('imag')(self)
 
+    def quantile(self, q, axis=None, keepdims=False):
+        r"""
+        For details, please refer to :func:`mindspore.ops.quantile`.
+        """
+        self._init_check()
+        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`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('nanquantile')(self, q, axis, keepdims)
+
+    def orgqr(self, input2):
+        r"""
+        For details, please refer to :func:`mindspore.ops.orgqr`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('orgqr')(self, input2)
+
+    def lu_solve(self, LU_data, LU_pivots):
+        r"""
+        For details, please refer to :func:`mindspore.ops.lu_solve`.
+
+        .. warning::
+            This is an experimental API that is subject to change or deletion.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('lu_solve')(self, LU_data, LU_pivots)
+
 
     def nextafter(self, other):
         r"""
@@ -4165,7 +4691,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         self._init_check()
         return tensor_operator_registry.get('nextafter')(self, other)
 
-
     def qr(self, some=True):
         r"""
         For details, please refer to :func:`mindspore.ops.qr`.
@@ -4175,12 +4700,143 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         return tensor_operator_registry.get('qr')(self, 'reduced' if some else 'complete')
 
 
+    def ormqr(self, input2, input3, left=True, transpose=False):
+        r"""
+        For details, please refer to :func:`mindspore.ops.ormqr`,
+        Args `input2` and `input3` correspond to the args `tau` and `other` of :func:`mindspore.ops.ormqr`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('ormqr')(self, input2, input3, left, transpose)
+
+
+    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.
+        The shape of `mask` and the "self Tensor" must be the same or `mask` is broadcastable.
+
+        .. warning::
+            This is an experimental API that is subject to change or deletion.
+
+        Args:
+            mask (Tensor[bool]): A bool tensor with a shape broadcastable to the "self Tensor".
+            x (Tensor): A tensor with the same data type as the "self Tensor". The number
+                of elements must be greater than or equal to the number of True's in `mask`.
+
+        Returns:
+            Tensor, with the same type and shape as the "self Tensor".
+
+        Raises:
+            TypeError: If `mask` or `x` is not a Tensor.
+            TypeError: If data type of the "self Tensor" is not be supported.
+            TypeError: If dtype of `mask` is not bool.
+            TypeError: If the dim of the "self Tensor" less than the dim of `mask`.
+            ValueError: If `mask` can not be broadcastable to the "self Tensor".
+            ValueError: If the number of elements in `x` is less than the number required for the updates.
+
+        Supported Platforms:
+            ``Ascend`` ``CPU``
+
+        Examples:
+            >>> import numpy as np
+            >>> import mindspore
+            >>> from mindspore import Tensor
+            >>> x = Tensor(np.array([1., 2., 3., 4.]), mindspore.float32)
+            >>> mask = Tensor(np.array([True, True, False, True]), mindspore.bool_)
+            >>> tensor = Tensor(np.array([5., 6., 7.]), mindspore.float32)
+            >>> output = x.masked_scatter(mask, tensor)
+            >>> print(output)
+            [5. 6. 3. 7.]
+        """
+        self._init_check()
+        return tensor_operator_registry.get('masked_scatter')()(self, mask, x)
+
+
+    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`.
+
+        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
+                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".
+                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 `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`).
+            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").
+
+        Supported Platforms:
+            ``Ascend`` ``CPU``
+
+        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
+            >>> output = x.index_put(indices, values, accumulate)
+            >>> print(output)
+            [[1 5 3]
+            [4 8 9]]
+        """
+        self._init_check()
+        validator.check_value_type('accumulate', accumulate, bool, 'Tensor.index_put')
+        _index_put = tensor_operator_registry.get('index_put')(0 if accumulate is False else 1)
+        return _index_put(self, values, indices)
+
+
+    def _offload(self):
+        r"""
+        Offload tensor parameter to host. Currently, only support for pynative mode.
+
+        Supported Platforms:
+            ``Ascend``
+
+        Examples:
+            >>> import mindspore as ms
+            >>> from mindspore import Tensor
+            >>> x = ms.Tensor([1, 2, 3], ms.int64)
+            >>> x._offload()
+        """
+        self._init_check()
+        return Tensor_._offload(self)
+
+
 def _vm_compare(*args):
     """Implement `vm_compare` for tensor."""
-    obj_str = args[-1]
+    if args:
+        obj_str = args[-1]
+    else:
+        raise ValueError("_vm_compare does not receive any input.")
     if obj_str == "shape":
         fn = getattr(args[0].asnumpy(), obj_str)
         return fn
+    if obj_str == "__setitem__":
+        fn = getattr(args[0].asnumpy(), obj_str)
+        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 len(args) == 2:
         fn = getattr(args[0].asnumpy(), obj_str)
         return Tensor(fn())