mindspore 2.7.0__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
 
@@ -339,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
 
@@ -683,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`.""")
@@ -768,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`.
@@ -796,8 +796,6 @@ 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.
-
     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
@@ -836,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.
           
@@ -1341,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.
@@ -1482,7 +1474,7 @@ 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
@@ -1507,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``
@@ -1566,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`.""")
@@ -1576,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.
@@ -1620,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
@@ -1952,9 +2029,6 @@ 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.
 
-.. warning::
-    This is an experimental API that is subject to change or deletion.
-
 Args:
     mask (Tensor[bool]): A bool tensor with a shape broadcastable to the "self Tensor".
     source (Tensor): A tensor with the same data type as the "self Tensor". The number
@@ -1978,11 +2052,52 @@ Examples:
     >>> import numpy as np
     >>> import mindspore
     >>> from mindspore import Tensor
-    >>> source = Tensor(np.array([1., 2., 3., 4.]), mindspore.float32)
+    >>> 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 = source.masked_scatter(mask, tensor)
+    >>> 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
 
@@ -2680,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.
@@ -2690,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``.
 
@@ -2816,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`.
@@ -2936,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`.
@@ -3087,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`.
@@ -3906,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`.
@@ -4086,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`.
@@ -4531,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.
@@ -4807,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`.
@@ -4815,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`.

mindspore/common/_utils.py

@@ -16,15 +16,10 @@
 # ============================================================================
 """common utils."""
 
-import os
-import math
 import types
 import ctypes
-import functools
 
 from mindspore import log as logger
-from mindspore.common import dtype as mstype
-from mindspore.parallel._ps_context import _is_ps_mode, _is_role_pserver, _is_role_sched
 
 
 def is_shape_unknown(shape):
@@ -54,45 +49,6 @@ def get_func(func):
     return func
 
 
-def get_slice_num(dtype, shape):
-    """Check whether size of data is too huge, and cut it to a smaller one, return slice num."""
-    slice_num = 1
-    need_split = _is_ps_mode() and (_is_role_pserver() or _is_role_sched())
-
-    if not need_split:
-        return slice_num
-
-    if "MS_EMBEDDING_REMOTE_CACHE_MEMORY_SIZE" not in os.environ:
-        return slice_num
-
-    num_element = functools.reduce(lambda x, y: x * y, shape, 1)
-    data_size = num_element * mstype.type_size_in_bytes(dtype)
-    remote_cache_size = int(os.getenv("MS_EMBEDDING_REMOTE_CACHE_MEMORY_SIZE")) << 30
-    if remote_cache_size == 0:
-        raise ValueError("The remote cache size set by env variable[MS_EMBEDDING_REMOTE_CACHE_MEMORY_SIZE]"
-                         " should be greater than 0.")
-
-    if data_size <= remote_cache_size:
-        return slice_num
-
-    slice_num = math.ceil(data_size / remote_cache_size)
-    return slice_num
-
-
-def get_slice_shape(dtype, shape):
-    """Check whether size of data is too huge, and cut it to a smaller one, return slice shape."""
-    slice_num = get_slice_num(dtype, shape)
-    if slice_num == 1:
-        return shape
-
-    new_shape = list(shape)
-    if slice_num == 0:
-        raise ValueError("The slice num is at least 1, but got 0")
-    slice_first_dim = math.ceil(new_shape[0] / slice_num)
-    new_shape[0] = slice_first_dim
-    return tuple(new_shape)
-
-
 def _jit_fallback_raise_func(type_name, script):
     """raise function for jit fallback."""
     raise type_name(script)