mindspore 2.7.0rc1__cp310-cp310-win_amd64.whl → 2.7.1__cp310-cp310-win_amd64.whl

mindspore/common/_tensor_docs.py

@@ -28,7 +28,7 @@ def attach_docstr(method, docstr):
 
 attach_docstr("absolute", r"""absolute() -> Tensor
 
-Alias for :func:`Tensor.abs`.
+Alias for :func:`mindspore.Tensor.abs`.
 """)
 attach_docstr("abs", r"""abs() -> Tensor
 
@@ -72,7 +72,7 @@ Note:
     - When `self` and `other` have different shapes,
       they must be able to broadcast to a common shape.
     - `self` and `other` can not be bool type at the same time,
-      [True, Tensor(True, bool\_), Tensor(np.array([True]), bool\_)] are all considered bool type.
+      [True, Tensor(True), Tensor(np.array([True]))] are all considered bool type.
     - `self` and `other` comply with the implicit type conversion rules to make the data types
       consistent.
     - The dimension of `self` should be greater than or equal to 1.
@@ -80,7 +80,7 @@ Note:
 Args:
     other (Union[Tensor, number.Number, bool]): `other` is a number.Number or a bool or a tensor whose data type is
         `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-        `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+        `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
 
 Returns:
     Tensor with a shape that is the same as the broadcasted shape of `self` and `other`,
@@ -131,7 +131,7 @@ Note:
 Args:
     other (Union[Tensor, number.Number, bool]): `other` is a number.Number or a bool or a tensor whose data type is
         `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-        `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+        `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
     
 Keyword Args:
     alpha (number.Number): A scaling factor applied to `other`, default 1.
@@ -319,29 +319,7 @@ Examples:
 .. method:: Tensor.any(dim=None, keepdim=False) -> Tensor
     :noindex:
 
-Tests if any element in tensor evaluates to `True` along the given axes.
-
-Args:
-    dim (int, optional): The dimensions to reduce. If ``None`` , all dimensions are reduced. Default ``None`` .
-    keepdim (bool, optional): Whether the output tensor has dim retained or not. Default ``False`` .
-
-Returns:
-    Tensor
-
-Supported Platforms:
-    ``Ascend`` ``GPU`` ``CPU``
-
-Examples:
-    >>> import mindspore
-    >>> x = mindspore.tensor([[True, False], [True, True]])
-    >>>
-    >>> # case 1:  By default, mindspore.Tensor.any tests along all the axes.
-    >>> x.any()
-    Tensor(shape=[], dtype=Bool, value= True)
-    >>>
-    >>> # case 2: Reduces a dimension along dim 1, with keepdim False.
-    >>> x.any(dim=1)
-    Tensor(shape=[2], dtype=Bool, value= [ True,  True])
+For details, please refer to :func:`mindspore.mint.any`.
 """)
 attach_docstr("arccosh", r"""arccosh() -> Tensor
 
@@ -361,7 +339,7 @@ Alias for :func:`mindspore.Tensor.asin`.
 """)
 attach_docstr("arctan2", r"""arctan2(other) -> Tensor
 
-Alias for :func:`Tensor.atan2`.
+Alias for :func:`mindspore.Tensor.atan2`.
 """)
 attach_docstr("arctanh", r"""arctanh() -> Tensor
 
@@ -705,6 +683,9 @@ Examples:
     >>> print(output)
     [ 0  1  0  0 -2  3  2]
 """)
+attach_docstr("broadcast_to", r"""broadcast_to(*shape) -> Tensor
+
+For details, please refer to :func:`mindspore.ops.broadcast_to`.""")
 attach_docstr("ceil", r"""ceil() -> Tensor
 
 For details, please refer to :func:`mindspore.ops.ceil`.""")
@@ -790,9 +771,6 @@ attach_docstr("clone", r"""clone() -> Tensor
 
 Returns a copy of self.
 
-.. warning::
-    This is an experimental API that is subject to change or deletion.
-
 Note:
     This function is differentiable, and gradients will flow back directly from the calculation
     result of the function to the `self`.
@@ -818,12 +796,16 @@ attach_docstr("copy_", r"""copy_(src, non_blocking=False) -> Tensor
 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.
+    If Copying is performed between Ascend and Ascend, the `src` tensor must be broadcastable with the `self` tensor,
+    and they can be of different data types.
+    Copying is performed between CPU and Ascend or CPU and CPU are only supported if `self` and `src` have
+    the same shape and data type and they are all contiguous.
 
 Args:
     src (Tensor): the source tensor to copy from.
-    non_blocking (bool, optional): no effect currently. Default: ``False``.
+    non_blocking (bool, optional): If ``True`` and copying is performed between CPU and Ascend, and `self` and `src`
+        have the same shape and data type and are contiguous. The copy may occur asynchronously with respect to the
+        host. For other cases, this argument has no effect. Default: ``False``.
 
 Returns:
     Return self Tensor.
@@ -852,9 +834,6 @@ attach_docstr("count_nonzero", r"""count_nonzero(dim=None) -> Tensor
 
 Counts the number of non-zero values in the tensor input along the given dim. If no dim is specified then all non-zeros in the tensor are counted.
 
-.. warning::
-    This is an experimental API that is subject to change or deletion.
-
 Args:
     dim (Union[None, int, tuple(int), list(int)], optional): The dimension to reduce. Default value: ``None``, which indicates that the number of non-zero elements is calculated. If `dim` is ``None``, all elements in the tensor are summed up.
           
@@ -901,7 +880,7 @@ Args:
     keep_dims (bool, optional): Whether to maintain dimensions specified by `axis`.
         If true, keep these reduced dimensions and the length is 1.
         If false, don't keep these dimensions. Default: ``False`` .
-    dtype (Union[Number, mindspore.bool\_], optional): The data type of the output tensor.
+    dtype (Union[Number, mindspore.bool], optional): The data type of the output tensor.
         Default: ``None`` .
 
 Returns:
@@ -1357,9 +1336,6 @@ the scalar could only be a constant.
 where the :math:`floor` indicates the Floor operator. For more details,
 please refer to the :class:`mindspore.mint.floor` operator.
 
-.. warning::
-    This is an experimental API that is subject to change or deletion.
-
 Args:
     other (Union[Tensor, Number, bool]): The other input is a number or
         a bool or a tensor whose data type is number or bool.
@@ -1498,11 +1474,11 @@ The following figure shows the calculation process of Gather commonly:
 where params represents the input `input_params`, and indices represents the index to be sliced `input_indices`.
 
 .. note::
-    - The value of input_indices must be in the range of `[0, input_param.shape[axis])`.
+    - The value of input_indices must be in the range of :math:`[0, input\_param.shape[axis])`.
       On CPU and GPU, an error is raised if an out of bound indice is found. On Ascend, the results may be
       undefined.
     - The data type of self cannot be
-      `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ on Ascend
+      `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ on Ascend
       platform currently.
 
 Args:
@@ -1523,7 +1499,7 @@ Raises:
     ValueError: If `axis` is a Tensor and its size is not 1.
     TypeError:  If `self` is not a tensor.
     TypeError:  If `input_indices` is not a tensor of type int.
-    RuntimeError: If `input_indices` is out of range :math:`[0, input_param.shape[axis])` on CPU or GPU.
+    RuntimeError: If `input_indices` is out of range :math:`[0, input\_param.shape[axis])` on CPU or GPU.
 
 Supported Platforms:
     ``Ascend`` ``GPU`` ``CPU``
@@ -1582,7 +1558,7 @@ For details, please refer to :func:`mindspore.ops.greater_equal`.
 """)
 attach_docstr("gt", r"""gt(other) -> Tensor
 
-For details, please refer to :func:'mindspore.Tensor.greater'.""")
+For details, please refer to :func:`mindspore.Tensor.greater`.""")
 attach_docstr("hardshrink", r"""hardshrink(lambd=0.5) -> Tensor
 
 For details, please refer to :func:`mindspore.ops.hardshrink`.""")
@@ -1592,6 +1568,10 @@ For details, please refer to :func:`mindspore.ops.histc`.
 
 Supported Platforms:
     ``Ascend`` ``GPU`` ``CPU``""")
+attach_docstr("imag", r"""imag() -> Tensor
+
+For details, please refer to :func:`mindspore.ops.imag`.
+""")
 attach_docstr("index_add", r"""index_add(indices, y, axis, use_lock=True, check_index_bound=True) -> Tensor
 
 Adds tensor `y` to specified axis and indices of tensor `self`. The axis should be in [-len(self.dim),  len(self.dim) - 1], and indices should be in [0, the size of `self` - 1] at the axis dimension.
@@ -1636,6 +1616,87 @@ For details, please refer to :func:`mindspore.ops.index_add`.
 The corresponding relationships between the parameters of `Tensor.index_add` and :func:`mindspore.ops.index_add`
 are as follows: `dim` -> `axis`, `index` -> `indices`, `source * alpha` -> `y`.
 """)
+attach_docstr("index_copy_", r"""index_copy_(dim, index, tensor) -> Tensor
+
+Copies the elements of `tensor` into the `self` by selecting the indices in the order given in `index` .
+
+.. note::
+    The value of `index` must be in the range `[0, self.shape[dim])` , if it is out of range, the result is undefined.
+
+    If value of `index` contains duplicate entries, the result is nondeterministic since it depends on the last copy operation that occurred.
+
+Args:
+    dim (int): The dimension along which to `index` .
+    index (Tensor): A 1-D Tensor with the indices to access in `self` along the specified `dim` .
+    tensor (Tensor): The tensor containing values to copy.
+
+Returns:
+    Return `self` Tensor.
+
+Supported Platforms:
+    ``Ascend``
+
+Examples:
+    >>> import mindspore
+    >>> from mindspore import Tensor, mint
+    >>> x = mint.ones((5, 3), dtype=mindspore.int64)
+    >>> index = Tensor([4, 0, 2])
+    >>> tensor = Tensor([[1, 2, 3], [4, 5, 6], [7, 8, 9]], dtype=mindspore.int64)
+    >>> x.index_copy_(0, index, tensor)
+    Tensor(shape=[5, 3], dtype=Int64, value=
+    [[4 5 6]
+     [1 1 1]
+     [7 8 9]
+     [1 1 1]
+     [1 2 3]])
+""")
+attach_docstr("index_fill_", r"""index_fill_(dim, index, value) -> Tensor
+
+Fills the elements under the `dim` dimension of the `self` Tensor with the input `value`
+by selecting the indices in the order given in `index`.
+
+.. warning::
+    This is an experimental API that is subject to change or deletion.
+
+.. note::
+    While calculating the gradient of `value` , the value of `index` must be in the range `[0, self.shape[dim])` ,
+    if it is out of range, the result is undefined.
+
+Args:
+    dim (int): Dimension along which to fill the `self` Tensor.
+    index (Tensor): Indices of the `self` Tensor to fill in. The `index` must be a 0D or 1D Tensor with dtype int32
+        or int64.
+    value (Union[Tensor, Number, bool]): Value to fill the `self` Tensor. The `value` is a number or a bool or a
+        tensor whose data type is number or bool. If `value` is a Tensor, it must be a 0D Tensor.
+
+Returns:
+    Tensor, the shape and the data type are the same as those of `self` .
+
+Raises:
+    TypeError: If the data type of `index` is not int32 or int64.
+    RuntimeError: If `dim` is out of range :math:`[-self.ndim, self.ndim)`.
+    RuntimeError: If the rank of `index` is greater than 1.
+    RuntimeError: If `value` is a Tensor and its rank is not equal to 0.
+
+Supported Platforms:
+    ``Ascend``
+
+Examples:
+    >>> import mindspore
+    >>> from mindspore import Tensor
+    >>> import numpy as np
+    >>> x = Tensor(np.array([[1, 2, 3], [4, 5, 6]]), mindspore.int32)
+    >>> dim = 1
+    >>> index = Tensor(np.array([0, 2]), mindspore.int32)
+    >>> value = Tensor(0, mindspore.int32)
+    >>> output = x.index_fill_(dim, index, value)
+    >>> print(output)
+    [[ 0  2  0]
+     [ 0  5  0]]
+    >>> print(x)
+    [[ 0  2  0]
+     [ 0  5  0]]
+""")
 attach_docstr("index_select", r"""index_select(axis, index) -> Tensor
 
 Generates a new Tensor that accesses the values of `self` along the specified `axis` dimension
@@ -1923,13 +1984,13 @@ Examples:
     >>> import mindspore
     >>> import numpy as np
     >>> from mindspore import Tensor
-    >>> input = Tensor(np.array([True, False, True]), mindspore.bool_)
-    >>> other = Tensor(np.array([True, True, False]), mindspore.bool_)
+    >>> input = Tensor(np.array([True, False, True]), mindspore.bool)
+    >>> other = Tensor(np.array([True, True, False]), mindspore.bool)
     >>> output = input.logical_xor(other)
     >>> print(output)
     [ False True True]
-    >>> x = Tensor(1, mindspore.bool_)
-    >>> other = Tensor(0, mindspore.bool_)
+    >>> x = Tensor(1, mindspore.bool)
+    >>> other = Tensor(0, mindspore.bool)
     >>> output = input.logical_xor(other)
     >>> print(output)
     True
@@ -1963,6 +2024,81 @@ In-place version of :func:`mindspore.Tensor.masked_fill`.
 .. warning::
     This is an experimental API that is subject to change or deletion.
 """)
+attach_docstr("masked_scatter", r"""masked_scatter(mask, source) -> Tensor
+
+Returns a Tensor. Updates the value in the "self Tensor" with the `tensor` value according to the mask.
+The shape of `mask` and the shape of the "self Tensor" must be the same or `mask` is broadcastable.
+
+Args:
+    mask (Tensor[bool]): A bool tensor with a shape broadcastable to the "self Tensor".
+    source (Tensor): A tensor with the same data type as the "self Tensor". The number
+        of elements must be greater than or equal to the number of True's in `mask`.
+
+Returns:
+    Tensor, with the same type and shape as the "self Tensor".
+
+Raises:
+    TypeError: If `mask` or `source` is not a Tensor.
+    TypeError: If data type of the "self Tensor" is not be supported.
+    TypeError: If dtype of `mask` is not bool.
+    TypeError: If the dim of the "self Tensor" is less than the dim of `mask`.
+    ValueError: If `mask` can not be broadcastable to the "self Tensor".
+    ValueError: If the number of elements in `source` is less than the number of elements to be updated in the tensor.
+
+Supported Platforms:
+    ``Ascend`` ``CPU``
+
+Examples:
+    >>> import numpy as np
+    >>> import mindspore
+    >>> from mindspore import Tensor
+    >>> x = Tensor(np.array([1., 2., 3., 4.]), mindspore.float32)
+    >>> mask = Tensor(np.array([True, True, False, True]), mindspore.bool_)
+    >>> source = Tensor(np.array([5., 6., 7.]), mindspore.float32)
+    >>> output = x.masked_scatter(mask, source)
+    >>> print(output)
+    [5. 6. 3. 7.]""")
+attach_docstr("masked_scatter_", r"""masked_scatter_(mask, source) -> Tensor
+
+Updates the value in the `self` with the `source` value according to the `mask`, and returns a Tensor.
+The shape of `mask` and the `self` must be the same or `mask` is broadcastable.
+
+Note:
+    When the total number of elements in `source` is less than the number of True elements in `mask`,
+    the NPU may not be able to detect this invalid input; therefore,
+    the correctness of the output cannot be guaranteed.
+
+Args:
+    mask (Tensor[bool]): A bool tensor with a shape broadcastable to the `self`.
+    source (Tensor): A tensor with the same data type as the `self`. The number
+        of elements must be greater than or equal to the number of True elements in `mask`.
+
+Returns:
+    Tensor, with the same type and shape as the `self`.
+
+Raises:
+    TypeError: If `mask` or `source` is not a Tensor.
+    TypeError: If data type of the "self Tensor" is not be supported.
+    TypeError: If dtype of `mask` is not bool.
+    TypeError: If the dim of the "self Tensor" is less than the dim of `mask`.
+    ValueError: If `mask` can not be broadcastable to the "self Tensor".
+
+
+Supported Platforms:
+    ``Ascend``
+
+Examples:
+    >>> import numpy as np
+    >>> import mindspore
+    >>> from mindspore import Tensor
+    >>> x = Tensor(np.array([1., 2., 3., 4.]), mindspore.float32)
+    >>> mask = Tensor(np.array([True, True, False, True]), mindspore.bool_)
+    >>> tensor = Tensor(np.array([5., 6., 7.]), mindspore.float32)
+    >>> output = x.masked_scatter_(mask, tensor)
+    >>> print(output)
+    [5. 6. 3. 7.]
+    >>> print(x)
+    [5. 6. 3. 7.]""")
 attach_docstr("masked_select", r"""masked_select(mask) -> Tensor
 
 For details, please refer to :func:`mindspore.ops.masked_select`.""")
@@ -2489,7 +2625,7 @@ Note:
     - When `self` and `other` have different shapes,
       `other` be able to broadcast to a `self`.
     - `self` and `other` can not be bool type at the same time,
-      [True, Tensor(True, bool\_), Tensor(np.array([True]), bool\_)] are all considered bool type.
+      [True, Tensor(True), Tensor(np.array([True]))] are all considered bool type.
 
 Args:
     other (Union[Tensor, number.Number, bool]): `other` is a number.Number or
@@ -2659,9 +2795,6 @@ attach_docstr("new_empty", r"""new_empty(size, *, dtype=None, device=None) -> Te
 Returns an uninitialized Tensor. Its shape is specified by `size`, its dtype is specified by `dtype` and its
 device is specified by `device`.
 
-.. warning::
-    This is an experimental API that is subject to change or deletion.
-
 Args:
     size (Union[tuple[int], list[int], int]): The specified shape of output tensor. Only positive integer or
         tuple or list containing positive integers are allowed.
@@ -2669,7 +2802,7 @@ Args:
 Keyword Args:
     dtype (:class:`mindspore.dtype`, optional): The specified dtype of the output tensor. If `dtype = None`,
         the tensor will have the same dtype as `self`. Default ``None``.
-    device (string, optional): The specified device of the output tensor. In PyNative mode, ``"Ascend"``, ``"npu"``,
+    device (str, optional): The specified device of the output tensor. In PyNative mode, ``"Ascend"``, ``"npu"``,
         ``"cpu"`` and ``"CPU"`` are supported. In graph mode O0, ``"Ascend"`` and ``"npu"`` are supported. If `device = None`,
         the value set by :func:`mindspore.set_device` will be used. Default ``None``.
 
@@ -2795,6 +2928,15 @@ attach_docstr("outer", r"""outer(vec2) -> Tensor
 
 For details, please refer to :func:`mindspore.ops.outer`.
 """)
+attach_docstr("permute", r"""permute(*dims) -> Tensor
+
+For details, please refer to :func:`mindspore.mint.permute`.
+
+.. method:: Tensor.permute(*axis) -> Tensor
+    :noindex:
+
+For details, please refer to :func:`mindspore.ops.permute`.
+""")
 attach_docstr("pow", r"""pow(exponent) -> Tensor
 
 For details, please refer to :func:`mindspore.ops.pow`.
@@ -2915,6 +3057,10 @@ Examples:
     [[4. 9. 5.]
      [10. 7. 8.]]
 """)
+attach_docstr("real", r"""real() -> Tensor
+
+For details, please refer to :func:`mindspore.ops.real`.
+""")
 attach_docstr("reciprocal", r"""reciprocal() -> Tensor
 
 For details, please refer to :func:`mindspore.ops.reciprocal`.
@@ -2935,11 +3081,11 @@ Supports broadcasting to a common shape and implicit type promotion.
 
     The dividend `self` is a tensor whose data type is
     `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-    `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+    `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
 
 Args:
     other (Union[Tensor, numbers.Number, bool]): The divisor is a numbers.Number or
-        a bool or a tensor whose data type is number or bool\_ when the dividend is a tensor.
+        a bool or a tensor whose data type is number or bool when the dividend is a tensor.
 
 Returns:
     Tensor, with dtype promoted and shape broadcasted.
@@ -3007,6 +3153,49 @@ Examples:
     >>> print(output)
     [2.  1.  0.]
 """)
+attach_docstr("remainder_", r"""remainder_(other) -> Tensor
+
+Computes the remainder of `self` divided by `other` element-wise. The result has the same sign as the divisor `other`
+and its absolute value is less than that of `other`.
+
+.. code-block::
+
+    remainder(self, other) == self - self.div(other, rounding_mode="floor") * other
+
+.. warning::
+    This is an experimental API that is subject to change or deletion.
+
+Note:
+    - Complex inputs are not supported.
+    - The dividend `self` is a tensor whose data type is
+      `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+    - When `self` and `other` have different shapes, `other` should be able to broadcast to a `self`.
+
+Args:
+    other (Union[Tensor, number, bool]): The divisor is a number or
+        a bool or a tensor whose data type is number or bool.
+
+Returns:
+    Tensor, the shape and the data type are the same as those of `self` .
+
+Raises:
+    RuntimeError: If `other` cannot be broadcast to `self`.
+
+Supported Platforms:
+    ``Ascend``
+
+Examples:
+    >>> import mindspore
+    >>> from mindspore import Tensor
+    >>> import numpy as np
+    >>> x = Tensor(np.array([2, 4, -1]), mindspore.int32)
+    >>> other = Tensor(np.array([3, -6, -2]), mindspore.int32)
+    >>> output = x.remainder_(other)
+    >>> print(output)
+    [ 2 -2 -1]
+    >>> print(x)
+    [ 2 -2 -1]
+""")
 attach_docstr("repeat", r"""repeat(*repeats)
 
 Copy the elements in each dimension of a Tensor based on the specified number of repetition times.
@@ -3023,9 +3212,6 @@ elements in `repeats`.
     repeats_{i} & \text{if } input.{rank} \le i < n \\
     \end{cases}
 
-.. warning::
-    This is an experimental API that is subject to change or deletion.
-
 .. note::
     If need to specify the number of repetition times for each element of a single dimension, please
     refer to :func:`mindspore.Tensor.repeat_interleave`.
@@ -3842,6 +4028,12 @@ Examples:
 attach_docstr("sigmoid", r"""sigmoid() -> Tensor
 
 For details, please refer to :func:`mindspore.ops.sigmoid`.""")
+attach_docstr("sigmoid_", r"""sigmoid_() -> Tensor
+
+In-place version of :func:`mindspore.Tensor.sigmoid`.
+
+.. warning::
+    Only supports Ascend.""")
 attach_docstr("sinc", r"""sinc() -> Tensor
 
 For details, please refer to :func:`mindspore.ops.sinc`.
@@ -4022,6 +4214,9 @@ For details, please refer to :func:`mindspore.ops.sqrt`.
 attach_docstr("square", r"""square() -> Tensor
 
 For details, please refer to :func:`mindspore.ops.square`.""")
+attach_docstr("squeeze", r"""squeeze(*axis) -> Tensor
+
+For details, please refer to :func:`mindspore.ops.squeeze`.""")
 attach_docstr("std", r"""std(axis=None, ddof=0, keepdims=False) -> Tensor
 
 For details, please refer to :func:`mindspore.ops.std`.
@@ -4105,7 +4300,7 @@ Args:
     other (Union[Tensor, number.Number, bool]): The second self, is a number.Number or
         a bool or a tensor whose data type is
         `number <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_ or
-        `bool_ <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
+        `bool <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.dtype.html>`_.
 
 Keyword Args:
     alpha (number.Number, optional): A scaling factor applied to `other`, default ``1``.
@@ -4467,13 +4662,106 @@ Examples:
 
 For more details, please refer to :func:`mindspore.ops.topk`.
 """)
+attach_docstr("to", r"""to(dtype=None, non_blocking=False, copy=False) -> Tensor
+
+Returns a tensor with the new specified data type.
+
+Note:
+    - When converting complex numbers to boolean type, the imaginary part of the complex number is not
+      taken into account. As long as the real part is non-zero, it returns True; otherwise, it returns False.
+    - `non_blocking` and `copy` do not take effect in GRAPH_MODE or within jit.
+
+Args:
+    dtype (dtype.Number, optional): The valid data type of the output tensor. Default: ``None``.
+    non_blocking(bool, optional): Data type conversion asynchronously. If ``True`` , convert data type asynchronously. If ``False`` , convert data type synchronously. Default: ``False`` .
+    copy(bool, optional): When copy is set ``True`` , a new Tensor is created even when then Tensor already matches the desired conversion. Default: ``False`` .
+
+Returns:
+    Tensor, the data type of the tensor is `dtype` .
+
+Supported Platforms:
+    ``Ascend`` ``GPU`` ``CPU``
+
+Examples:
+    >>> import mindspore
+    >>> import numpy as np
+    >>> from mindspore import Tensor
+    >>> input_np = np.random.randn(2, 3, 4, 5).astype(np.float32)
+    >>> input = Tensor(input_np)
+    >>> dtype = mindspore.int32
+    >>> output = input.to(dtype)
+    >>> print(output.dtype)
+    Int32
+    >>> print(output.shape)
+    (2, 3, 4, 5)
+
+.. method:: Tensor.to(device=None, dtype=None, non_blocking=False, copy=False) -> Tensor
+    :noindex:
+
+Returns a tensor with the new specified data type and device type.
+
+Note:
+    `device` , `non_blocking` and `copy` do not take effect in GRAPH_MODE or within jit.
+
+Args:
+    device(str, optional): The device type of the output tensor. Default: ``None`` .
+    dtype (dtype.Number, optional): The valid data type of the output tensor. Default: ``None`` .
+    non_blocking(bool, optional): Data type conversion asynchronously. If ``True`` , convert data type asynchronously. If ``False`` , convert data type synchronously. Default: ``False`` .
+    copy(bool, optional): When copy is set ``True`` , a new Tensor is created even when then Tensor already matches the desired conversion. Default: ``False`` .
+
+Returns:
+    Tensor, the specified device type and data type of the tensor.
+
+Supported Platforms:
+    ``Ascend`` ``CPU``
+
+Examples:
+    >>> import mindspore
+    >>> import numpy as np
+    >>> from mindspore import Tensor
+    >>> input_np = np.random.randn(2, 3, 4, 5).astype(np.float32)
+    >>> input = Tensor(input_np)
+    >>> dtype = mindspore.int32
+    >>> output = input.to("Ascend")
+    >>> print(output.device)
+    "Ascend:0"
+
+.. method:: Tensor.to(other, non_blocking=False, copy=False) -> Tensor
+    :noindex:
+
+Returns a tensor with same device and dtype as the Tensor `other` .
+
+Note:
+    `non_blocking` and `copy` do not take effect in GRAPH_MODE or within jit.
+
+Args:
+    other(Tensor): The returned Tensor has the same device and dtype as `other` .
+    non_blocking(bool, optional): Data type conversion asynchronously. If ``True`` , convert data type asynchronously. If ``False`` , convert data type synchronously. Default: ``False`` .
+    copy(bool, optional): When copy is set ``True`` , a new Tensor is created even when then Tensor already matches the desired conversion. Default: ``False`` .
+
+Returns:
+    Tensor, same device and dtype as the Tensor `other` .
+
+Supported Platforms:
+    ``Ascend`` ``CPU``
+
+Examples:
+    >>> import mindspore
+    >>> import numpy as np
+    >>> from mindspore import Tensor
+    >>> input_np = np.random.randn(2, 3, 4, 5).astype(np.float32)
+    >>> input = Tensor(input_np)
+    >>> other = input.to("Ascend", dtype=mindspore.float16)
+    >>  output = input.to(other)
+    >>> print(output.device)
+    "Ascend:0"
+    >>> print(output.dtype)
+    float16
+""")
 attach_docstr("transpose", r"""transpose(dim0, dim1) -> Tensor
 
 Interchange two axes of a tensor.
 
-.. warning::
-    This is an experimental API that is subject to change or deletion.
-
 Args:
     dim0 (int): Specifies the first dimension to be transposed.
     dim1 (int): Specifies the second dimension to be transposed.
@@ -4743,6 +5031,26 @@ Examples:
     >>> print(output)
     [1. 2. 3. 2. 3. 4.]
 """)
+attach_docstr("view", r"""view(*shape) -> Tensor
+
+Reshape the tensor according to the input `shape` .
+
+Args:
+    shape (Union[tuple(int), int]): Dimension of the output tensor.
+
+Returns:
+    Tensor, which dimension is the input shape's value.
+
+Examples:
+    >>> from mindspore import Tensor
+    >>> import numpy as np
+    >>> a = Tensor(np.array([[1, 2, 3], [2, 3, 4]], dtype=np.float32))
+    >>> output = a.view((3, 2))
+    >>> print(output)
+    [[1. 2.]
+     [3. 2.]
+     [3. 4.]]
+""")
 attach_docstr("where", r"""where(condition, y) -> Tensor
 
 For details, please refer to :func:`mindspore.ops.where`.
@@ -4751,39 +5059,6 @@ attach_docstr("xlogy", r"""xlogy(other) -> Tensor
 
 For details, please refer to :func:`mindspore.ops.xlogy`.
 """)
-attach_docstr("_to", r"""_to(dtype) -> Tensor
-
-    Returns a tensor with the new specified data type.
-
-    Note:
-        When converting complex numbers to boolean type, the imaginary part of the complex number is not
-        taken into account. As long as the real part is non-zero, it returns True; otherwise, it returns False.
-
-    Args:
-        dtype (dtype.Number): The valid data type of the output tensor. Only constant value is allowed.
-
-    Returns:
-        Tensor, the data type of the tensor is `dtype`.
-
-    Raises:
-        TypeError: If `dtype` is not a Number.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> import mindspore
-        >>> import numpy as np
-        >>> from mindspore import Tensor
-        >>> input_np = np.random.randn(2, 3, 4, 5).astype(np.float32)
-        >>> input = Tensor(input_np)
-        >>> dtype = mindspore.int32
-        >>> output = input._to(dtype)
-        >>> print(output.dtype)
-        Int32
-        >>> print(output.shape)
-        (2, 3, 4, 5)
-""")
 attach_docstr("__abs__", r"""__abs__() -> Tensor
 
 Alias for :func:`Tensor.abs`.