mindspore 2.2.14__cp39-cp39-win_amd64.whl → 2.4.0__cp39-cp39-win_amd64.whl

mindspore/common/tensor.py

@@ -1,4 +1,4 @@
-# Copyright 2020-2022 Huawei Technologies Co., Ltd
+# Copyright 2020-2024 Huawei Technologies Co., Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -27,13 +27,17 @@ from mindspore.common.seed import get_seed
 from mindspore import context
 from mindspore import log as logger
 from mindspore.common import dtype as mstype
+from mindspore.common.hook_handle import _TensorHookHandle
 
 from mindspore.common._utils import get_slice_num
 from mindspore.common._register_for_tensor import tensor_operator_registry
+from mindspore.common._tensor_overload import (repeat_interleave_mint, add_mint, item_mint, isnan_mint, flatten_mint,
+                                               max_mint, mean_mint, min_mint, split_mint, sub_mint)
 from mindspore._c_expression import Tensor as Tensor_
 from mindspore import _checkparam as validator
-from mindspore._checkparam import check_is_number, is_stub_tensor
+from mindspore._checkparam import check_is_number, is_stub_tensor, check_hook_fn
 from mindspore._check_jit_forbidden_api import jit_forbidden_register
+from mindspore.common.symbol import Symbol
 
 np_types = (np.int8, np.int16, np.int32, np.int64,
             np.uint8, np.uint16, np.uint32, np.uint64, np.float16,
@@ -48,7 +52,8 @@ def _check_input_data_type(input_data):
     valid_dtypes = (np.int8, np.int16, np.int32, np.int64, np.uint8, np.uint16, np.uint32, np.uint64,
                     np.float16, np.float32, np.float64, np.bool_, np.str_, np.complex64, np.complex128)
     if isinstance(input_data, np.ndarray) and input_data.dtype not in valid_dtypes and \
-            input_data.dtype.kind != 'U' and input_data.dtype.kind != 'S':  # Support dtype np.str_
+            input_data.dtype.kind != 'U' and input_data.dtype.kind != 'S' and \
+            not (input_data.dtype.kind == 'V' and input_data.dtype.char == 'E'):  # Support np.str_ and np.bfloat16
         new_line = '\n'
         for index, x in np.ndenumerate(input_data):
             if np.array(x).dtype not in valid_dtypes:
@@ -82,11 +87,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/r2.2/note/static_graph_syntax_support.html#mindspore-user-defined-data-types>`_ .
+    <https://www.mindspore.cn/docs/en/master/model_train/program_form/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/r2.2/design/dynamic_graph_and_static_graph.html?#annotation-type>`_
+    <https://www.mindspore.cn/docs/en/master/model_train/program_form/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`.
@@ -114,22 +119,25 @@ 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
+        If `init` interface is used to initialize `Tensor`, the `Tensor.init_data` API needs to be called to load the
         actual data to `Tensor`.
 
+    Warning:
+          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
             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`` .
-        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`` .
+        shape (Union[tuple, list, int, :class:`mindspore.Symbol`]): Used to indicate the shape of the output Tensor.
+            If `input_data` is available, `shape` doesn't need to be set. If ``None`` or `Symbol` exists in `shape` ,
+            a tensor of dynamic shape is created, `input_data` doesn't need to be set; if only integers exist in
+            `shape`, a tensor of static shape is created, `input_data` or `init` must be set. Default: ``None`` .
         init (Initializer): The information of init data.
-            'init' is used for delayed initialization in parallel mode, when using init, `dtype` and `shape` must be
+            `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.
@@ -137,14 +145,17 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             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.
+            Default: ``None`` .
 
     Outputs:
         Tensor.
 
     Note:
-        The default value None of `input_data` works as a placeholder, it does not mean that we can create a NoneType
+        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.
+        Tensor with `shape` contains 0 is not fully tested and supported.
 
     Examples:
         >>> import numpy as np
@@ -198,8 +209,14 @@ 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):
+    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()
 
@@ -218,8 +235,16 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
                 if isinstance(input_data, np_types):
                     input_data = np.array(input_data)
 
-                if isinstance(shape, numbers.Number):
-                    shape = (shape,)
+                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)
 
@@ -244,6 +269,9 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
                         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
@@ -258,6 +286,12 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         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):
         """
@@ -295,19 +329,11 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
     def __eq__(self, other):
         if not isinstance(other, (int, float, Tensor)):
             return False
-        # bool type is not supported for `Equal` operator in backend.
-        if self.dtype == mstype.bool_ or (isinstance(other, Tensor) and other.dtype == mstype.bool_):
-            if isinstance(other, Tensor):
-                return Tensor(np.array(self.asnumpy() == other.asnumpy()))
-            return Tensor(np.array(self.asnumpy() == other))
         return tensor_operator_registry.get('__eq__')(self, other)
 
     def __ne__(self, other):
         if not isinstance(other, (int, float, Tensor)):
             return True
-        #  bool type is not supported for `NotEqual` operator in backend.
-        if self.dtype == mstype.bool_ or (isinstance(other, Tensor) and other.dtype == mstype.bool_):
-            return Tensor(np.array(self.asnumpy() != other.asnumpy()))
         return tensor_operator_registry.get('__ne__')(self, other)
 
     def __hash__(self):
@@ -322,7 +348,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         return out
 
     def __round__(self):
-        out = tensor_operator_registry.get('round')()(self)
+        out = tensor_operator_registry.get('round')(self)
         return out
 
     def __bool__(self):
@@ -360,9 +386,9 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         return self
 
     def __abs__(self):
-        self._init_check()
         return tensor_operator_registry.get('abs')(self)
 
+    @add_mint
     def __add__(self, other):
         return tensor_operator_registry.get('__add__')(self, other)
 
@@ -387,6 +413,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
     def __iadd__(self, other):
         return self.__add__(other)
 
+    @sub_mint
     def __sub__(self, other):
         return tensor_operator_registry.get('__sub__')(self, other)
 
@@ -488,8 +515,6 @@ 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):
@@ -498,9 +523,12 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         return state
 
     def __setstate__(self, state):
-        value = state.pop("value")
+        if isinstance(state, tuple):
+            value = state
+        else:
+            value = state.pop("value")
+            self.__dict__.update(state)
         Tensor_.__setstate__(self, value)
-        self.__dict__.update(state)
 
     @property
     def shape(self):
@@ -509,6 +537,13 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return self._shape
 
+    @shape.setter
+    def shape(self, shape_value):
+        r"""
+        Set the shape value.
+        """
+        self._shape = shape_value
+
     @property
     def dtype(self):
         """Return the dtype of the tensor (:class:`mindspore.dtype`)."""
@@ -544,6 +579,83 @@ 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):
         """
@@ -607,8 +719,9 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
         Examples:
             >>> from mindspore import Tensor
+            >>> from mindspore import dtype as mstype
             >>> import numpy as np
-            >>> x = Tensor(np.array([[1, 2], [3, 4]]))
+            >>> x = Tensor(np.array([[1, 2], [3, 4]]), dtype=mstype.int64)
             >>> output = x.strides
             >>> print(output)
             (16, 8)
@@ -644,6 +757,8 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             [[1 3]
             [2 4]]
         """
+        if self.ndim <= 1:
+            return self
         return self.transpose()
 
     @staticmethod
@@ -710,28 +825,24 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         r"""
         For details, please refer to :func:`mindspore.ops.arccosh`.
         """
-        self._init_check()
         return tensor_operator_registry.get('acosh')(self)
 
     def arcsin(self):
         r"""
         For details, please refer to :func:`mindspore.ops.arcsin`.
         """
-        self._init_check()
         return tensor_operator_registry.get('asin')(self)
 
     def arctan(self):
         r"""
         For details, please refer to :func:`mindspore.ops.arctan`.
         """
-        self._init_check()
         return tensor_operator_registry.get('atan')(self)
 
     def arctan2(self, other):
         r"""
         For details, please refer to :func:`mindspore.ops.arctan2`.
         """
-        self._init_check()
         return tensor_operator_registry.get('atan2')(self, other)
 
     def cauchy(self, median=0.0, sigma=1.0):
@@ -766,7 +877,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             [[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)
 
@@ -804,7 +914,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             [[1.2788825 2.3305743]
             [14.944194 0.16303174]]
         """
-        self._init_check()
         return tensor_operator_registry.get('log_normal')(mean, std)(self)
 
     @jit_forbidden_register
@@ -837,29 +946,24 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         r"""
         For details, please refer to :func:`mindspore.ops.bincount`.
         """
-        self._init_check()
         return tensor_operator_registry.get('bincount')(self, weights, minlength)
 
     def chunk(self, chunks, axis=0):
         r"""
         For details, please refer to :func:`mindspore.ops.chunk`.
         """
-        self._init_check()
         return tensor_operator_registry.get('chunk')(self, chunks, axis)
 
+    @item_mint
     def item(self, index=None):
         """
         Get the item at the specified index of the tensor.
 
-        Note:
-            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``.
 
         Returns:
-            A Tensor scalar, dtype is the same with the original Tensor.
+            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.
@@ -877,7 +981,11 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(x.item())
             1.2
         """
-        output = tensor_operator_registry.get('item')(self, index)
+
+        if index is not None:
+            output = self.asnumpy().item(index)
+        else:
+            output = self.asnumpy().item()
         return output
 
     def itemset(self, *args):
@@ -936,7 +1044,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(x.get_bytes())
             b'\x01\x00\x02\x00\x03\x00'
         """
-        self._init_check()
         return Tensor_.get_bytes(self)
 
     def asnumpy(self):
@@ -958,10 +1065,11 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(y)
             [11.  2.]
         """
-        self._init_check()
+        if self.has_init:
+            self.init_data()
         return Tensor_.asnumpy(self)
 
-    def numpy(self):
+    def numpy(self, *, force=False):
         """
         Alias for :func:`mindspore.Tensor.asnumpy`.
         """
@@ -1002,21 +1110,18 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         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`.
         """
-        self._init_check()
         validator.check_value_type('min', min, (int, float,), 'Tensor.histc')
         validator.check_value_type('max', max, (int, float,), 'Tensor.histc')
         return tensor_operator_registry.get('histc')(self, bins, float(min), float(max))
@@ -1025,7 +1130,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         For details, please refer to :func:`mindspore.ops.geqrf`.
         """
-        self._init_check()
         return tensor_operator_registry.get('geqrf')(self)
 
     def slice_shape_of_persistent_data(self):
@@ -1067,14 +1171,11 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> 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.]]
+            >>> z = y.contiguous()
+            >>> print(z.is_contiguous())
+            True
         """
-        Tensor_.contiguous(self)
-        return self
+        return tensor_operator_registry.get('contiguous')(self)
 
     def is_contiguous(self):
         """
@@ -1094,6 +1195,95 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return Tensor_.is_contiguous(self)
 
+    def stride(self, dim=None):
+        """
+        The stride to jump from one element to the next in the input dim.
+        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.
+
+        Returns:
+            Int, the stride of tensor.
+
+        Raises:
+            TypeError: `dim` is not an int.
+
+        Examples:
+            >>> import mindspore as ms
+            >>> x = ms.Tensor([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]], dtype=ms.float32)
+            >>> x.stride()
+            [5, 1]
+        """
+        stride = Tensor_.stride(self)
+        if dim is None:
+            return stride
+        return stride[dim]
+
+    def storage_offset(self):
+        """
+        Tensor's offset in the underlying storage in terms of the number of storage elements.
+
+        Returns:
+            int, tensor's offset in the underlying storage in terms of number of storage elements.
+
+        Examples:
+            >>> import mindspore as ms
+            >>> x = ms.Tensor([1, 2, 3, 4, 5], dtype=ms.float32)
+            >>> ret = x.storage_offset()
+            >>> print(ret)
+            0
+        """
+        return Tensor_.storage_offset(self)
+
+    def register_hook(self, hook_fn):
+        """
+        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,
+              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.
+
+        Args:
+            hook_fn (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
+            `handle.remove()` .
+
+        Raises:
+            TypeError: If the `hook_fn` is not a function of python.
+
+        Supported Platforms:
+            ``Ascend`` ``GPU`` ``CPU``
+
+        Examples:
+            >>> import mindspore as ms
+            >>> from mindspore import Tensor
+            >>> ms.set_context(mode=ms.PYNATIVE_MODE)
+            >>> def hook_fn(grad):
+            ...     return grad * 2
+            ...
+            >>> def hook_test(x, y):
+            ...     z = x * y
+            ...     z.register_hook(hook_fn)
+            ...     z = z * y
+            ...     return z
+            ...
+            >>> ms_grad = ms.grad(hook_test, grad_position=(0,1))
+            >>> output = ms_grad(Tensor(1, ms.float32), Tensor(2, ms.float32))
+            >>> 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)
+        return handle
+
     def flush_from_cache(self):
         """
         Flush cache data to host if tensor is cache enable.
@@ -1106,35 +1296,66 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(y)
             None
         """
-        self._init_check()
         Tensor_._flush_from_cache(self)
 
     def addcdiv(self, tensor1, tensor2, value=1):
         r"""
         For details, please refer to :func:`mindspore.ops.addcdiv`.
         """
-        self._init_check()
-        return tensor_operator_registry.get('addcdiv')()(self, tensor1, tensor2, value)
+        return tensor_operator_registry.get('addcdiv')(self, tensor1, tensor2, value)
 
     def addcmul(self, tensor1, tensor2, value=1):
         r"""
         For details, please refer to :func:`mindspore.ops.addcmul`.
         """
-        self._init_check()
-        return tensor_operator_registry.get('addcmul')()(self, tensor1, tensor2, value)
+        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`.
         """
-        self._init_check()
-        return tensor_operator_registry.get('add')()(self, other)
+        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`.
         """
-        self._init_check()
         return tensor_operator_registry.get('sub')(self, alpha * other)
 
     def true_divide(self, value):
@@ -1142,7 +1363,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         Alias for Tensor.div() with :math:`rounding\_mode=None`.
         For details, please refer to :func:`mindspore.ops.div`.
         """
-        self._init_check()
         return tensor_operator_registry.get('div')(self, value, rounding_mode=None)
 
     def triu(self, diagonal=0):
@@ -1153,7 +1373,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             This is an experimental API that is subject to change or deletion.
 
         """
-        self._init_check()
         validator.check_value_type('diagonal', diagonal, [int], 'triu')
         return tensor_operator_registry.get('triu')(self, diagonal)
 
@@ -1161,65 +1380,69 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         r"""
         For details, please refer to :func:`mindspore.ops.addbmm`.
         """
-        self._init_check()
         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`.
         """
-        self._init_check()
         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.
+
+        .. 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)
+
     def addr(self, vec1, vec2, beta=1, alpha=1):
         r"""
         For details, please refer to :func:`mindspore.ops.addr`.
         """
-        self._init_check()
         return tensor_operator_registry.get('addr')(self, vec1, vec2, beta=beta, alpha=alpha)
 
     def adjoint(self):
         r"""
         For details, please refer to :func:`mindspore.ops.adjoint`.
         """
-        self._init_check()
         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`.
         """
-        self._init_check()
         return tensor_operator_registry.get('all')(self, axis, keep_dims)
 
     def angle(self):
         r"""
         For details, please refer to :func:`mindspore.ops.angle`.
         """
-        self._init_check()
         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`.
         """
-        self._init_check()
         if axis is None:
             axis = ()
-        return tensor_operator_registry.get('any')(keep_dims)(self, 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`.
         """
-        self._init_check()
         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`.
         """
-        self._init_check()
         return tensor_operator_registry.get('baddbmm')(self, batch1, batch2, beta=beta, alpha=alpha)
 
     def view(self, *shape):
@@ -1243,7 +1466,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             [3. 2.]
             [3. 4.]]
         """
-        self._init_check()
         if not shape:
             raise ValueError("The shape variable should not be empty")
         if isinstance(shape[0], tuple):
@@ -1277,7 +1499,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(output)
             [1. 2. 3. 2. 3. 4.]
         """
-        self._init_check()
         if not isinstance(other, (Tensor, Tensor_)):
             raise TypeError(f"For view_as, the input other must be a Tensor, but got {type(other)}")
         return self.view(other.shape)
@@ -1286,42 +1507,36 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         r"""
         For details, please refer to :func:`mindspore.ops.t`.
         """
-        self._init_check()
         return tensor_operator_registry.get("t")(self)
 
     def bitwise_and(self, other):
         """
         For details, please refer to :func:`mindspore.ops.bitwise_and`.
         """
-        self._init_check()
         return tensor_operator_registry.get('bitwise_and')(self, other)
 
     def bitwise_or(self, other):
         """
         For details, please refer to :func:`mindspore.ops.bitwise_or`.
         """
-        self._init_check()
         return tensor_operator_registry.get('bitwise_or')(self, other)
 
     def bitwise_xor(self, other):
         """
         For details, please refer to :func:`mindspore.ops.bitwise_xor`.
         """
-        self._init_check()
         return tensor_operator_registry.get('bitwise_xor')(self, other)
 
     def bitwise_left_shift(self, other):
         """
         For details, please refer to :func:`mindspore.ops.bitwise_left_shift`.
         """
-        self._init_check()
         return tensor_operator_registry.get('bitwise_left_shift')(self, other)
 
     def bitwise_right_shift(self, other):
         """
         For details, please refer to :func:`mindspore.ops.bitwise_right_shift`.
         """
-        self._init_check()
         _cast = tensor_operator_registry.get('cast')
         other = _cast(other, self.dtype)
         return tensor_operator_registry.get('bitwise_right_shift')(self, other)
@@ -1330,50 +1545,43 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         For details, please refer to :func:`mindspore.ops.scatter`.
         """
-        self._init_check()
         return tensor_operator_registry.get('scatter')(self, axis, index, src)
 
     def scatter_mul(self, indices, updates):
         """
         For details, please refer to :func:`mindspore.ops.scatter_mul`.
         """
-        self._init_check()
         return tensor_operator_registry.get('tensor_scatter_mul')(self, indices, updates)
 
     def scatter_div(self, indices, updates):
         """
         For details, please refer to :func:`mindspore.ops.scatter_div`.
         """
-        self._init_check()
         return tensor_operator_registry.get('tensor_scatter_div')(self, indices, updates)
 
     def ger(self, vec2):
         """
         For details, please refer to :func:`mindspore.ops.ger`.
         """
-        self._init_check()
         return tensor_operator_registry.get('ger')(self, vec2)
 
     def gt(self, x):
         """
         For details, please refer to :func:`mindspore.ops.gt`.
         """
-        self._init_check()
-        return tensor_operator_registry.get('gt')()(self, x)
+        return tensor_operator_registry.get('gt')(self, x)
 
     def ge(self, x):
         """
         For details, please refer to :func:`mindspore.ops.ge`.
         """
-        self._init_check()
-        return tensor_operator_registry.get('ge')()(self, x)
+        return tensor_operator_registry.get('ge')(self, x)
 
     def broadcast_to(self, shape):
         """
         For details, please refer to :func:`mindspore.ops.broadcast_to`.
         """
-        self._init_check()
-        return tensor_operator_registry.get('broadcast_to')(shape)(self)
+        return tensor_operator_registry.get('broadcast_to')(self, shape)
 
     def expand_as(self, x):
         """
@@ -1397,84 +1605,73 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             [[1. 2. 3.]
             [1. 2. 3.]]
         """
-        self._init_check()
-        return tensor_operator_registry.get('broadcast_to')(x.shape)(self)
+        return tensor_operator_registry.get('broadcast_to')(self, x.shape)
 
     def exp(self):
         """
         For details, please refer to :func:`mindspore.ops.exp`.
         """
-        self._init_check()
         return tensor_operator_registry.get('exp')(self)
 
     def real(self):
         r"""
         For details, please refer to :func:`mindspore.ops.real`.
         """
-        self._init_check()
         return tensor_operator_registry.get('real')(self)
 
     def rsqrt(self):
         r"""
         For details, please refer to :func:`mindspore.ops.rsqrt`.
         """
-        self._init_check()
         return tensor_operator_registry.get('rsqrt')(self)
 
     def reciprocal(self):
         r"""
         For details, please refer to :func:`mindspore.ops.reciprocal`.
         """
-        self._init_check()
         return tensor_operator_registry.get('reciprocal')(self)
 
     def sqrt(self):
         """
         For details, please refer to :func:`mindspore.ops.sqrt`.
         """
-        self._init_check()
         return tensor_operator_registry.get('sqrt')(self)
 
     def square(self):
         """
         For details, please refer to :func:`mindspore.ops.square`.
         """
-        self._init_check()
         return tensor_operator_registry.get('square')(self)
 
+    @sub_mint
     def sub(self, y):
         r"""
         For details, please refer to :func:`mindspore.ops.sub`.
         """
-        self._init_check()
         return tensor_operator_registry.get('sub')(self, y)
 
     def tan(self):
         """
         For details, please refer to :func:`mindspore.ops.tan`.
         """
-        self._init_check()
-        return tensor_operator_registry.get('tan')()(self)
+        return tensor_operator_registry.get('tan')(self)
 
     def tanh(self):
         r"""
         For details, please refer to :func:`mindspore.ops.tanh`.
         """
-        self._init_check()
         return tensor_operator_registry.get('tanh')(self)
 
     def cosh(self):
         r"""
         For details, please refer to :func:`mindspore.ops.cosh`.
         """
-        self._init_check()
-        return tensor_operator_registry.get('cosh')()(self)
+        return tensor_operator_registry.get('cosh')(self)
 
     def acos(self):
         r"""
         For details, please refer to :func:`mindspore.ops.acos`.
         """
-        self._init_check()
         return tensor_operator_registry.get('acos')(self)
 
     def arccos(self):
@@ -1487,35 +1684,30 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         r"""
         For details, please refer to :func:`mindspore.ops.cos`.
         """
-        self._init_check()
         return tensor_operator_registry.get('cos')(self)
 
     def cov(self, *, correction=1, fweights=None, aweights=None):
         r"""
         For details, please refer to :func:`mindspore.ops.cov`.
         """
-        self._init_check()
         return tensor_operator_registry.get('cov')(self, correction=correction, fweights=fweights, aweights=aweights)
 
     def acosh(self):
         """
         For details, please refer to :func:`mindspore.ops.acosh`.
         """
-        self._init_check()
         return tensor_operator_registry.get('acosh')(self)
 
     def asin(self):
         r"""
         For details, please refer to :func:`mindspore.ops.asin`.
         """
-        self._init_check()
         return tensor_operator_registry.get('asin')(self)
 
     def abs(self):
         """
         For details, please refer to :func:`mindspore.ops.abs`.
         """
-        self._init_check()
         return tensor_operator_registry.get('abs')(self)
 
     def absolute(self):
@@ -1528,14 +1720,12 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         For details, please refer to :func:`mindspore.ops.ceil`.
         """
-        self._init_check()
-        return tensor_operator_registry.get('ceil')()(self)
+        return tensor_operator_registry.get('ceil')(self)
 
     def floor(self):
         """
         For details, please refer to :func:`mindspore.ops.floor`.
         """
-        self._init_check()
         return tensor_operator_registry.get('floor')(self)
 
     def floor_divide(self, other):
@@ -1545,21 +1735,18 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         .. 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`.
         """
-        self._init_check()
         return tensor_operator_registry.get('lerp')(self, end, weight)
 
     def negative(self):
         r"""
         For details, please refer to :func:`mindspore.ops.negative`.
         """
-        self._init_check()
         return tensor_operator_registry.get("negative")(self)
 
     # pylint: disable=redefined-builtin
@@ -1567,14 +1754,12 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         For details, please refer to :func:`mindspore.ops.norm`.
         """
-        self._init_check()
         return tensor_operator_registry.get('norm')(self, ord, dim, keepdim, dtype=dtype)
 
     def renorm(self, p, axis, maxnorm):
         """
         For details, please refer to :func:`mindspore.ops.renorm`.
         """
-        self._init_check()
         return tensor_operator_registry.get("renorm")(self, p, axis, maxnorm)
 
     def approximate_equal(self, other, tolerance=1e-5):
@@ -1584,7 +1769,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         validator.check_isinstance("x", self, Tensor)
         validator.check_isinstance("y", other, Tensor)
         validator.check_isinstance("tolerance", tolerance, float)
-        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')(
@@ -1595,14 +1779,12 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         r"""
         For details, please refer to :func:`mindspore.ops.log1p`.
         """
-        self._init_check()
         return tensor_operator_registry.get('log1p')(self)
 
     def logit(self, eps=None):
         r"""
         For details, please refer to :func:`mindspore.ops.logit`.
         """
-        self._init_check()
         if eps is None:
             eps = -1.0
         validator.check_value_type('eps', eps, (float,), 'Tensor.logit')
@@ -1612,14 +1794,12 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         r"""
         For details, please refer to :func:`mindspore.ops.logaddexp`.
         """
-        self._init_check()
         return tensor_operator_registry.get('logaddexp')(self, other)
 
     def logaddexp2(self, other):
         r"""
         For details, please refer to :func:`mindspore.ops.logaddexp2`.
         """
-        self._init_check()
         return tensor_operator_registry.get('logaddexp2')(self, other)
 
     def logcumsumexp(self, axis):
@@ -1629,149 +1809,129 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         .. 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`.
         """
-        self._init_check()
         return tensor_operator_registry.get('logsumexp')(self, axis, keepdims)
 
     def logdet(self):
         r"""
         For details, please refer to :func:`mindspore.ops.logdet`.
         """
-        self._init_check()
         return tensor_operator_registry.get('logdet')(self)
 
     def i0(self):
         r"""
         For details, please refer to :func:`mindspore.ops.i0`.
         """
-        self._init_check()
         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`.
         """
-        self._init_check()
         return tensor_operator_registry.get('isclose')(self, x2, rtol, atol, equal_nan)
 
     def isneginf(self):
         r"""
         For details, please refer to :func:`mindspore.ops.isneginf`.
         """
-        self._init_check()
         return tensor_operator_registry.get('isneginf')(self)
 
     def isposinf(self):
         r"""
         For details, please refer to :func:`mindspore.ops.isposinf`.
         """
-        self._init_check()
         return tensor_operator_registry.get('isposinf')(self)
 
     def isreal(self):
         r"""
         For details, please refer to :func:`mindspore.ops.isreal`.
         """
-        self._init_check()
         return tensor_operator_registry.get('isreal')(self)
 
     def isfinite(self):
         r"""
         For details, please refer to :func:`mindspore.ops.isfinite`.
         """
-        self._init_check()
-        return tensor_operator_registry.get('isfinite')()(self)
+        return tensor_operator_registry.get('isfinite')(self)
 
     def is_complex(self):
         r"""
         For details, please refer to :func:`mindspore.ops.is_complex`.
         """
-        self._init_check()
         return tensor_operator_registry.get('is_complex')(self)
 
     def inv(self):
         r"""
         For details, please refer to :func:`mindspore.ops.inv`.
         """
-        self._init_check()
         return tensor_operator_registry.get('inv')(self)
 
     def inverse(self):
         r"""
         For details, please refer to :func:`mindspore.ops.inverse`.
         """
-        self._init_check()
         return tensor_operator_registry.get('inverse')(self)
 
     def invert(self):
         r"""
         For details, please refer to :func:`mindspore.ops.invert`.
         """
-        self._init_check()
         return tensor_operator_registry.get('invert')(self)
 
     def pow(self, exponent):
         r"""
         For details, please refer to :func:`mindspore.ops.pow`.
         """
-        self._init_check()
-        return tensor_operator_registry.get('pow')()(self, exponent)
+        return tensor_operator_registry.get('pow')(self, exponent)
 
     def log(self):
         """
         For details, please refer to :func:`mindspore.ops.log`.
         """
-        self._init_check()
         return tensor_operator_registry.get('log')(self)
 
     def log10(self):
         r"""
         For details, please refer to :func:`mindspore.ops.log10`.
         """
-        self._init_check()
         return tensor_operator_registry.get('log10')(self)
 
     def log2(self):
         r"""
         For details, please refer to :func:`mindspore.ops.log2`.
         """
-        self._init_check()
         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`.
         """
-        self._init_check()
         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`.
         """
-        self._init_check()
         if axis is None:
             axis = ()
         return tensor_operator_registry.get('amin')(self, axis, keepdims, initial=initial, where=where)
 
     def reverse(self, axis):
         """
-        For details, please refer to :func:`mindspore.ops.reverse`.
+        For details, please refer to :func:`mindspore.ops.flip`.
         """
-        self._init_check()
-        return tensor_operator_registry.get('reverse')(axis)(self)
+        return tensor_operator_registry.get('flip')(self, axis)
 
     def amax(self, axis=None, keepdims=False, *, initial=None, where=None):
         """
         For details, please refer to :func:`mindspore.ops.amax`.
         """
-        self._init_check()
         if axis is None:
             axis = ()
         return tensor_operator_registry.get('amax')(self, axis, keepdims, initial=initial, where=where)
@@ -1780,28 +1940,24 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         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`.
         """
-        self._init_check()
-        return tensor_operator_registry.get("reverse_sequence")(seq_dim, batch_dim)(self, seq_lengths)
+        return tensor_operator_registry.get("reverse_sequence")(self, seq_lengths, seq_dim, batch_dim)
 
-    def prod(self, axis=None, keep_dims=False):
+    def prod(self, axis=None, keep_dims=False, dtype=None):
         """
         For details, please refer to :func:`mindspore.ops.prod`.
         """
-        self._init_check()
-        return tensor_operator_registry.get('prod')(self, axis, keep_dims)
+        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`.
         """
-        self._init_check()
         if not isinstance(condition, Tensor):
             raise TypeError(f"For 'Tensor.select', the argument 'condition' should be Tensor,"
                             f" but got {type(condition)}.")
@@ -1816,7 +1972,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
                             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
+            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:
@@ -1827,22 +1983,46 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         r"""
         For details, please refer to :func:`mindspore.ops.transpose`.
         """
-        self._init_check()
         perm = validator.check_transpose_axis(axes, self.ndim)
-        return tensor_operator_registry.get('transpose')()(self, perm)
+        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`.
         """
-        self._init_check()
         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]]
         """
-        For details, please refer to :func:`mindspore.ops.reshape`.
-        """
-        self._init_check()
         new_shape = validator.check_reshape_shp(shape)
         return tensor_operator_registry.get('reshape')(self, new_shape)
 
@@ -1871,7 +2051,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
              [ 3.6  0.4]
              [ 0.5 -3.2]]
         """
-        self._init_check()
         return tensor_operator_registry.get('reshape')(self, other.shape)
 
     def ravel(self):
@@ -1881,13 +2060,12 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         Returns:
             Tensor, a 1-D tensor, containing the same elements of the input.
 
-        Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
-
         See also:
-            :func:`mindspore.Tensor.reshape`: Give a new shape to a tensor without changing its data.
+            - :func:`mindspore.Tensor.reshape`: Give a new shape to a tensor without changing its data.
+            - :func:`mindspore.Tensor.flatten`: Return a copy of the tensor collapsed into one dimension.
 
-            :func:`mindspore.Tensor.flatten`: Return a copy of the tensor collapsed into one dimension.
+        Supported Platforms:
+            ``Ascend`` ``GPU`` ``CPU``
 
         Examples:
             >>> import numpy as np
@@ -1897,85 +2075,73 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(output.shape)
             (24,)
         """
-        self._init_check()
         reshape_op = tensor_operator_registry.get('reshape')
         return reshape_op(self, (-1,))
 
-    def round(self):
+    def round(self, decimals=0):
         """
         For details, please refer to :func:`mindspore.ops.round`.
         """
-        self._init_check()
-        return tensor_operator_registry.get('round')()(self)
+        return tensor_operator_registry.get('round')(self, decimals=decimals)
 
     def roll(self, shifts, dims):
         """
         For details, please refer to :func:`mindspore.ops.roll`.
         """
-        self._init_check()
         return tensor_operator_registry.get('roll')(shifts, dims)(self)
 
     def rot90(self, k, dims):
         r"""
         For details, please refer to :func:`mindspore.ops.rot90`.
         """
-        self._init_check()
         return tensor_operator_registry.get('rot90')(self, k, dims)
 
     def deg2rad(self):
         r"""
         For details, please refer to :func:`mindspore.ops.deg2rad`.
         """
-        self._init_check()
         return tensor_operator_registry.get('deg2rad')(self)
 
     def dot(self, other):
         r"""
         For details, please refer to :func:`mindspore.ops.dot`.
         """
-        self._init_check()
         return tensor_operator_registry.get('dot')(self, other)
 
     def 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`.
         """
-        self._init_check()
         return tensor_operator_registry.get('rad2deg')(self)
 
     def copysign(self, other):
         r"""
         For details, please refer to :func:`mindspore.ops.copysign`.
         """
-        self._init_check()
         return tensor_operator_registry.get('copysign')(self, other)
 
     def nelement(self):
         r"""
         Alias for :func:`mindspore.Tensor.numel`.
         """
-        self._init_check()
         return tensor_operator_registry.get('nelement')(self)
 
     def numel(self):
         r"""
         For details, please refer to :func:`mindspore.ops.numel`.
         """
-        self._init_check()
         return tensor_operator_registry.get('numel')(self)
 
     def permute(self, *axis):
         """
         For details, please refer to :func:`mindspore.ops.permute`.
         """
-        self._init_check()
         perm = validator.check_transpose_axis(axis, self.ndim)
         return tensor_operator_registry.get('permute')(self, perm)
 
@@ -1983,98 +2149,85 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         For details, please refer to :func:`mindspore.ops.positive`.
         """
-        self._init_check()
         return tensor_operator_registry.get("positive")(self)
 
     def remainder(self, divisor):
         r"""
         For details, please refer to :func:`mindspore.ops.remainder`.
         """
-        self._init_check()
         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`.
         """
-        self._init_check()
         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`.
         """
-        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`.
         """
-        self._init_check()
         return tensor_operator_registry.get('fmod')(self, other)
 
     def narrow(self, axis, start, length):
         """
         For details, please refer to :func:`mindspore.ops.narrow`.
         """
-        self._init_check()
         return tensor_operator_registry.get('narrow')(self, axis, start, length)
 
     def swapaxes(self, axis0, axis1):
         """
         For details, please refer to :func:`mindspore.ops.swapaxes`.
         """
-        self._init_check()
         return tensor_operator_registry.get('swapaxes')(self, axis0, axis1)
 
     def swapdims(self, dim0, dim1):
         """
         For details, please refer to :func:`mindspore.ops.swapdims`.
         """
-        self._init_check()
         return tensor_operator_registry.get('swapdims')(self, dim0, dim1)
 
     def squeeze(self, axis=None):
         """
         For details, please refer to :func:`mindspore.ops.squeeze`.
         """
-        self._init_check()
         return tensor_operator_registry.get('squeeze')(self, axis)
 
     def slogdet(self):
         """
         For details, please refer to :func:`mindspore.ops.slogdet`.
         """
-        self._init_check()
         return tensor_operator_registry.get('slogdet')(self)
 
     def tril(self, diagonal=0):
         """
         For details, please refer to :func:`mindspore.ops.tril`.
         """
-        self._init_check()
         return tensor_operator_registry.get('tril')(self, diagonal)
 
     def unsqueeze(self, dim):
         """
         For details, please refer to :func:`mindspore.ops.unsqueeze`.
         """
-        self._init_check()
         validator.check_is_int(dim, 'dim')
         validator.check_int_range(dim, -self.ndim - 1, self.ndim + 1, validator.INC_LEFT, 'dim')
         return tensor_operator_registry.get('unsqueeze')(self, dim)
@@ -2083,7 +2236,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         For details, please refer to :func:`mindspore.ops.expand_dims`.
         """
-        self._init_check()
         validator.check_is_int(axis, 'axis')
         validator.check_int_range(axis, -self.ndim - 1, self.ndim + 1, validator.INC_LEFT, 'axis')
         return tensor_operator_registry.get('expand_dims')(self, axis)
@@ -2116,7 +2268,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(x.dtype)
             Int32
         """
-        self._init_check()
         dtype = _check_astype_and_convert(dtype)
         if not copy and dtype == self.dtype:
             return self
@@ -2126,7 +2277,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         For details, please refer to :func:`mindspore.ops.argmax`.
         """
-        self._init_check()
         out = tensor_operator_registry.get('argmax')(self, axis, keepdims)
         return out
 
@@ -2134,7 +2284,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         For details, please refer to :func:`mindspore.ops.argmin`.
         """
-        self._init_check()
         out = tensor_operator_registry.get('argmin')(self, axis, keepdims)
         return out
 
@@ -2185,7 +2334,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         if self.shape == ():
             return (self, Tensor(0))
-        self._init_check()
         return tensor_operator_registry.get('argmax_with_value')(self, axis, keep_dims)
 
     def argmin_with_value(self, axis=0, keep_dims=False):
@@ -2233,7 +2381,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         if self.shape == ():
             return (self, Tensor(0))
-        self._init_check()
         return tensor_operator_registry.get('argmin_with_value')(self, axis, keep_dims)
 
     def cumsum(self, axis=None, dtype=None):
@@ -2275,15 +2422,13 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         For details, please refer to :func:`mindspore.ops.index_select`.
         """
-        self._init_check()
         return tensor_operator_registry.get('index_select')(self, axis, index)
 
     def inplace_update(self, v, indices):
         """
         For details, please refer to :func:`mindspore.ops.inplace_update`.
         """
-        self._init_check()
-        return tensor_operator_registry.get('inplace_update')()(self, indices, v)
+        return tensor_operator_registry.get('inplace_update')(self, v, indices)
 
     def copy(self):
         """
@@ -2321,6 +2466,38 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         x = x.astype(origin_dtype)
         return x
 
+    def copy_(self, src, non_blocking=False):
+        """
+        Copies the elements from src into self tensor and returns self.
+
+        .. 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.
+
+        Args:
+            src (Tensor): the source tensor to copy from.
+            non_blocking (bool): no effect currently.
+
+        Returns:
+            Return self Tensor.
+
+        Supported Platforms:
+            ``Ascend``
+
+        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.
@@ -2357,15 +2534,13 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         Raises:
             TypeError: If arguments have types not specified above.
 
-        Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
-
         See also:
-            :func:`mindspore.Tensor.argmin`: Return the indices of the minimum values along an axis.
-
-            :func:`mindspore.Tensor.argmax`: Return the indices of the maximum values along an axis.
+            - :func:`mindspore.Tensor.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.
 
-            :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
@@ -2380,7 +2555,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(indices)
             [1 1]
         """
-        self._init_check()
         if isinstance(axis, (list, tuple)):
             reduce_ = tensor_operator_registry.get("reduce")
             reduce_max = tensor_operator_registry.get("reduce_max")
@@ -2392,6 +2566,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             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.
@@ -2428,15 +2603,13 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         Raises:
             TypeError: If arguments have types not specified above.
 
-        Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
-
         See also:
-            :func:`mindspore.Tensor.argmin`: Return the indices of the minimum values along an axis.
-
-            :func:`mindspore.Tensor.argmax`: Return the indices of the maximum values along an axis.
+            - :func:`mindspore.Tensor.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.
 
-            :func:`mindspore.Tensor.max`: Return the minimum of a tensor or minimum along an axis.
+        Supported Platforms:
+            ``Ascend`` ``GPU`` ``CPU``
 
         Examples:
             >>> import numpy as np
@@ -2460,12 +2633,11 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(indices)
             [0 0]
         """
-        self._init_check()
         if isinstance(axis, (list, tuple)):
             reduce_ = tensor_operator_registry.get("reduce")
             reduce_min = tensor_operator_registry.get("reduce_min")
             minimum = tensor_operator_registry.get("minimum")
-            return reduce_(self, reduce_min(keepdims), cmp_fn=minimum(), axis=axis, keepdims=keepdims,
+            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:
@@ -2476,7 +2648,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         For details, please refer to :func:`mindspore.ops.scatter_add`.
         """
-        self._init_check()
         return tensor_operator_registry.get("tensor_scatter_add")(self, indices, updates)
 
     def scatter_sub(self, indices, updates):
@@ -2489,7 +2660,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
         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 use cases.
+        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,
@@ -2524,28 +2695,30 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             [[-3.3000002  0.3        3.6      ]
             [ 0.4        0.5       -3.2      ]]
         """
-        self._init_check()
         return tensor_operator_registry.get('tensor_scatter_sub')(self, indices, updates)
 
     def scatter_min(self, indices, updates):
         """
         For details, please refer to :func:`mindspore.ops.scatter_min`.
         """
-        self._init_check()
-        return tensor_operator_registry.get('tensor_scatter_min')()(self, indices, updates)
+        return tensor_operator_registry.get('tensor_scatter_min')(self, indices, updates)
 
     def scatter_max(self, indices, updates):
         """
         For details, please refer to :func:`mindspore.ops.scatter_max`.
         """
-        self._init_check()
-        return tensor_operator_registry.get('tensor_scatter_max')()(self, indices, updates)
+        return tensor_operator_registry.get('tensor_scatter_max')(self, indices, updates)
+
+    def softmax(self, axis, dtype=None):
+        """
+        For details, please refer to :func:`mindspore.ops.softmax`.
+        """
+        return tensor_operator_registry.get('softmax')(self, axis, dtype=dtype)
 
     def fill(self, value):
         """
         `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 "
@@ -2558,7 +2731,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         `Tensor.fills` is deprecated, please use `ops.fill` instead.
         """
-        self._init_check()
         return tensor_operator_registry.get('fills')(self, value)
 
     def fill_diagonal(self, fill_value, wrap=False):
@@ -2600,14 +2772,12 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
              [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`.
         """
-        self._init_check()
         if isinstance(value, (float, int)):
             value = tensor_operator_registry.get("scalar_to_tensor")(value, self.dtype)
         if not isinstance(mask, Tensor):
@@ -2663,13 +2833,12 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         r"""
         For details, please refer to :func:`mindspore.ops.minimum`.
         """
-        return tensor_operator_registry.get('minimum')()(self, other)
+        return tensor_operator_registry.get('minimum')(self, other)
 
     def clamp(self, min=None, max=None):
         r"""
         For details, please refer to :func:`mindspore.ops.clamp`.
         """
-        self._init_check()
         return tensor_operator_registry.get('clamp')(self, min, max)
 
     def clip(self, min=None, max=None):
@@ -2678,10 +2847,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return self.clamp(min, max)
 
-    def _init_check(self):
-        if self.has_init:
-            self.init_data()
-
     def init_data(self, slice_index=None, shape=None, opt_shard_group=None):
         """
         Get the tensor format data of this Tensor.
@@ -2698,7 +2863,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/tutorials/experts/en/r2.2/parallel/optimizer_parallel.html>`_.
+                <https://www.mindspore.cn/docs/en/master/model_train/parallel/optimizer_parallel.html>`_.
                 Default: ``None``.
 
         Returns:
@@ -2776,12 +2941,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         if slice_num_of_persistent_data > 1:
             self.assign_value(Tensor_.persistent_data_from_numpy(data, slice_num_of_persistent_data))
         else:
-            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))
+            self.assign_value(Tensor_.from_numpy(data))
         return self
 
     def resize(self, *new_shape):
@@ -2803,13 +2963,12 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         Returns:
             Tensor.
 
-        Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
-
         See also:
-            :func:`mindspore.Tensor.reshape`: Give a new shape to a tensor without changing its data.
+            - :func:`mindspore.Tensor.reshape`: Give a new shape to a tensor without changing its data.
+            - :func:`mindspore.Tensor.repeat`: Repeat elements of a tensor.
 
-            :func:`mindspore.Tensor.repeat`: Repeat elements of a tensor.
+        Supported Platforms:
+            ``Ascend`` ``GPU`` ``CPU``
 
         Examples:
             >>> import numpy as np
@@ -2836,7 +2995,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         diff_size = new_size - cur_size
         if diff_size > 0:
             pad_val = tensor_operator_registry.get('fill')(self.dtype, (diff_size,), 0)
-            res = tensor_operator_registry.get('concatenate')(0)((flattened, pad_val))
+            res = tensor_operator_registry.get('concatenate')((flattened, pad_val), 0)
         else:
             res = flattened[:new_size]
         return res.reshape(new_shape)
@@ -2845,70 +3004,60 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         r"""
         For details, please refer to :func:`mindspore.ops.det`.
         """
-        self._init_check()
         return tensor_operator_registry.get('det')(self)
 
     def diff(self, n=1, axis=-1, prepend=None, append=None):
         r"""
         For details, please refer to :func:`mindspore.ops.diff`.
         """
-        self._init_check()
         return tensor_operator_registry.get('diff')(self, n, axis, prepend, append)
 
     def frac(self):
         r"""
         For details, please refer to :func:`mindspore.ops.frac`.
         """
-        self._init_check()
         return tensor_operator_registry.get('frac')(self)
 
     def argwhere(self):
         r"""
         For details, please refer to :func:`mindspore.ops.argwhere`.
         """
-        self._init_check()
         return tensor_operator_registry.get('argwhere')(self)
 
     def moveaxis(self, source, destination):
         r"""
         For details, please refer to :func:`mindspore.ops.moveaxis`.
         """
-        self._init_check()
         return tensor_operator_registry.get('moveaxis')(self, source, destination)
 
     def movedim(self, source, destination):
         r"""
         For details, please refer to :func:`mindspore.ops.movedim`.
         """
-        self._init_check()
         return tensor_operator_registry.get('movedim')(self, source, destination)
 
     def digamma(self):
         r"""
         For details, please refer to :func:`mindspore.ops.digamma`.
         """
-        self._init_check()
         return tensor_operator_registry.get('digamma')(self)
 
     def lgamma(self):
         r"""
         For details, please refer to :func:`mindspore.ops.lgamma`.
         """
-        self._init_check()
         return tensor_operator_registry.get('lgamma')(self)
 
     def diagonal(self, offset=0, axis1=0, axis2=1):
         """
         For details, please refer to :func:`mindspore.ops.diagonal`.
         """
-        self._init_check()
         return tensor_operator_registry.get('diagonal')(self, offset, axis1, axis2)
 
     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):
@@ -2933,12 +3082,12 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         Raises:
             ValueError: If the input tensor has less than two dimensions.
 
+        See also:
+            - :func:`mindspore.Tensor.diagonal`: Return specified diagonals.
+
         Supported Platforms:
             ``Ascend`` ``GPU`` ``CPU``
 
-        See also:
-            :func:`mindspore.Tensor.diagonal`: Return specified diagonals.
-
         Examples:
             >>> import numpy as np
             >>> from mindspore import Tensor
@@ -2946,17 +3095,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(x.trace())
             3.0
         """
-        if offset == 0 and axis1 == 0 and axis2 == 1 and dtype is None:
-            self._init_check()
-            return tensor_operator_registry.get('trace')(self)
-        d = self.diagonal(offset, axis1=axis1, axis2=axis2)
-        shape = d.shape
-        if dtype is None:
-            dtype = d.dtype
-        if shape[-1] == 0:
-            return tensor_operator_registry.get('fill')(dtype, shape[:-1], 0)
-        res = tensor_operator_registry.get('reduce_sum')(d.astype(mstype.float32), -1)
-        return res.astype(dtype)
+        return tensor_operator_registry.get('tracev2')(self, offset, axis1, axis2, dtype)
 
     def take(self, indices, axis=None, mode='clip'):
         """
@@ -3020,7 +3159,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         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')(shape_indices)(indices)
+        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)
@@ -3065,7 +3204,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         if isinstance(choices, Tensor):
             shape_choice = validator.infer_out_shape(self.shape, choices.shape[1:])
-            choices = tensor_operator_registry.get('broadcast_to')((choices.shape[0],) + shape_choice)(choices)
+            choices = tensor_operator_registry.get('broadcast_to')(choices, (choices.shape[0],) + shape_choice)
         else:
             # broadcasts choices to the same shape if choices is a sequence
             choicelist = []
@@ -3078,14 +3217,14 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             shape_choice = validator.infer_out_shape(self.shape, *shapes)
             tmp = []
             for choice in choicelist:
-                tmp.append(tensor_operator_registry.get('broadcast_to')(shape_choice)(choice))
+                tmp.append(tensor_operator_registry.get('broadcast_to')(choice, shape_choice))
             choices = tensor_operator_registry.get('stack')(tmp, 0)
 
         if self.ndim == 0 or choices.ndim == 0:
             raise ValueError(f"For 'Tensor.choose', the original tensor and the argument 'choices' cannot be scalars."
                              f" Their dimensions should all be > 0, but got the original tensor's dimension "
                              f"{self.ndim}, 'choices' dimension {choices.ndim}.")
-        a = tensor_operator_registry.get('broadcast_to')(shape_choice)(self)
+        a = tensor_operator_registry.get('broadcast_to')(self, shape_choice)
         dtype = choices.dtype
         # adjusts dtype for F.tensor_mul and F.gather_nd
         a = a.astype(mstype.int32)
@@ -3097,10 +3236,10 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         for i in range(ndim):
             dim_grid = Tensor(list(range(a.shape[i])), mstype.int32)
             dim_shape = validator.expanded_shape(ndim, a.shape[i], i)
-            dim_grid = tensor_operator_registry.get('broadcast_to')(a.shape)(dim_grid.reshape(dim_shape))
+            dim_grid = tensor_operator_registry.get('broadcast_to')(dim_grid.reshape(dim_shape), a.shape)
             grids.append(dim_grid)
         grid = tensor_operator_registry.get('stack')(grids, -1)
-        indices = tensor_operator_registry.get('concatenate')(-1)((a.reshape(a.shape + (1,)), grid))
+        indices = tensor_operator_registry.get('concatenate')((a.reshape(a.shape + (1,)), grid), -1)
         return tensor_operator_registry.get('gather_nd')(choices, indices).astype(dtype)
 
     def searchsorted(self, v, side='left', sorter=None):
@@ -3113,9 +3252,10 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
                 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, 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`` .
+            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`.
@@ -3136,37 +3276,26 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         if side not in ('left', 'right'):
             raise ValueError(f"For 'Tensor.searchsorted', the argument 'side' should be one of in "
                              f"['left', 'right'], but got {side}.")
-        a = self.astype(mstype.float32)
         if not isinstance(v, Tensor):
             v = tensor_operator_registry.get('make_tensor')(v)
-        shape = v.shape
         if sorter is not None:
-            if not isinstance(sorter, (int, float, bool, list, tuple, Tensor)):
+            if not isinstance(sorter, (int, list, tuple, Tensor)):
                 raise TypeError("For Tensor.searchsorted, the type of the argument 'sorter' must be one of 'int', "
-                                "'float', 'bool', 'list', 'tuple', 'Tensor', but got {}.".format(type(sorter)))
+                                "'list', 'tuple', 'Tensor', but got {}.".format(type(sorter)))
             if not isinstance(sorter, Tensor):
                 sorter = tensor_operator_registry.get('make_tensor')(sorter)
-            if sorter.ndim != 1 or sorter.size != a.size:
-                raise ValueError('sorter must be 1-D array with the same size as the Tensor')
-            sorter = sorter.reshape(sorter.shape + (1,))
-            a = tensor_operator_registry.get('gather_nd')(a, sorter)
-        less_op = tensor_operator_registry.get('__le__') if side == 'left' else tensor_operator_registry.get('__lt__')
-        i = tensor_operator_registry.get('fill')(mstype.int32, shape, 0)
-        j = tensor_operator_registry.get('fill')(mstype.int32, shape, a.size)
-
-        sort_range = tuple(range(math.ceil(math.log2(tensor_operator_registry.get('shape_mul')(a.shape) + 1))))
-        for _ in sort_range:
-            mid = (i - -j) // 2
-            mask = less_op(v, tensor_operator_registry.get('gather_nd')(a, mid.reshape(mid.shape + (1,))))
-            i = tensor_operator_registry.get('select')(mask, i, mid)
-            j = tensor_operator_registry.get('select')(mask, mid, j)
-        return j
+            if sorter.size != self.size:
+                raise ValueError('The size of sorter must be the same as the Tensor')
+
+        dtype = mstype.int32
+        right = (side == 'right')
+        search_sorted_ = tensor_operator_registry.get('searchsorted')(dtype, right)
+        return search_sorted_(self, v, sorter)
 
     def gather_nd(self, indices):
         r"""
         For details, please refer to :func:`mindspore.ops.gather_nd`.
         """
-        self._init_check()
         validator.check_value_type('indices', indices, (Tensor, Tensor_,), 'Tensor.gather_nd')
         return tensor_operator_registry.get('gather_nd')(self, indices)
 
@@ -3174,11 +3303,39 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         r"""
         For details, please refer to :func:`mindspore.ops.gather`.
         """
-        self._init_check()
         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).
+
+        Args:
+            from\_ (number): The lower bound of the interval.
+            to (number): The upper bound of the interval.
+            generator (Generator, optional): The random seed. Default: None.
+
+        Returns:
+            Tensor, with the same shape as tensor.
+
+        Raises:
+            TypeError: If `from_` is larger than `to`.
+
+        Supported Platforms:
+            ``Ascend``
+
+        Examples:
+            >>> import mindspore
+            >>> x = mindspore.ops.ones((4, 2))
+            >>> generator = mindspore.Generator()
+            >>> generator.manual_seed(100)
+            >>> output = x.uniform(1., 2., generator)
+            >>> print(output.shape)
+            (4, 2)
+        """
+        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.
@@ -3202,13 +3359,12 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         Returns:
             Variance tensor.
 
-        Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
-
         See also:
-            :func:`mindspore.Tensor.mean`: Reduce a dimension of a tensor by averaging all elements in the dimension.
+            - :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.
 
-            :func:`mindspore.Tensor.std`: Compute the standard deviation along the specified axis.
+        Supported Platforms:
+            ``Ascend`` ``GPU`` ``CPU``
 
         Examples:
             >>> import numpy as np
@@ -3255,40 +3411,40 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         Return sum of tensor elements over a given axis.
 
         Note:
-            Numpy arguments `out`, `where`, `casting`, `order`, `subok`, `signature`, and
-            `extobj` are not supported.
+            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)]): Axis or axes along which a sum is performed.
+            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.
+                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
+                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`` .
+                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.
+            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.
 
         Raises:
-            TypeError: If input is not array_like, or `axis` is not int, tuple of ints or list of ints,
+            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.
+            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`.
 
         Supported Platforms:
             ``Ascend`` ``GPU`` ``CPU``
 
-        See also:
-            :func:`mindspore.Tensor.cumsum`: Return the cumulative sum of the elements along a given axis.
-
         Examples:
             >>> import numpy as np
             >>> from mindspore import Tensor
@@ -3299,13 +3455,12 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(input_x.sum(axis=1))
             [10. 35.]
         """
-        if initial is not None and not isinstance(initial, (int, float, bool)):
-            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
-        if dtype is not None:
-            res = res.astype(dtype)
+        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
 
     def sum_to_size(self, *size):
@@ -3333,7 +3488,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(output.shape)
             (1, 3, 1, 3)
         """
-        self._init_check()
         x = self
         if len(size) == 1 and isinstance(size[0], tuple):
             size = size[0]
@@ -3357,21 +3511,18 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         For details, please refer to :func:`mindspore.ops.nansum`.
         """
-        self._init_check()
         return tensor_operator_registry.get('nansum')(self, axis=axis, keepdims=keepdims, dtype=dtype)
 
     def 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):
@@ -3391,13 +3542,12 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             ValueError: If the axis is out of range.
             TypeError: If arguments have types not specified above.
 
-        Supported Platforms:
-            ``Ascend`` ``GPU`` ``CPU``
-
         See also:
-            :func:`mindspore.Tensor.reshape`: Give a new shape to a tensor without changing its data.
+            - :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.
 
-            :func:`mindspore.Tensor.resize`: Changes shape and size of tensor in-place.
+        Supported Platforms:
+            ``Ascend`` ``GPU`` ``CPU``
 
         Examples:
             >>> import numpy as np
@@ -3446,27 +3596,25 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         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')(axis)(repeated_subs)
+        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`.
         """
-        self._init_check()
         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`.
         """
-        self._init_check()
         return tensor_operator_registry.get('bernoulli')(self, p, seed)
 
     def random_categorical(self, num_sample, seed=0, dtype=mstype.int64):
         r"""
         For details, please refer to :func:`mindspore.ops.random_categorical`.
         """
-        self._init_check()
         validator.check_is_int(num_sample, 'num_sample')
         validator.check_is_int(seed, 'seed')
         return tensor_operator_registry.get('random_categorical')(self, num_sample, seed, dtype)
@@ -3475,23 +3623,20 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         For details, please refer to :func:`mindspore.ops.masked_select`.
         """
-        self._init_check()
         return tensor_operator_registry.get('masked_select')(self, mask)
 
     def gather_elements(self, dim, index):
         """
         For details, please refer to :func:`mindspore.ops.gather_elements`.
         """
-        self._init_check()
         validator.check_value_type('index', index, (Tensor, Tensor_,), 'Tensor.gather_elements')
         return tensor_operator_registry.get('gather_elements')(self, dim, index)
 
-    def nonzero(self):
+    def nonzero(self, as_tuple=False):
         """
         For details, please refer to :func:`mindspore.ops.nonzero`.
         """
-        self._init_check()
-        return tensor_operator_registry.get('nonzero')(self)
+        return tensor_operator_registry.get('nonzero')(self, as_tuple)
 
     def svd(self, full_matrices=False, compute_uv=True):
         """
@@ -3508,42 +3653,36 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         r"""
         For details, please refer to :func:`mindspore.ops.hardshrink`.
         """
-        self._init_check()
-        return tensor_operator_registry.get('hardshrink')(lambd)(self)
+        return tensor_operator_registry.get('hardshrink')(self, lambd)
 
     def heaviside(self, values):
         r"""
         For details, please refer to :func:`mindspore.ops.heaviside`.
         """
-        self._init_check()
         return tensor_operator_registry.get('heaviside')(self, values)
 
     def hypot(self, other):
         r"""
         For details, please refer to :func:`mindspore.ops.hypot`.
         """
-        self._init_check()
         return tensor_operator_registry.get('hypot')(self, other)
 
     def soft_shrink(self, lambd=0.5):
         r"""
         For details, please refer to :func:`mindspore.ops.soft_shrink`.
         """
-        self._init_check()
         return tensor_operator_registry.get('soft_shrink')(self, lambd)
 
     def matrix_determinant(self):
         r"""
         For details, please refer to :func:`mindspore.ops.matrix_determinant`.
         """
-        self._init_check()
         return tensor_operator_registry.get('matrix_determinant')(self)
 
     def log_matrix_determinant(self):
         r"""
         For details, please refer to :func:`mindspore.ops.log_matrix_determinant`.
         """
-        self._init_check()
         return tensor_operator_registry.get('log_matrix_determinant')(self)
 
     def to_coo(self):
@@ -3577,7 +3716,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
              [1 0]] [ 1. -5.] (2, 2)
 
         """
-        self._init_check()
         return tensor_operator_registry.get('dense_to_sparse_coo')(self)
 
     def to_csr(self):
@@ -3610,7 +3748,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(output.indptr, output.indices, output.values, output.shape)
             [0 1 2] [0 0] [ 1. -5.] (2, 2)
         """
-        self._init_check()
         return tensor_operator_registry.get('dense_to_sparse_csr')(self)
 
     def tolist(self):
@@ -3633,42 +3770,36 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> 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`.
         """
-        self._init_check()
-        return tensor_operator_registry.get('unbind')(dim)(self)
+        return tensor_operator_registry.get('unbind')(self, dim)
 
     def unsorted_segment_min(self, segment_ids, num_segments):
         r"""
         For details, please refer to :func:`mindspore.ops.unsorted_segment_min`.
         """
-        self._init_check()
         return tensor_operator_registry.get('unsorted_segment_min')(self, segment_ids, num_segments)
 
     def unsorted_segment_max(self, segment_ids, num_segments):
         r"""
         For details, please refer to :func:`mindspore.ops.unsorted_segment_max`.
         """
-        self._init_check()
         return tensor_operator_registry.get('unsorted_segment_max')(self, segment_ids, num_segments)
 
     def unsorted_segment_prod(self, segment_ids, num_segments):
         r"""
         For details, please refer to :func:`mindspore.ops.unsorted_segment_prod`.
         """
-        self._init_check()
         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):
         """
         For details, please refer to :func:`mindspore.ops.unique_consecutive`.
         """
-        self._init_check()
         output, idx, counts = tensor_operator_registry.get("unique_consecutive")(return_idx, return_counts, axis)(self)
         if return_idx and return_counts:
             return output, idx, counts
@@ -3682,30 +3813,27 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         For details, please refer to :func:`mindspore.ops.unique_with_pad`.
         """
-        self._init_check()
-        return tensor_operator_registry.get("unique_with_pad")()(self, pad_num)
+        return tensor_operator_registry.get("unique_with_pad")(self, pad_num)
 
     def diag(self):
         r"""
         For details, please refer to :func:`mindspore.ops.diag`.
         """
-        self._init_check()
-        return tensor_operator_registry.get('diag')()(self)
+        return tensor_operator_registry.get('diag')(self)
 
     def diagflat(self, offset=0):
         r"""
         For details, please refer to :func:`mindspore.ops.diagflat`.
         """
-        self._init_check()
         return tensor_operator_registry.get('diagflat')(self, offset)
 
     def xdivy(self, y):
         r"""
         For details, please refer to :func:`mindspore.ops.xdivy`.
         """
-        self._init_check()
-        return tensor_operator_registry.get("xdivy")()(self, y)
+        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`.
@@ -3716,7 +3844,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         For details, please refer to :func:`mindspore.ops.tensor_split`.
         """
-        self._init_check()
         return tensor_operator_registry.get('tensor_split')(self, indices_or_sections, axis)
 
     def vsplit(self, indices_or_sections):
@@ -3724,28 +3851,25 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         For details, please refer to :func:`mindspore.ops.vsplit`.
         """
 
-        self._init_check()
         return tensor_operator_registry.get('vsplit')(self, indices_or_sections)
 
     def hsplit(self, indices_or_sections):
         """
         For details, please refer to :func:`mindspore.ops.hsplit`.
         """
-        self._init_check()
         return tensor_operator_registry.get('hsplit')(self, indices_or_sections)
 
     def dsplit(self, indices_or_sections):
         """
         For details, please refer to :func:`mindspore.ops.dsplit`.
         """
-        self._init_check()
         return tensor_operator_registry.get('dsplit')(self, indices_or_sections)
 
     def xlogy(self, y):
         r"""
         For details, please refer to :func:`mindspore.ops.xlogy`.
         """
-        return tensor_operator_registry.get("xlogy")()(self, y)
+        return tensor_operator_registry.get("xlogy")(self, y)
 
     def eigvals(self):
         r"""
@@ -3760,13 +3884,13 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         r"""
         For details, please refer to :func:`mindspore.ops.erf`.
         """
-        return tensor_operator_registry.get("erf")()(self)
+        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)
+        return tensor_operator_registry.get("erfc")(self)
 
     def tile(self, reps):
         r"""
@@ -3778,29 +3902,26 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         r"""
         For details, please refer to :func:`mindspore.ops.topk`.
         """
-        self._init_check()
         return tensor_operator_registry.get("topk")(self, k, dim, largest, sorted)
 
     def top_k(self, k, sorted=True):
         r"""
         `Tensor.top_k` is deprecated, please use `Tensor.topk` instead.
         """
-        self._init_check()
         validator.check_is_int(k, 'k')
         validator.check_bool(sorted, 'sorted')
-        return tensor_operator_registry.get("top_k")(sorted)(self, k)
+        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)
+        return tensor_operator_registry.get("sigmoid")(self)
 
     def median(self, axis=-1, keepdims=False):
         r"""
         For details, please refer to :func:`mindspore.ops.median`.
         """
-        self._init_check()
         validator.check_axis_in_range(axis, self.ndim)
         return tensor_operator_registry.get('median')(False, axis, keepdims)(self)
 
@@ -3808,49 +3929,42 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         r"""
         For details, please refer to :func:`mindspore.ops.addmv`.
         """
-        self._init_check()
         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`.
         """
-        self._init_check()
         return tensor_operator_registry.get('asinh')(self)
 
     def arcsinh(self):
         r"""
         Alias for :func:`mindspore.Tensor.asinh`.
         """
-        self._init_check()
         return tensor_operator_registry.get('arcsinh')(self)
 
     def atan(self):
         r"""
         For details, please refer to :func:`mindspore.ops.atan`.
         """
-        self._init_check()
         return tensor_operator_registry.get('atan')(self)
 
     def atanh(self):
         r"""
         For details, please refer to :func:`mindspore.ops.atanh`.
         """
-        self._init_check()
         return tensor_operator_registry.get('atanh')(self)
 
     def arctanh(self):
         r"""
         Alias for :func:`mindspore.Tensor.atanh`.
         """
-        self._init_check()
         return tensor_operator_registry.get('arctanh')(self)
 
     def bmm(self, mat2):
         r"""
         For details, please refer to :func:`mindspore.ops.bmm`.
         """
-        self._init_check()
         return tensor_operator_registry.get('bmm')(self, mat2)
 
     def to(self, dtype):
@@ -3880,8 +3994,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(output.dtype)
             Int32
         """
-        self._init_check()
-        return tensor_operator_registry.get('to')()(self, dtype)
+        return tensor_operator_registry.get('to')(self, dtype)
 
     def type(self, dtype=None):
         r"""
@@ -3907,7 +4020,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             [[1 2]
              [3 4]]
         """
-        self._init_check()
         if dtype is None:
             return str(self.dtype)
         return self.astype(dtype)
@@ -3934,7 +4046,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(x.dtype)
             Int32
         """
-        self._init_check()
         return self.astype(other.dtype)
 
     def bool(self):
@@ -3957,8 +4068,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(output.dtype)
             Bool
         """
-        self._init_check()
-        return tensor_operator_registry.get('bool')()(self, mstype.bool_)
+        return tensor_operator_registry.get('bool')(self, mstype.bool_)
 
     def float(self):
         r"""
@@ -3979,8 +4089,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(output.dtype)
             Float32
         """
-        self._init_check()
-        return tensor_operator_registry.get('float')()(self, mstype.float32)
+        return tensor_operator_registry.get('float')(self, mstype.float32)
 
     def half(self):
         r"""
@@ -4001,8 +4110,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(output.dtype)
             Float16
         """
-        self._init_check()
-        return tensor_operator_registry.get('half')()(self, mstype.float16)
+        return tensor_operator_registry.get('half')(self, mstype.float16)
 
     def int(self):
         r"""
@@ -4023,8 +4131,28 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(output.dtype)
             Int32
         """
-        self._init_check()
-        return tensor_operator_registry.get('int')()(self, mstype.int32)
+        return tensor_operator_registry.get('int')(self, mstype.int32)
+
+    def byte(self):
+        r"""
+        Converts input tensor dtype to `uint8`.
+
+        Returns:
+            Tensor, converted to the `uint8` 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.float32)
+            >>> output = input_x.byte()
+            >>> print(output.dtype)
+            uint8
+        """
+        return tensor_operator_registry.get('byte')(self, mstype.uint8)
 
     def long(self):
         r"""
@@ -4045,8 +4173,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(output.dtype)
             Int64
         """
-        self._init_check()
-        return tensor_operator_registry.get('long')()(self, mstype.int64)
+        return tensor_operator_registry.get('long')(self, mstype.int64)
 
     def short(self):
         r"""
@@ -4068,22 +4195,19 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> output
             Tensor(shape=[5], dtype=Int16, value= [1, 2, 3, 4, 5])
         """
-        self._init_check()
         return tensor_operator_registry.get('cast')(self, mstype.int16)
 
     def cholesky(self, upper=False):
         r"""
         For details, please refer to :func:`mindspore.ops.cholesky`.
         """
-        self._init_check()
-        return tensor_operator_registry.get('cholesky')(upper=upper)(self)
+        return tensor_operator_registry.get('cholesky')(self, upper=upper)
 
     def cholesky_inverse(self, upper=False):
         r"""
         For details, please refer to :func:`mindspore.ops.cholesky_inverse`.
         """
-        self._init_check()
-        return tensor_operator_registry.get('cholesky_inverse')(upper=upper)(self)
+        return tensor_operator_registry.get('cholesky_inverse')(self, upper=upper)
 
     def cholesky_solve(self, input2, upper=False):
         r"""
@@ -4092,63 +4216,54 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         .. 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`.
         """
-        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`.
         """
-        self._init_check()
         return tensor_operator_registry.get('cross')(self, other, dim)
 
     def erfinv(self):
         r"""
         For details, please refer to :func:`mindspore.ops.erfinv`.
         """
-        self._init_check()
         return tensor_operator_registry.get('erfinv')(self)
 
     def less_equal(self, other):
         r"""
         For details, please refer to :func:`mindspore.ops.less_equal`.
         """
-        self._init_check()
         return tensor_operator_registry.get('less_equal')(self, other)
 
     def lcm(self, other):
         r"""
         For details, please refer to :func:`mindspore.ops.lcm`.
         """
-        self._init_check()
         return tensor_operator_registry.get('lcm')(self, other)
 
     def ldexp(self, other):
         r"""
         For details, please refer to :func:`mindspore.ops.ldexp`.
         """
-        self._init_check()
         return tensor_operator_registry.get('ldexp')(self, other)
 
     def fold(self, output_size, kernel_size, dilation=1, padding=0, stride=1):
         r"""
         For details, please refer to :func:`mindspore.ops.fold`.
         """
-        self._init_check()
         return tensor_operator_registry.get('fold')(self, output_size, kernel_size, dilation, padding, stride)
 
     def unfold(self, kernel_size, dilation=1, padding=0, stride=1):
@@ -4159,70 +4274,62 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             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.broadcast_to`.
         """
-        self._init_check()
+        if isinstance(size, Tensor):
+            size = tensor_operator_registry.get('tensortotuple')()(size)
         return tensor_operator_registry.get('expand')(self, size)
 
     def cumprod(self, dim, dtype=None):
         r"""
         For details, please refer to :func:`mindspore.ops.cumprod`.
         """
-        self._init_check()
         return tensor_operator_registry.get('cumprod')(self, dim, dtype)
 
     def multiply(self, value):
         r"""
         For details, please refer to :func:`mindspore.ops.multiply`.
         """
-        self._init_check()
         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`.
         """
-        self._init_check()
         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`.
         """
-        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`.
         """
-        self._init_check()
         return tensor_operator_registry.get('equal')(self, other)
 
     def expm1(self):
         r"""
         For details, please refer to :func:`mindspore.ops.expm1`.
         """
-        self._init_check()
         return tensor_operator_registry.get('expm1')(self)
 
     def index_add(self, dim, index, source, *, alpha=1):
         r"""
         For details, please refer to :func:`mindspore.ops.index_add`.
         """
-        self._init_check()
         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)
@@ -4231,42 +4338,37 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         r"""
         For details, please refer to :func:`mindspore.ops.greater`.
         """
-        self._init_check()
         return tensor_operator_registry.get('greater')(self, other)
 
     def greater_equal(self, other):
         r"""
         For details, please refer to :func:`mindspore.ops.greater_equal`.
         """
-        self._init_check()
         return tensor_operator_registry.get('greater_equal')(self, other)
 
     def igamma(self, other):
         r"""
         For details, please refer to :func:`mindspore.ops.igamma`.
         """
-        self._init_check()
         return tensor_operator_registry.get('igamma')(self, other)
 
     def igammac(self, other):
         r"""
         For details, please refer to :func:`mindspore.ops.igammac`.
         """
-        self._init_check()
         return tensor_operator_registry.get('igammac')(self, other)
 
     def isinf(self):
         r"""
         For details, please refer to :func:`mindspore.ops.isinf`.
         """
-        self._init_check()
         return tensor_operator_registry.get('isinf')(self)
 
+    @isnan_mint
     def isnan(self):
         r"""
         For details, please refer to :func:`mindspore.ops.isnan`.
         """
-        self._init_check()
         return tensor_operator_registry.get('isnan')(self)
 
     def flip(self, dims):
@@ -4320,14 +4422,12 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         r"""
         For details, please refer to :func:`mindspore.ops.le`.
         """
-        self._init_check()
         return tensor_operator_registry.get('le')(self, other)
 
     def less(self, other):
         r"""
         For details, please refer to :func:`mindspore.ops.less`.
         """
-        self._init_check()
         return tensor_operator_registry.get('less')(self, other)
 
     def lt(self, other):
@@ -4340,35 +4440,30 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         r"""
         For details, please refer to :func:`mindspore.ops.logical_and`.
         """
-        self._init_check()
         return tensor_operator_registry.get('logical_and')(self, other)
 
     def logical_not(self):
         r"""
         For details, please refer to :func:`mindspore.ops.logical_not`.
         """
-        self._init_check()
         return tensor_operator_registry.get('logical_not')(self)
 
     def logical_or(self, other):
         r"""
         For details, please refer to :func:`mindspore.ops.logical_or`.
         """
-        self._init_check()
         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`.
         """
-        self._init_check()
         return tensor_operator_registry.get('logical_xor')(self, other)
 
     def lstsq(self, A):
         r"""
         For details, please refer to :func:`mindspore.ops.lstsq`.
         """
-        self._init_check()
         return tensor_operator_registry.get('lstsq')(self, A)
 
     @property
@@ -4392,28 +4487,24 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         r"""
         For details, please refer to :func:`mindspore.ops.mvlgamma`.
         """
-        self._init_check()
         return tensor_operator_registry.get('mvlgamma')(self, p)
 
     def matmul(self, tensor2):
         r"""
         For details, please refer to :func:`mindspore.ops.matmul`.
         """
-        self._init_check()
         return tensor_operator_registry.get('matmul')(self, tensor2)
 
     def inner(self, other):
         r"""
         For details, please refer to :func:`mindspore.ops.inner`.
         """
-        self._init_check()
         return tensor_operator_registry.get('inner')(self, other)
 
     def multinomial(self, num_samples, replacement=True, seed=None):
         r"""
         For details, please refer to :func:`mindspore.ops.multinomial`.
         """
-        self._init_check()
         return tensor_operator_registry.get('multinomial')(self, num_samples, replacement, seed)
 
     def matrix_power(self, n):
@@ -4424,38 +4515,33 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             This is an experimental API that is subject to change or deletion.
 
         """
-        self._init_check()
         return tensor_operator_registry.get('matrix_power')(self, n)
 
     def maximum(self, other):
         r"""
         For details, please refer to :func:`mindspore.ops.maximum`.
         """
-        self._init_check()
         return tensor_operator_registry.get('maximum')(self, other)
 
     def mm(self, mat2):
         r"""
         For details, please refer to :func:`mindspore.ops.mm`.
         """
-        self._init_check()
         return tensor_operator_registry.get('mm')(self, mat2)
 
     def msort(self):
         r"""
         For details, please refer to :func:`mindspore.ops.msort`.
         """
-        self._init_check()
         return tensor_operator_registry.get('msort')(self)
 
     def mul(self, value):
         r"""
         For details, please refer to :func:`mindspore.ops.mul`.
         """
-        self._init_check()
         return tensor_operator_registry.get('mul')(self, value)
 
-    def nan_to_num(self, nan=0.0, posinf=None, neginf=None):
+    def nan_to_num(self, nan=None, posinf=None, neginf=None):
         """
         For details, please refer to :func:`mindspore.ops.nan_to_num`.
         """
@@ -4465,31 +4551,29 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         r"""
         For details, please refer to :func:`mindspore.ops.neg`.
         """
-        self._init_check()
         return tensor_operator_registry.get('neg')(self)
 
     def ne(self, other):
         r"""
         For details, please refer to :func:`mindspore.ops.ne`.
         """
-        self._init_check()
         return tensor_operator_registry.get('ne')(self, other)
 
     def not_equal(self, other):
         r"""
         For details, please refer to :func:`mindspore.ops.not_equal`.
         """
-        self._init_check()
         return tensor_operator_registry.get('not_equal')(self, other)
 
-    def new_zeros(self, size, *, dtype=None):
+    def new_zeros(self, size, dtype=None):
         r"""
         Return a tensor of `size` filled with zeros.
 
-        Args:
-            size (Union[int, tuple, list]): An int, list or tuple of integers defining the output shape.
+        .. warning::
+            For argument `size`, Tensor type input will be deprecated in the future version.
 
-        Keyword Args:
+        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``.
 
@@ -4497,7 +4581,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             Tensor, the shape and dtype is defined above and filled with zeros.
 
         Raises:
-            TypeError: If `size` is not an int, list or tuple of integers.
+            TypeError: If `size` is neither an int nor an tuple/list/Tensor of int.
 
         Supported Platforms:
             ``Ascend`` ``GPU`` ``CPU``
@@ -4512,21 +4596,42 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             [[0. 0.]
              [0. 0.]]
         """
-        validator.check_value_type('size', size, [list, int, tuple], 'Tensor.new_zeros')
-        if isinstance(size, list):
-            size = tuple(size)
-        self._init_check()
-        _dtype = self.dtype if dtype is None else dtype
-        return tensor_operator_registry.get('zeros')(size, _dtype)
+        return tensor_operator_registry.get('zeros')(size, dtype)
 
-    def new_ones(self, size, *, dtype=None):
+    def zero_(self):
+        r"""
+        Return a tensor filled with zeros.
+
+        .. warning::
+            This is an experimental API that is subject to change or deletion.
+
+        Returns:
+            Return a tensor. Fill self tensor with zeros.
+
+        Supported Platforms:
+            ``Ascend``
+
+        Examples:
+            >>> import numpy as np
+            >>> import mindspore
+            >>> from mindspore import Tensor
+            >>> x = Tensor(np.array([2, 2]))
+            >>> output = x.zero_()
+            >>> print(output)
+            [[0. 0.]
+             [0. 0.]]
+        """
+        return tensor_operator_registry.get('zero_')(self)
+
+    def new_ones(self, size, dtype=None):
         r"""
         Return a tensor of `size` filled with ones.
 
-        Args:
-            size (Union[int, tuple, list]): An int, list or tuple of integers defining the output shape.
+        .. warning::
+            For argument `size`, Tensor type input will be deprecated in the future version.
 
-        Keyword Args:
+        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``.
 
@@ -4534,7 +4639,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             Tensor, the shape and dtype is defined above and filled with ones.
 
         Raises:
-            TypeError: If `size` is not an int, list or tuple of integers.
+            TypeError: If `size` is neither an int nor an tuple/list/Tensor of int.
 
         Supported Platforms:
             ``Ascend`` ``GPU`` ``CPU``
@@ -4549,109 +4654,90 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             [[1. 1.]
              [1. 1.]]
         """
-        validator.check_value_type('size', size, [list, int, tuple], 'Tensor.new_zeros')
-        if isinstance(size, list):
-            size = tuple(size)
-        self._init_check()
-        _dtype = self.dtype if dtype is None else dtype
-        return tensor_operator_registry.get('ones')(size, _dtype)
+        return tensor_operator_registry.get('ones')(size, dtype)
 
     def sign(self):
         r"""
         For details, please refer to :func:`mindspore.ops.sign`.
         """
-        self._init_check()
         return tensor_operator_registry.get('sign')(self)
 
     def signbit(self):
         """
         For details, please refer to :func:`mindspore.ops.signbit`.
         """
-        self._init_check()
         return tensor_operator_registry.get('signbit')(self)
 
     def sgn(self):
         """
         For details, please refer to :func:`mindspore.ops.sgn`.
         """
-        self._init_check()
         return tensor_operator_registry.get('sgn')(self)
 
     def sin(self):
         r"""
         For details, please refer to :func:`mindspore.ops.sin`.
         """
-        self._init_check()
         return tensor_operator_registry.get('sin')(self)
 
     def sinc(self):
         r"""
         For details, please refer to :func:`mindspore.ops.sinc`.
         """
-        self._init_check()
         return tensor_operator_registry.get('sinc')(self)
 
     def sinh(self):
         r"""
         For details, please refer to :func:`mindspore.ops.sinh`.
         """
-        self._init_check()
         return tensor_operator_registry.get('sinh')(self)
 
     def sort(self, axis=-1, descending=False):
         r"""
         For details, please refer to :func:`mindspore.ops.sort`.
         """
-        self._init_check()
         return tensor_operator_registry.get('sort')(self, axis=axis, descending=descending)
 
     def argsort(self, axis=-1, descending=False):
         """
         For details, please refer to :func:`mindspore.ops.argsort`.
         """
-        self._init_check()
         return tensor_operator_registry.get('argsort')(self, axis, descending)
 
     def trunc(self):
         r"""
         For details, please refer to :func:`mindspore.ops.trunc`.
         """
-        self._init_check()
         return tensor_operator_registry.get('trunc')(self)
 
     def where(self, condition, y):
         r"""
         For details, please refer to :func:`mindspore.ops.where`.
         """
-        self._init_check()
         return tensor_operator_registry.get('where')(condition, self, y)
 
     def imag(self):
         r"""
         For details, please refer to :func:`mindspore.ops.imag`.
         """
-        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):
@@ -4661,7 +4747,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         .. 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)
 
 
@@ -4669,14 +4754,12 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         r"""
         For details, please refer to :func:`mindspore.ops.nextafter`.
         """
-        self._init_check()
         return tensor_operator_registry.get('nextafter')(self, other)
 
     def qr(self, some=True):
         r"""
         For details, please refer to :func:`mindspore.ops.qr`.
         """
-        self._init_check()
         validator.check_value_type('some', some, bool, 'Tensor.qr')
         return tensor_operator_registry.get('qr')(self, 'reduced' if some else 'complete')
 
@@ -4686,7 +4769,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         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)
 
 
@@ -4728,7 +4810,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(output)
             [5. 6. 3. 7.]
         """
-        self._init_check()
         return tensor_operator_registry.get('masked_scatter')()(self, mask, x)
 
 
@@ -4780,12 +4861,47 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             [[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 move_to(self, to, blocking=True):
+        r"""
+        Copy Tensor to target device synchronously or asynchronously, default synchronously. only support PyNative mode.
+
+        Args:
+            to (str): a string type value, one of ``"Ascend"``, ``"GPU"``, ``"CPU"``.
+            blocking (bool): a bool type value, using synchronous copy or asynchronous copy.
+                Default: ``True`` , synchronous copy.
+
+        Returns:
+            New Tensor, storged on target device which with the same type and shape as the "self Tensor".
+
+        Raises:
+            ValueError: If the type of `blocking` is not bool type.
+            ValueError: If the value of `to` is not one of ``"Ascend"``, ``"GPU"``, ``"CPU"``.
+            ValueError: If the run mode is not PyNative mode.
+
+        Supported Platforms:
+            ``Ascend`` ``GPU`` ``CPU``
+
+        Examples:
+            >>> import mindspore as ms
+            >>> from mindspore import Tensor
+            >>> x = ms.Tensor([1, 2, 3], ms.int64)
+            >>> new_tensor = x.move_to("CPU")
+        """
+        if not isinstance(blocking, bool):
+            raise ValueError(f"The type of 'blocking' must be bool, but got {blocking}")
+        if to not in ("Ascend", "GPU", "CPU"):
+            raise ValueError(f"The value of 'to' must be one of ['Ascend', 'GPU', 'CPU'], but got {to}")
+        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(Tensor_.move_to(self, to, blocking), device="CPU" if to == "CPU" else None)
+
+
     def _offload(self):
         r"""
         Offload tensor parameter to host. Currently, only support for pynative mode.
@@ -4799,7 +4915,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> x = ms.Tensor([1, 2, 3], ms.int64)
             >>> x._offload()
         """
-        self._init_check()
         return Tensor_._offload(self)
 
 
@@ -4831,6 +4946,44 @@ def _vm_compare(*args):
     return Tensor(np.array(fn(y)))
 
 
+def _check_sequence_shape(input_data):
+    """Check the shape of tensor input with type of sequence."""
+    max_dims_reached = False
+    max_ndim = 64 # corresponding to NPY_MAXDIMS
+    out_shape = [0]*max_ndim
+
+    def check_shape_recursive(input_data, curr_ndim):
+        nonlocal max_dims_reached, max_ndim, out_shape
+        if curr_ndim > max_ndim:
+            return False
+        if not isinstance(input_data, (tuple, list)):
+            if max_dims_reached and curr_ndim != max_ndim:
+                max_ndim = curr_ndim
+                return False
+            max_dims_reached = True
+            max_ndim = curr_ndim
+            return True
+        if not max_dims_reached:
+            out_shape[curr_ndim] = len(input_data)
+        else:
+            if out_shape[curr_ndim] != len(input_data):
+                max_ndim = curr_ndim
+                return False
+        if not input_data:
+            # process empty list
+            if not check_shape_recursive(None, curr_ndim + 1):
+                return False
+        for data in input_data:
+            if not check_shape_recursive(data, curr_ndim + 1):
+                return False
+        return True
+
+    if not check_shape_recursive(input_data, 0):
+        raise ValueError(f"When initializing a tensor with a sequence, the sequence has an inhomogeneous shape "
+                         f"after {max_ndim} dimensions. The detected shape was {tuple(out_shape[:max_ndim])} "
+                         f"+ inhomogeneous part.")
+
+
 def _check_tensor_input(input_data=None, dtype=None, shape=None, init=None):
     """Check the tensor input."""
     if input_data is not None and shape is not None:
@@ -4841,11 +4994,12 @@ 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)) and np.array(input_data).ndim > 1 \
-                and np.array(input_data).size == 0:
+        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)):
+            _check_sequence_shape(input_data)
+            if np.array(input_data).ndim >= 1 and np.array(input_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.")
@@ -4882,4 +5036,4 @@ def _check_astype_and_convert(dtype):
     return dtype
 
 
-tensor_operator_registry.register('vm_compare', _vm_compare)
+setattr(tensor_operator_registry, 'vm_compare', _vm_compare)