mindspore 2.4.10__cp311-cp311-win_amd64.whl → 2.6.0rc1__cp311-cp311-win_amd64.whl

mindspore/_extends/parse/standard_method.py

@@ -17,16 +17,19 @@
 """standard_method"""
 
 from __future__ import absolute_import
-from mindspore import Tensor, CSRTensor, COOTensor
+from mindspore import Tensor, CSRTensor, COOTensor, Parameter
 from mindspore import dtype as mstype
-from mindspore._c_expression import Tensor as Tensor_
+from mindspore._c_expression import TensorPy as Tensor_
 from mindspore.common import mutable
+from mindspore.common.generator import default_generator
 import mindspore.common._monad as monad
 from mindspore.common.sparse_tensor import RowTensorInner
 from mindspore.ops.composite.base import _append, _insert, _pop, _list_clear, _reverse, \
     _extend, _dict_setitem, _dict_clear, _haskey, _update, _fromkeys
 from mindspore.ops.operations._sequence_ops import TensorToTuple
-from mindspore.ops.auto_generate import trace_v2_op, inplace_addmm_op
+from mindspore.ops.auto_generate import trace_v2_op, inplace_addmm_op, inplace_index_put_op, inplace_normal_op, inplace_index_add_op
+from mindspore.ops.auto_generate import inplace_copy_op, inplace_uniform_op, inplace_erfinv_op
+from mindspore.ops.auto_generate import inplace_scatter_add as inplace_scatter_add_
 
 from ... import _checkparam as validator
 from ..._checkparam import check_is_number, check_reshape_shp, check_axis_in_range, \
@@ -36,10 +39,9 @@ from ...ops import operations as P
 from ...ops import composite
 from ...ops.operations import array_ops
 from ...ops.composite import MultitypeFuncGraph, env_get, hyper_add, \
-    zeros_like, ones_like, repeat_elements, multitype_ops
+    zeros_like, ones_like, multitype_ops, _ones_like_for_grad
 from ...ops.composite.multitype_ops import _constexpr_utils as const_utils
 from ...ops.composite.multitype_ops import _compile_utils as compile_utils
-from ...ops.operations.math_ops import Median
 from ...ops.operations._inner_ops import Format
 from ...ops.operations import _csr_ops
 from ...ops.operations import _map_tensor_ops
@@ -50,7 +52,7 @@ from ...ops.operations._sequence_ops import ListAppend, ListInsert, SequenceMax,
     SequenceIndex
 
 __all__ = ['MultitypeFuncGraph', 'env_get',
-           'hyper_add', 'zeros_like', 'ones_like']
+           'hyper_add', 'zeros_like', 'ones_like', '_ones_like_for_grad']
 
 shape_ = P.Shape()
 dtype_ = P.DType()
@@ -66,11 +68,13 @@ _csr_mm = _csr_ops.CSRMM()
 itemsize_map = {mstype.bool_: 1, mstype.int8: 1, mstype.uint8: 1,
                 mstype.float16: 2, mstype.int16: 2, mstype.uint16: 2,
                 mstype.float32: 4, mstype.int32: 4, mstype.uint32: 4,
-                mstype.float64: 8, mstype.int64: 8, mstype.uint64: 8}
+                mstype.float64: 8, mstype.int64: 8, mstype.uint64: 8,
+                mstype.bfloat16: 2}
 
 nan_tensor = Tensor(float('nan'), dtype=mstype.float32)
 
 _map = composite.HyperMap()
+generator_step_ = Tensor(12, mstype.int64)
 
 
 def hypermap_dynamic_tuple(func, *inputs):
@@ -103,6 +107,14 @@ def hypermap_dynamic_list(func, *inputs):
     return ret
 
 
+def index_add_(x, dim, index, source, *, alpha=1):
+    """
+    Accumulate the elements of `alpha` times `source` into the `self` by adding to the indices
+    in the order given in `index`.
+    """
+    return inplace_index_add_op(x, dim, index, source, alpha)
+
+
 def mean(x, axis=None, keep_dims=False):
     """
     Reduces a dimension of a tensor by averaging all elements in the dimension.
@@ -409,7 +421,7 @@ def hasattr(x, attr):  # pylint: disable=redefined-builtin
 
     Args:
         x (object): Input object.
-        attr (string): The name of attribute
+        attr (str): The name of attribute
 
     Returns:
         Boolean value, indicates whether the object x has attribute attr.
@@ -945,17 +957,11 @@ def argmin_with_value(x, axis=0, keep_dims=False):
     return F.min(x, axis, keep_dims)
 
 
-def median(input, global_median, axis=0, keep_dims=False):
+def median(input, axis=-1, keepdims=False):
     r"""
     Computes the median of input tensor.
-
-    .. warning::
-        When attr `global_median` is True, the second output Tensor value is meaningless.
-
     """
-    check_axis_in_range(axis, input.ndim)
-    median_ = Median(global_median, axis, keep_dims)
-    return median_(input)
+    return F.median(input, axis, keepdims)
 
 
 def msort(x):
@@ -1102,6 +1108,13 @@ def copy(x):
     return x
 
 
+def copy_(self, src, non_blocking=False):
+    """
+    Copies the elements from src into self tensor and returns self.
+    """
+    return inplace_copy_op(self, src)
+
+
 def max(input, axis=None, keepdims=False, *, initial=None,  # pylint: disable=redefined-builtin
         where=True, return_indices=False):  # pylint: disable=redefined-outer-name
     """
@@ -1219,6 +1232,13 @@ def pow(x, y):  # pylint: disable=redefined-builtin
     return F.pow(x, y)
 
 
+def put_(x, index, source, accumulate=False):  # pylint: disable=redefined-builtin
+    """
+    Copies the elements from source into the positions specified by index.
+    """
+    return F.put_(x, index, source, accumulate)
+
+
 def log(x):
     """
     Calculate the logarithm of Tensor.
@@ -1261,12 +1281,12 @@ def logcumsumexp(input, axis):
     return F.logcumsumexp(input, axis)
 
 
-def logsumexp(input, axis, keepdims=False):
+def logsumexp(input, dim, keepdim=False):
     """
     Reduces a dimension of a tensor by calculating exponential for all elements in the dimension,
     then calculate logarithm of the sum.
     """
-    return F.logsumexp(input, axis, keepdims)
+    return F.logsumexp(input, dim, keepdim)
 
 
 def round_(x):
@@ -1276,12 +1296,11 @@ def round_(x):
     return F.round(x)
 
 
-def roll(x, shifts, dims):
+def roll(x, shifts, dims=None):
     """
     Rolls the elements of a tensor along an axis.
     """
-    dims = dims if dims is not None else 0
-    return F.Roll(shifts, dims)(x)
+    return F.roll(x, shifts, dims)
 
 
 def rot90(x, k, dims):
@@ -1349,11 +1368,11 @@ def remainder(input, divisor):
     return F.remainder(input, divisor)
 
 
-def unique_consecutive(input, return_idx=False, return_counts=False, axis=None):
+def unique_consecutive(input, return_inverse=False, return_counts=False, dim=None):
     """
     Returns the elements that are unique in each consecutive group of equivalent elements in the input tensor.
     """
-    return F.unique_consecutive(input, return_idx, return_counts, axis)
+    return F.unique_consecutive(input, return_inverse, return_counts, dim)
 
 
 def unique_with_pad(x, pad_num):
@@ -1476,7 +1495,7 @@ def lgamma(input):
 
 def i0(x):
     """
-    For details, please refer to :func:`mindspore.ops.i0`.
+    For details, please refer to :func:`mindspore.ops.bessel_i0`.
     """
     return F.i0(x)
 
@@ -1837,7 +1856,7 @@ def searchsorted(x, v, side='left', sorter=None):
 
     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}.")
+                         f"['left', 'right'], but got {side}.")
     if not isinstance(v, Tensor):
         v = const_utils.make_tensor(v)
     if sorter is not None:
@@ -1931,6 +1950,13 @@ def clamp(x, min=None, max=None):
     return F.clamp(x, min, max)
 
 
+def clamp_(x, min=None, max=None):
+    """
+    Clamps all elements in `x` into the range `[min, max]`.
+    """
+    return F.clamp_(x, min, max)
+
+
 def clip(x, min=None, max=None):
     """
     Clamps all elements in `x` into the range `[min, max]`.
@@ -2157,71 +2183,53 @@ def nanmedian(input, axis=-1, keepdims=False):
     return F.nanmedian(input, axis, keepdims)
 
 
-def repeat(x, repeats, axis=None):
+def repeat(x, *args, repeats=None):
     """
     Repeat elements of an array.
 
     Args:
         x (Tensor): Input tensor.
-        repeats (Union[int, tuple, list]): The number of repetitions for each element.
-            `repeats` is broadcasted to fit the shape of the given axis.
-        axis (int, optional): The axis along which to repeat values. By default,
-            use the flattened input tensor, and return a flat output tensor.
+        args (*int): To simulate an overload like ``repeat(x, *repeats: int)``.
+        repeats (Union[int, tuple[int], list[int]]): The number of repetitions of `a` along
+            each axis. Requires that ``len(repeats) >= x.rank``.
 
     Returns:
-        Tensor, has the same shape as input tensor except along the given axis.
+        Tensor, the repeated output array.
 
     Raises:
-        ValueError: if axis is out of range.
         TypeError: if input is not a Tensor.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> import mindspore.numpy as np
-        >>> x = np.array(3)
-        >>> print(x.repeat(4))
-        [3 3 3 3]
-        >>> x = np.array([[1,2],[3,4]])
-        >>> print(x.repeat(2))
-        [1 1 2 2 3 3 4 4]
-        >>> print(x.repeat(3, axis=1))
-        [[1 1 1 2 2 2]
-        [3 3 3 4 4 4]]
-        >>> print(x.repeat([1,2], axis=0))
-        [[1 2]
-        [3 4]
-        [3 4]]
-    """
-    if not isinstance(repeats, (tuple, list)):
-        repeats = (repeats,)
-    for element in repeats:
-        if not isinstance(element, int):
-            const_utils.raise_type_error("Each element should be integer")
-    if axis is None:
-        x = ravel(x)
-        axis = 0
-    if not isinstance(axis, int):
-        const_utils.raise_type_error('axes should be integers')
-    check_axis_in_range(axis, x.ndim)
-    axis = axis + x.ndim if axis < 0 else axis
-
-    if len(repeats) == 1:
-        repeats = repeats[0]
-        if repeats == 0:
-            return empty_tensor(x.dtype)
-        return repeat_elements(x, repeats, axis)
-    size = x.shape[axis]
-    if len(repeats) != size:
-        const_utils.raise_value_error(
-            'operands could not be broadcast together')
-    subs = P.Split(axis, size)(x)
-    repeated_subs = []
-    for sub_item, rep in zip(subs, repeats):
-        if rep != 0:
-            repeated_subs.append(repeat_elements(sub_item, rep, axis))
-    return P.Concat(axis)(repeated_subs)
+        >>> from mindspore import Tensor
+        >>> a = tensor([0, 1, 2])
+        >>> output = a.repeat(2, 2)  # same as a.repeat((2, 2))
+        >>> print(output)
+        [[0 1 2 0 1 2]
+         [0 1 2 0 1 2]]
+    """
+    # only simulate 2 overload of repeat. Further check by F.tile
+    if repeats is None:
+        # no `repeats`: called by positional arguments like ``x.repeat(...)``
+        if len(args) == 1 and isinstance(args[0], (list, tuple)):
+            repeats = tuple(args[0])  # transform ``x.repeat([x0, x1, ...])`` (list type) to tuple
+        else:
+            repeats = args  # called as variable-length parameter like ``x.repeat(x0, x1, ...)``
+    else:
+        if args:  # simulate an exception thrown by Python interpreter
+            raise TypeError("repeat() got multiple values for argument 'repeat'")
+        # transform named argument with list type like ``x.repeat(repeats=[x0, x1, ...])`` to tuple
+        if isinstance(repeats, list):
+            repeats = tuple(repeats)
+    x_rank = F.rank(x)
+    if len(repeats) < x_rank:
+        raise ValueError(
+            "For repeat, number of items of repeats can not be smaller than the number of "
+            f"dimensions of self tensor, but got repeats with {len(repeats)}"
+            f" items and rank of self Tensor is {x_rank}.")
+    return F.tile(x, repeats)
 
 
 def repeat_interleave(x, repeats, dim=None):
@@ -2312,9 +2320,9 @@ def setitem(data, index, value):
     return data.__setitem__(index, value)
 
 
-def item(data, *args):
+def item(data):
     """Implementation of `item`."""
-    return compile_utils.tensor_item(data, *args)
+    return compile_utils.tensor_item(data)
 
 
 def itemset(data, *args):
@@ -2375,7 +2383,7 @@ def bool_func(*data):
 def cast_to_int(*data):
     target = data[0]
     if isinstance(target, (Tensor, Tensor_)):
-        target = Tensor(target, internal=True)
+        target = Tensor(target)
     if len(data) == 1:
         return int(target)
     return int(target, data[1])
@@ -2413,7 +2421,7 @@ def int_func(*data):
 @constexpr
 def cast_to_float(data):
     if isinstance(data, (Tensor, Tensor_)):
-        data = Tensor(data, internal=True)
+        data = Tensor(data)
     return float(data)
 
 
@@ -2476,6 +2484,18 @@ def tuple_func(data):
     return ret
 
 
+def dict_func(data):
+    """Implementation of `dict`."""
+    if isinstance(data, (tuple, list)):
+        keys = F.make_tuple()
+        values = F.make_tuple()
+        for pair in data:
+            keys = keys + F.make_tuple(pair[0])
+            values = values + F.make_tuple(pair[1])
+        return F.make_dict(keys, values)
+    raise TypeError('Currently, dict() only supports tuple or list input.')
+
+
 def ms_zip(*data):
     """Packs elements in the corresponding positions in multiple sequences into tuples."""
     x = ()
@@ -2585,7 +2605,7 @@ def ms_max_one_element(x):
 def ms_max(*data):
     """Implementation of `max`."""
     len_data = get_max_min_data_len(data)
-    if len_data <= 0: # pylint: disable=no-else-raise
+    if len_data <= 0:  # pylint: disable=no-else-raise
         raise TypeError("max() requires 1 argument at least.")
     elif len_data == 1:
         x = data[0]
@@ -2661,7 +2681,7 @@ def ms_min_one_element(x):
 def ms_min(*data):
     """Implementation of `min`."""
     len_data = get_max_min_data_len(data)
-    if len_data <= 0: # pylint: disable=no-else-raise
+    if len_data <= 0:  # pylint: disable=no-else-raise
         raise TypeError("min() requires 1 argument at least.")
     elif len_data == 1:
         x = data[0]
@@ -2773,9 +2793,9 @@ def enumerate_(x, start=0):
     return ret
 
 
-def expand_tensor_as(x, y):
+def expand_tensor_as(input, x):
     """Expand tensor"""
-    return F.broadcast_to(x, shape_(y))
+    return F.broadcast_to(input, shape_(x))
 
 
 def broadcast_to(x, shape):
@@ -2815,8 +2835,8 @@ def col2im(*inputs):
 
 def narrow(input, axis, start, length):
     """
-    Returns a narrowed tensor from input tensor.
-    The dimension axis is input from start to start + length.
+    Obtains a tensor of a specified length at a
+    specified start position along a specified axis.
     """
     return F.narrow(input, axis, start, length)
 
@@ -2980,6 +3000,11 @@ def tanh(x):
     return F.tanh(x)
 
 
+def tanh_(x):
+    """Returns hyperbolic tangent of `x`."""
+    return F.tanh_(x)
+
+
 def cosh(x):
     """
     Computes hyperbolic cosine of `x` element-wise.
@@ -3011,6 +3036,13 @@ def tensor_scatter_add(x, indices, updates):
     return F.tensor_scatter_add(x, indices, updates)
 
 
+def inplace_scatter_add(input, dim, index, src):
+    """
+    Add all elements in `src` to the index specified by `index` to `self` along dimension specified by `dim`.
+    """
+    return inplace_scatter_add_(input, dim, index, src)
+
+
 def tensor_scatter_sub(x, indices, updates):
     """
     Creates a new tensor by subtracting the values from the positions in `x` indicated by
@@ -3076,11 +3108,11 @@ def negative(input):
     return F.neg(input)
 
 
-def nonzero(input, as_tuple=False):
+def nonzero(input, *, as_tuple=False):
     """
     Return a Tensor of the positions of all non-zero values.
     """
-    return F.nonzero(input, as_tuple)
+    return F.nonzero(input, as_tuple=as_tuple)
 
 
 def new_zeros(x, size, *, dtype=None):
@@ -3182,7 +3214,7 @@ def random_categorical(x, num_sample, seed=0, dtype=mstype.int64):
 @constexpr
 def empty_tensor(dtype):
     """Return empty tensor"""
-    return Tensor_([], dtype)
+    return Tensor([], dtype)
 
 
 @constexpr
@@ -3259,7 +3291,7 @@ check_bool = constexpr(validator.check_bool)
 @constexpr
 def empty_compile(dtype, shape):
     """Returns an empty Tensor."""
-    return Tensor_(dtype, shape)
+    return Tensor(dtype=dtype, shape=shape)
 
 
 def tensor_bool(x):
@@ -3370,6 +3402,23 @@ def norm(A, ord=None, dim=None, keepdim=False, *, dtype=None):
     return F.norm(A, ord, dim, keepdim, dtype=dtype)
 
 
+def normal_(input, mean=0, std=1, *, generator=None):
+    """
+    Update the `input` tensor in place by generating random numbers sampled from the normal
+    distribution which constructed by the parameters `mean` and `std`.
+
+    For details, please refer to :func:`mindspore.Tensor.normal_`.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+    """
+    if generator is None:
+        generator = default_generator
+
+    seed, offset = generator._step(generator_step_)
+    return inplace_normal_op(input, mean, std, seed, offset)
+
+
 def renorm(input_x, p, dim, maxnorm):
     """
     Renormalizes the sub-tensors along dimension `dim`, and each sub-tensor's p-norm should not exceed the
@@ -3649,11 +3698,11 @@ def sparse_ndim_(x):
     return F.tuple_len(x.shape)
 
 
-def bernoulli(input, p=0.5, seed=None):
+def bernoulli(input, *, generator=None):
     """
     Randomly draws binary numbers from a Bernoulli distribution.
     """
-    return F.bernoulli(input, p, seed)
+    return F.bernoulli_ext(input, generator=generator)
 
 
 def gather_nd(input_x, indices):
@@ -3886,7 +3935,7 @@ def atanh(x):
     return F.atanh(x)
 
 
-def baddbmm(x, batch1, batch2, beta=1, alpha=1):
+def baddbmm(x, batch1, batch2, *, beta=1, alpha=1):
     r"""
     For details, please refer to :func:`mindspore.ops.baddbmm`.
     """
@@ -3911,42 +3960,62 @@ def to(input_x, dtype):
     r"""
     Performs tensor dtype conversion.
     """
-    return P.Cast()(input_x, dtype)
+    return F.cast(input_x, dtype)
 
 
 def to_bool(input_x):
     r"""
     Converts input tensor dtype to bool.
     """
-    return P.Cast()(input_x, mstype.bool_)
+    return F.cast(input_x, mstype.bool_)
 
 
 def to_float(input_x):
     r"""
     Converts input tensor dtype to float32.
     """
-    return P.Cast()(input_x, mstype.float32)
+    return F.cast(input_x, mstype.float32)
 
 
 def to_half(input_x):
     r"""
     Converts input tensor dtype to float16.
     """
-    return P.Cast()(input_x, mstype.float16)
+    return F.cast(input_x, mstype.float16)
 
 
 def to_int(input_x):
     r"""
     Converts input tensor dtype to int32.
     """
-    return P.Cast()(input_x, mstype.int32)
+    return F.cast(input_x, mstype.int32)
 
 
 def to_long(input_x):
     r"""
     Converts input tensor dtype to int64.
     """
-    return P.Cast()(input_x, mstype.int64)
+    return F.cast(input_x, mstype.int64)
+
+
+def to_double(input_x):
+    r"""
+    Converts input tensor dtype to float64.
+    """
+    return F.cast(input_x, mstype.float64)
+
+def to_bfloat16(input_x):
+    r"""
+    Converts input tensor dtype to bfloat16.
+    """
+    return F.cast(input_x, mstype.bfloat16)
+
+
+def to_byte(input_x):
+    r"""
+    Converts input tensor dtype to uint8.
+    """
+    return F.cast(input_x, mstype.uint8)
 
 
 def cholesky(input_x, upper=False):
@@ -4034,6 +4103,16 @@ def erfinv(input):
     return F.erfinv(input)
 
 
+def erfinv_(input):
+    r"""
+    For details, please refer to :func:`mindspore.Tensor.erfinv_`.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+    """
+    return inplace_erfinv_op(input)
+
+
 def less_equal(input, other):
     r"""
     Computes the boolean value of :math:`input\_x <= other` element-wise.
@@ -4398,6 +4477,19 @@ def uniform(input, from_=0., to=1., generator=None):
     return F.uniform_ext(input, from_, to, generator)
 
 
+def uniform_(input, from_=0, to=1, *, generator=None):
+    r"""
+    For details, please refer to :func:`mindspore.Tensor.uniform_`.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+    """
+    if generator is None:
+        generator = default_generator
+    seed, offset = generator._step(generator_step_) # pylint: disable=protected-access
+    return inplace_uniform_op(input, from_, to, seed, offset)
+
+
 def amin(input, axis=None, keep_dims=False):
     r"""
     For details, please refer to :func:`mindspore.ops.amin`.
@@ -4428,6 +4520,16 @@ def index_put(input, indices, values, accumulate=False):
     return _index_put(input, values, indices)
 
 
+def index_put_(input, indices, values, accumulate=False):
+    r"""
+    For details, please refer to :func:`mindspore.Tensor.index_put_`.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+    """
+    return inplace_index_put_op(input, indices, values, accumulate)
+
+
 def aminmax(input, *, axis=0, keepdims=False):
     r"""
     For details, please refer to :func:`mindspore.ops.aminmax`.
@@ -4462,14 +4564,31 @@ def outer(input, vec2):
     """
     return F.outer(input, vec2)
 
+
 def sigmoid(input):
     r"""
     For details, please refer to :func:`mindspore.ops.sigmoid`.
     """
     return F.sigmoid(input)
 
+
 def _getitem(data, index):
     return multitype_ops.getitem(data, index)
 
+
 def _setitem(data, index, value):
     return multitype_ops.setitem(data, index, value)
+
+
+def register_hook(x, func):
+    if isinstance(x, Parameter):
+        raise ValueError("Register hook for Parameter inside graph is not supported.")
+    hook_op = P.InsertGradientOf(func)
+    return hook_op(x)
+
+
+def zero_(input):
+    r"""
+    Return a tensor filled with zeros.
+    """
+    return F.zero_(input)

mindspore/_extends/pijit/__init__.py

@@ -18,6 +18,6 @@ Helper module for pijit analyze
 
 
 from .pijit_func_white_list import _func_map as pijit_func_white_list_map
+from .tensor_func_list import get_tensor_method_name
 
-
-__all__ = ['pijit_func_white_list_map']
+__all__ = ['pijit_func_white_list_map', "get_tensor_method_name"]