mindspore 2.1.0__cp38-cp38-manylinux1_x86_64.whl → 2.2.11__cp38-cp38-manylinux1_x86_64.whl

mindspore/common/tensor.py

@@ -82,11 +82,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.1/design/dynamic_graph_and_static_graph.html#creating-and-using-tensor>`_ .
+    <https://www.mindspore.cn/docs/en/r2.2/note/static_graph_syntax_support.html#mindspore-user-defined-data-types>`_ .
 
     The difference between it and the Tensor class is that it adds
     `Annotation
-    <https://www.mindspore.cn/docs/en/r2.1/design/dynamic_graph_and_static_graph.html?#annotation-marking>`_
+    <https://www.mindspore.cn/docs/en/r2.2/design/dynamic_graph_and_static_graph.html?#annotation-type>`_
     which can prevent the generation of AnyType compared to the Tensor class.
 
     The arguments and return values are the same as the Tensor class. Also see: :class:`mindspore.Tensor`.
@@ -113,6 +113,10 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
     """
     Tensor is a data structure that stores an n-dimensional array.
 
+    Note:
+        If 'init' interface is used to initialize Tensor, the `Tensor.init_data` API needs to be called to load the
+        actual data to `Tensor`.
+
     Args:
         input_data (Union[Tensor, float, int, bool, tuple, list, numpy.ndarray]): The data to be stored. It can be
             another Tensor, Python number or NumPy ndarray. Default: ``None`` .
@@ -125,10 +129,8 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             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`` .
         init (Initializer): The information of init data.
-            'init' is used for delayed initialization in parallel mode. Usually, it is not recommended to use
-            'init' interface to initialize Tensor in the other conditions. If 'init' interface is used to initialize
-            Tensor, the `Tensor.init_data` API needs to be called to convert `Tensor` to the actual data.
-            Default: ``None`` .
+            'init' is used for delayed initialization in parallel mode, when using init, `dtype` and `shape` must be
+            set. Default: ``None`` .
         internal (bool): Whether it is created by the framework.
             ``'True'`` means that the tensor is created by framework.
             ``'False'`` means that the tensor is created by user.
@@ -273,7 +275,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             if np.array(input_data).dtype == np.float64:
                 return mstype.float32
         if isinstance(input_data, (int, list, tuple)):
-            if np.array(input_data).dtype == np.int32 or np.array(input_data).dtype == np.int64:
+            if np.array(input_data).dtype in (np.int32, np.int64):
                 return mstype.int64
         return dtype
 
@@ -358,10 +360,8 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         return self
 
     def __abs__(self):
-        data = abs(self.asnumpy())
-        if isinstance(data, np.number):
-            data = np.array(data)
-        return Tensor(data)
+        self._init_check()
+        return tensor_operator_registry.get('abs')(self)
 
     def __add__(self, other):
         return tensor_operator_registry.get('__add__')(self, other)
@@ -461,6 +461,11 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
     def __setitem__(self, index, value):
         out = tensor_operator_registry.get('__setitem__')(self, index, value)
+        if isinstance(out, tuple):
+            if self.parent_tensor_ is not None and self.index_of_parent_ is not None:
+                self.parent_tensor_.__setitem__(self.index_of_parent_, out[0])
+                return self
+            return self
         self.assign_value(out)
         if self.parent_tensor_ is not None and self.index_of_parent_ is not None:
             self.parent_tensor_.__setitem__(self.index_of_parent_, self)
@@ -483,8 +488,20 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
     def __str__(self):
         if self.dtype == mstype.type_none:
             return "Unknown Tensor type!"
+        if self.dtype == mstype.bfloat16:
+            return str(self.float().asnumpy())
         return str(self.asnumpy())
 
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        state["value"] = Tensor_.__getstate__(self)
+        return state
+
+    def __setstate__(self, state):
+        value = state.pop("value")
+        Tensor_.__setstate__(self, value)
+        self.__dict__.update(state)
+
     @property
     def shape(self):
         """
@@ -784,12 +801,13 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> x = mindspore.Tensor(np.array([[1, 2], [3, 4]]), dtype=mindspore.float32)
             >>> output = x.log_normal()
             >>> print(output)
-            [[1.2788825 2,3305743]
-            [14.944194 0,16303174]]
+            [[1.2788825 2.3305743]
+            [14.944194 0.16303174]]
         """
         self._init_check()
         return tensor_operator_registry.get('log_normal')(mean, std)(self)
 
+    @jit_forbidden_register
     def assign_value(self, value):
         """
         Assign another tensor value to this tensor.
@@ -901,6 +919,26 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         output = tensor_operator_registry.get('itemset')(self, *args)
         return output
 
+    def get_bytes(self):
+        r"""
+        Get raw data of tensor with type of bytes.
+
+        Supported Platforms:
+            ``CPU`` ``GPU`` ``Ascend``
+
+        Returns:
+            Bytes of tensor.
+
+        Examples:
+            >>> import mindspore as ms
+            >>> from mindspore import Tensor
+            >>> x = ms.Tensor([1, 2, 3], ms.int16)
+            >>> print(x.get_bytes())
+            b'\x01\x00\x02\x00\x03\x00'
+        """
+        self._init_check()
+        return Tensor_.get_bytes(self)
+
     def asnumpy(self):
         """
         Convert tensor to numpy array. Returns self tensor as a NumPy ndarray. This tensor and the returned ndarray
@@ -921,6 +959,8 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             [11.  2.]
         """
         self._init_check()
+        if self.dtype == mstype.bfloat16:
+            raise TypeError(f"For asnumpy, the type of tensor cannot be BFloat16, but got {self.dtype}.")
         return Tensor_.asnumpy(self)
 
     def numpy(self):
@@ -1016,6 +1056,46 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         return self
 
+    def contiguous(self):
+        """
+        Converts a Tensor into a continuous-memory Tensor that contains the same data as the original Tensor.
+
+        Returns:
+            A contiguous in memory tensor containing the same data as self tensor.
+
+        Examples:
+            >>> import mindspore as ms
+            >>> import numpy as np
+            >>> from mindspore import Tensor, ops
+            >>> x = Tensor([[1, 2, 3], [4, 5, 6]], dtype=ms.float32)
+            >>> y = ops.transpose(x, (1, 0))
+            >>> y.contiguous()
+            >>> y[:, 1] = 1
+            >>> print(x)
+            [[1. 2. 3.]
+             [4. 5. 6.]]
+        """
+        Tensor_.contiguous(self)
+        return self
+
+    def is_contiguous(self):
+        """
+        Determines whether the memory of tensor is contiguous.
+
+        Returns:
+            Bool, True if tensor memory is contiguous, False otherwise.
+
+        Examples:
+            >>> import mindspore as ms
+            >>> import numpy as np
+            >>> from mindspore import Tensor, ops
+            >>> x = Tensor([[1, 2, 3], [4, 5, 6]], dtype=ms.float32)
+            >>> y = ops.transpose(x, (1, 0))
+            >>> print(y.is_contiguous())
+            False
+        """
+        return Tensor_.is_contiguous(self)
+
     def flush_from_cache(self):
         """
         Flush cache data to host if tensor is cache enable.
@@ -1112,9 +1192,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         For details, please refer to :func:`mindspore.ops.all`.
         """
         self._init_check()
-        if axis is None:
-            axis = ()
-        return tensor_operator_registry.get('all')(keep_dims)(self, axis)
+        return tensor_operator_registry.get('all')(self, axis, keep_dims)
 
     def angle(self):
         r"""
@@ -1174,7 +1252,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             if len(shape) != 1:
                 raise ValueError(f"Only one tuple is needed, but got {shape}")
             shape = shape[0]
-        return tensor_operator_registry.get('reshape')()(self, shape)
+        return tensor_operator_registry.get('reshape')(self, shape)
 
     def view_as(self, other):
         r"""
@@ -1329,7 +1407,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         For details, please refer to :func:`mindspore.ops.exp`.
         """
         self._init_check()
-        return tensor_operator_registry.get('exp')()(self)
+        return tensor_operator_registry.get('exp')(self)
 
     def real(self):
         r"""
@@ -1440,7 +1518,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         For details, please refer to :func:`mindspore.ops.abs`.
         """
         self._init_check()
-        return tensor_operator_registry.get('abs')()(self)
+        return tensor_operator_registry.get('abs')(self)
 
     def absolute(self):
         """
@@ -1511,7 +1589,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         self._init_check()
         input_x = self.copy() if self.dtype == mstype.float32 else self.astype(mstype.float16)
         input_y = other.copy() if other.dtype == mstype.float32 else other.astype(mstype.float16)
-        return tensor_operator_registry.get('__lt__')(tensor_operator_registry.get('abs')()(
+        return tensor_operator_registry.get('__lt__')(tensor_operator_registry.get('abs')(
             tensor_operator_registry.get('__sub__')(input_x, input_y)
         ), tolerance)
 
@@ -1673,9 +1751,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         For details, please refer to :func:`mindspore.ops.mean`.
         """
         self._init_check()
-        if axis is None:
-            axis = ()
-        return tensor_operator_registry.get('mean')(keep_dims)(self, axis)
+        return tensor_operator_registry.get('mean')(self, axis, keep_dims)
 
     def amin(self, axis=None, keepdims=False, *, initial=None, where=None):
         """
@@ -1770,7 +1846,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         self._init_check()
         new_shape = validator.check_reshape_shp(shape)
-        return tensor_operator_registry.get('reshape')()(self, new_shape)
+        return tensor_operator_registry.get('reshape')(self, new_shape)
 
     def reshape_as(self, other):
         """
@@ -1798,7 +1874,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
              [ 0.5 -3.2]]
         """
         self._init_check()
-        return tensor_operator_registry.get('reshape')()(self, other.shape)
+        return tensor_operator_registry.get('reshape')(self, other.shape)
 
     def ravel(self):
         """
@@ -1824,7 +1900,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             (24,)
         """
         self._init_check()
-        reshape_op = tensor_operator_registry.get('reshape')()
+        reshape_op = tensor_operator_registry.get('reshape')
         return reshape_op(self, (-1,))
 
     def round(self):
@@ -1980,10 +2056,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         For details, please refer to :func:`mindspore.ops.squeeze`.
         """
         self._init_check()
-        if axis is None:
-            return tensor_operator_registry.get('squeeze')(self)
-        new_shape = validator.prepare_shape_for_squeeze(self.shape, axis)
-        return tensor_operator_registry.get('reshape')()(self, new_shape)
+        return tensor_operator_registry.get('squeeze')(self, axis)
 
     def slogdet(self):
         """
@@ -2055,39 +2128,16 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         For details, please refer to :func:`mindspore.ops.argmax`.
         """
-        if self.shape == ():
-            return Tensor(0)
-        a = self
-        if self.dtype == mstype.bool_:
-            a = self.astype(mstype.int32)
-        is_axis_none = False
-        if axis is None:
-            a = a.ravel()
-            axis = 0
-            is_axis_none = True
-        out = tensor_operator_registry.get('argmax')(axis, mstype.int64)(a)
-        if keepdims and not is_axis_none:
-            out = out.expand_dims(axis)
+        self._init_check()
+        out = tensor_operator_registry.get('argmax')(self, axis, keepdims)
         return out
 
     def argmin(self, axis=None, keepdims=False):
         """
         For details, please refer to :func:`mindspore.ops.argmin`.
         """
-        if self.shape == ():
-            return Tensor(0)
-        # P.Argmin only supports float
-        is_axis_none = False
-        a = self.astype(mstype.float32)
-        if axis is None:
-            a = a.ravel()
-            axis = 0
-        else:
-            axis = validator.check_axis_in_range(axis, a.ndim)
-        # P.Argmin is currently not supported
-        out = tensor_operator_registry.get('argmin')(axis)(a)
-        if keepdims and not is_axis_none:
-            out = out.expand_dims(axis)
+        self._init_check()
+        out = tensor_operator_registry.get('argmin')(self, axis, keepdims)
         return out
 
     def argmax_with_value(self, axis=0, keep_dims=False):
@@ -2097,9 +2147,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         Compute the max value of input Tensor on the specified axis, and return the max value and index.
 
         Note:
-            In auto_parallel and semi_auto_parallel mode, the first output index can not be used.
-
-        .. warning::
+            - In auto_parallel and semi_auto_parallel mode, the first output index can not be used.
             - If there are multiple maximum values, the index of the first maximum value is used.
             - The value range of `axis` is [-dims, dims - 1]. `dims` is the dimension length of this tensor.
 
@@ -2138,7 +2186,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             [0.7] [3]
         """
         if self.shape == ():
-            return (Tensor(0), self)
+            return (self, Tensor(0))
         self._init_check()
         return tensor_operator_registry.get('argmax_with_value')(self, axis, keep_dims)
 
@@ -2147,9 +2195,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         Returns the minimum value with corresponding index.
 
         Note:
-            In auto_parallel and semi_auto_parallel mode, the first output index can not be used.
-
-        .. warning::
+            - In auto_parallel and semi_auto_parallel mode, the first output index can not be used.
             - If there are multiple minimum values, the index of the first minimum value is used.
             - The value range of `axis` is [-dims, dims - 1]. `dims` is the dimension length of this tensor.
 
@@ -2188,7 +2234,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             [0.0] [0]
         """
         if self.shape == ():
-            return (Tensor(0), self)
+            return (self, Tensor(0))
         self._init_check()
         return tensor_operator_registry.get('argmin_with_value')(self, axis, keep_dims)
 
@@ -2501,15 +2547,13 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         `Tensor.fill` is deprecated, please use `ops.fill` instead.
         """
+        self._init_check()
         if value is None:
             if self.dtype not in (mstype.float16, mstype.float32, mstype.float64):
                 raise TypeError("For 'Tensor.fill', if the argument 'value' is None, the type of the original "
                                 "tensor must be float, but got {}.".format(self.dtype))
             value = Tensor(float('nan')).astype("float32")
             return tensor_operator_registry.get("tile")()(value, self.shape).astype(self.dtype)
-        if not isinstance(value, (int, float, bool)):
-            raise TypeError("For 'Tensor.fill', the type of the argument 'value' must be int, float or bool, "
-                            "but got {}.".format(type(value)))
         return tensor_operator_registry.get("fill")(self.dtype, self.shape, value)
 
     def fills(self, value):
@@ -2639,7 +2683,6 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
     def _init_check(self):
         if self.has_init:
             self.init_data()
-        return self
 
     def init_data(self, slice_index=None, shape=None, opt_shard_group=None):
         """
@@ -2655,7 +2698,10 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             shape (list[int]): Shape of the slice, it is used when initialize a slice of the parameter.
                 Default: ``None``.
             opt_shard_group(str): Optimizer shard group which is used in auto or semi auto parallel mode
-                to get one shard of a parameter's slice. Default: ``None``.
+                to get one shard of a parameter's slice. For more information about optimizer parallel, please refer to:
+                `Optimizer Parallel
+                <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/optimizer_parallel.html>`_.
+                Default: ``None``.
 
         Returns:
             Initialized Tensor.
@@ -2724,14 +2770,20 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
                     self.init.seed, _ = self.seed
 
         with seed_context(self.init):
-            self.init(data)
+            if slice_num_of_persistent_data == 1:
+                self.init(data)
         self.init = None
 
         # At embedding cache scenes. When size of tensor is out of range, we store data to persistent storage
         if slice_num_of_persistent_data > 1:
             self.assign_value(Tensor_.persistent_data_from_numpy(data, slice_num_of_persistent_data))
         else:
-            self.assign_value(Tensor_.from_numpy(data))
+            if self.dtype == mstype.bfloat16:
+                # The dtype of data is np.float32 when mstype is bfloat16,
+                # so we create tensor_ by init func instead of asnumpy
+                self.assign_value(Tensor_(data, self.dtype))
+            else:
+                self.assign_value(Tensor_.from_numpy(data))
         return self
 
     def resize(self, *new_shape):
@@ -2851,54 +2903,8 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         """
         For details, please refer to :func:`mindspore.ops.diagonal`.
         """
-        ndim = self.ndim
-        if ndim < 2:
-            raise ValueError("For 'Tensor.diagonal', the original tensor requires at least two dimensions, "
-                             "but got {}.".format(ndim))
-        dtype = self.dtype
-
-        axes = validator.check_axis_valid((axis1, axis2), ndim)
-        perm = ()
-        for i in range(ndim):
-            if i not in axes:
-                perm += (i,)
-        perm += axes
-        a = self.transpose(perm)
-
-        shape = a.shape
-        n, m = shape[-2:]
-
-        e = tensor_operator_registry.get('eye')(n, m, dtype)
-        if offset >= m or offset <= -n:
-            e = tensor_operator_registry.get('fill')(dtype, (n, m), 0)
-        elif offset != 0:
-            e = e.astype(mstype.float32)
-            if offset > 0:
-                e_left = tensor_operator_registry.get('fill')(mstype.float32, (n, offset), 0)
-                e_right = e[..., 0:m - offset:1]
-                e = tensor_operator_registry.get('concatenate')(1)((e_left, e_right)).astype(dtype)
-            elif offset < 0:
-                e_upper = tensor_operator_registry.get('fill')(mstype.float32, (-offset, m), 0)
-                e_lower = e[0:n + offset:1, ...]
-                e = tensor_operator_registry.get('concatenate')(0)((e_upper, e_lower)).astype(dtype)
-        e = tensor_operator_registry.get('broadcast_to')(shape)(e)
-
-        prod = tensor_operator_registry.get('__mul__')(a, e)
-        res = tensor_operator_registry.get('reduce_sum')(prod.astype(mstype.float32), -1)
-
-        begin = ()
-        for _ in range(ndim - 2):
-            begin += (0,)
-        last_dim_begin = max(0, -offset)
-        begin += (last_dim_begin,)
-        size = res.shape[:-1]
-        last_dim_end = min(
-            shape[-2], max(0, shape[-1] - offset)) - last_dim_begin
-        if last_dim_end <= 0:
-            return Tensor([])
-        size += (last_dim_end,)
-        res = tensor_operator_registry.get('tensor_slice')(res, begin, size)
-        return res.astype(dtype)
+        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"""
@@ -2959,7 +2965,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         Takes elements from a tensor along an axis.
 
         Args:
-            indices (Tensor): The indices with shape `(Nj...)` of the values to extract.
+            indices (Tensor): The indices with shape :math:`(Nj...)` of the values to extract.
             axis (int, optional): The axis over which to select values. By default,
                 the flattened input tensor is used. Default: ``None`` .
             mode (str, optional): Support ``'raise'``, ``'wrap'``, ``'clip'``.
@@ -3227,10 +3233,10 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             axis = ()
         else:
             axis = validator.check_and_canonicalize_axes(axis, self.ndim)
-        x_mean = tensor_operator_registry.get('mean')(True)(self, axis)
+        x_mean = tensor_operator_registry.get('mean')(self, axis, True)
         x_sub = tensor_operator_registry.get('__sub__')(self, x_mean)
         x_pow = tensor_operator_registry.get('__pow__')(x_sub, 2)
-        x_sum = tensor_operator_registry.get('sum')(bool(keepdims))(x_pow, axis)
+        x_sum = tensor_operator_registry.get('reducesum')(bool(keepdims))(x_pow, axis)
         nums = 1
         if axis == ():
             nums = self.size
@@ -3255,11 +3261,12 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             `extobj` are not supported.
 
         Args:
-            axis (Union[None, int, tuple(int)]): Axis or axes along which a sum is performed. Default: ``None`` .
+            axis (Union[None, int, tuple(int), list(int)]): Axis or axes along which a sum is performed.
+                Default: ``None`` .
                 If None, sum all the elements of the input tensor.
                 If the axis is negative, it counts from the last to the first axis.
-                If the axis is a tuple of ints, a sum is performed on all the axes specified in the tuple
-                instead of a single axis or all the axes as before.
+                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
@@ -3274,7 +3281,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             If the input tensor is a 0-d array, or if the axis is ``None`` , a scalar is returned.
 
         Raises:
-            TypeError: If input is not array_like, or `axis` is not int or tuple of ints,
+            TypeError: If input is not array_like, or `axis` is not int, tuple of ints or list of ints,
                 or `keepdims` is not integer, or `initial` is not scalar.
             ValueError: If any axis is out of range or duplicate axes exist.
 
@@ -3294,27 +3301,14 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
             >>> print(input_x.sum(axis=1))
             [10. 35.]
         """
-        input_x = self.astype(mstype.int32) if self.dtype == mstype.bool_ else self
-        dtype = input_x.dtype if dtype is None else dtype
-        if not isinstance(keepdims, int):
-            raise TypeError("For 'Tensor.sum', the type of the argument 'keepdims' must be int, but "
-                            "got {}.".format(type(keepdims)))
         if initial is not None and not isinstance(initial, (int, float, bool)):
-            raise TypeError("For 'Tensor.sum', when the argument 'initial' is not None, it must be int, "
-                            "float or bool, but got {}.".format(type(initial)))
-        if axis is None:
-            axis = ()
-        else:
-            axis = validator.check_and_canonicalize_axes(axis, self.ndim)
-
-        if not validator.check_type_support(input_x.dtype, 'GPU', (mstype.float64, mstype.float32, mstype.float16)):
-            input_x = input_x.astype(mstype.float32)
-        if 0 in self.shape:
-            input_x = tensor_operator_registry.get('make_tensor')([0], self.dtype)
-        res = tensor_operator_registry.get('sum')(bool(keepdims))(input_x, axis)
+            raise TypeError(f"For Tensor.sum, initial must be int, float or bool, but got {type(initial)}.")
+        res = tensor_operator_registry.get("sum")(self, axis, keepdims)
         if initial is not None:
             res += initial
-        return res.astype(dtype)
+        if dtype is not None:
+            res = res.astype(dtype)
+        return res
 
     def sum_to_size(self, *size):
         r"""
@@ -3621,6 +3615,29 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         self._init_check()
         return tensor_operator_registry.get('dense_to_sparse_csr')(self)
 
+    def tolist(self):
+        r"""
+        Convert a Tensor to List. If the input is Tensor scalar, a Python scalar will be returned.
+
+        Returns:
+            List or Python scalar.
+
+        Supported Platforms:
+            ``Ascend`` ``GPU`` ``CPU``
+
+        Examples:
+            >>> import mindspore as ms
+            >>> x = ms.Tensor([[1, 2, 3], [4, 5, 6]])
+            >>> out1 = x.tolist()
+            >>> print(out1)
+            [[1, 2, 3], [4, 5, 6]]
+            >>> out2 = x[0][0].tolist()
+            >>> print(out2)
+            1
+        """
+        self._init_check()
+        return self.asnumpy().tolist()
+
     def unbind(self, dim=0):
         r"""
         For details, please refer to :func:`mindspore.ops.unbind`.
@@ -3757,7 +3774,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         r"""
         For details, please refer to :func:`mindspore.ops.tile`.
         """
-        return tensor_operator_registry.get('tile')()(self, reps)
+        return tensor_operator_registry.get('tile')(self, reps)
 
     def topk(self, k, dim=None, largest=True, sorted=True):
         r"""
@@ -3868,6 +3885,60 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         self._init_check()
         return tensor_operator_registry.get('to')()(self, dtype)
 
+    def type(self, dtype=None):
+        r"""
+        Change the dtype of the Tensor to the `dtype` . Return the type if `dtype` is ``None`` .
+
+        Args:
+            dtype (mindspore.dtype, optional): The specified dtype of output tensor. Default: ``None``.
+
+        Returns:
+            Tensor or str. If `dtype` is ``None`` , return a str, which describes the dtype of Tensor.
+            If `dtype` is not ``None`` , then return a Tensor, and the dtype of returned Tensor is `dtype` .
+
+        Supported Platforms:
+            ``Ascend`` ``GPU`` ``CPU``
+
+        Examples:
+            >>> import mindspore
+            >>> from mindspore import Tensor
+            >>> x = Tensor([[1.2, 2], [3.4, 4]], dtype=mindspore.float32)
+            >>> print(x.type())
+            Float32
+            >>> print(x.type(dtype=mindspore.int32))
+            [[1 2]
+             [3 4]]
+        """
+        self._init_check()
+        if dtype is None:
+            return str(self.dtype)
+        return self.astype(dtype)
+
+    def type_as(self, other):
+        r"""
+        Change the dtype of the Tensor to the dtype of `other`.
+
+        Args:
+            other (Tensor): The return tensor has the same dtype as `other`.
+
+        Returns:
+            Tensor, has the same dtype as `other`.
+
+        Supported Platforms:
+            ``Ascend`` ``GPU`` ``CPU``
+
+        Examples:
+            >>> import mindspore
+            >>> from mindspore import Tensor
+            >>> x = Tensor([[1, 2], [3, 4]], dtype=mindspore.float32)
+            >>> y = Tensor([[1, 2], [3, 4]], dtype=mindspore.int32)
+            >>> x = x.type_as(y)
+            >>> print(x.dtype)
+            Int32
+        """
+        self._init_check()
+        return self.astype(other.dtype)
+
     def bool(self):
         r"""
         Converts input tensor dtype to `bool`.
@@ -4033,6 +4104,13 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         self._init_check()
         return tensor_operator_registry.get('conj')(self)
 
+    def count_nonzero(self, axis=(), keep_dims=False, dtype=mstype.int32):
+        r"""
+        For details, please refer to :func:`mindspore.ops.count_nonzero`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('count_nonzero')(self, axis, keep_dims, dtype)
+
     def cross(self, other, dim=None):
         r"""
         For details, please refer to :func:`mindspore.ops.cross`.
@@ -4088,7 +4166,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
     def expand(self, size):
         r"""
-        For details, please refer to :func:`mindspore.ops.expand`.
+        For details, please refer to :func:`mindspore.ops.broadcast_to`.
         """
         self._init_check()
         return tensor_operator_registry.get('expand')(self, size)
@@ -4121,6 +4199,13 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
         self._init_check()
         return tensor_operator_registry.get('div')(self, value, rounding_mode=rounding_mode)
 
+    def eq(self, other):
+        r"""
+        For details, please refer to :func:`mindspore.ops.eq`.
+        """
+        self._init_check()
+        return tensor_operator_registry.get('equal')(self, other)
+
     def equal(self, other):
         r"""
         For details, please refer to :func:`mindspore.ops.equal`.
@@ -4545,23 +4630,7 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
     def imag(self):
         r"""
-        Returns a new tensor containing imaginary value of the input tensor.
-        If input tensor is real, it will return zeros.
-
-        Returns:
-            Tensor, the shape is the same as the input tensor.
-
-        Supported Platforms:
-            ``GPU`` ``CPU``
-
-        Examples:
-            >>> import numpy as np
-            >>> import mindspore
-            >>> from mindspore import Tensor
-            >>> x = Tensor(np.asarray(np.complex(1.3 + 0.4j)), mindspore.complex64)
-            >>> output = x.imag()
-            >>> print(output)
-            0.4
+        For details, please refer to :func:`mindspore.ops.imag`.
         """
         self._init_check()
         return tensor_operator_registry.get('imag')(self)
@@ -4738,10 +4807,19 @@ class Tensor(Tensor_, metaclass=_TensorMeta):
 
 def _vm_compare(*args):
     """Implement `vm_compare` for tensor."""
-    obj_str = args[-1]
+    if args:
+        obj_str = args[-1]
+    else:
+        raise ValueError("_vm_compare does not receive any input.")
     if obj_str == "shape":
         fn = getattr(args[0].asnumpy(), obj_str)
         return fn
+    if obj_str == "__setitem__":
+        fn = getattr(args[0].asnumpy(), obj_str)
+        index = args[1].asnumpy() if isinstance(args[1], Tensor) else args[1]
+        value = args[2].asnumpy() if isinstance(args[2], Tensor) else args[2]
+        fn(index, value)
+        return args[0]
     if len(args) == 2:
         fn = getattr(args[0].asnumpy(), obj_str)
         return Tensor(fn())