mindspore 2.5.0__cp310-cp310-win_amd64.whl → 2.6.0rc1__cp310-cp310-win_amd64.whl

mindspore/ops/function/reshard_func.py

@@ -1,4 +1,4 @@
-# Copyright 2023 Huawei Technologies Co., Ltd
+# Copyright 2023-2025 Huawei Technologies Co., Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -13,30 +13,12 @@
 # limitations under the License.
 # ============================================================================
 """Defines parameter operators with functional form."""
-from mindspore.ops import operations as P
-from mindspore.ops._primitive_cache import _get_cache_prim
-from mindspore.parallel.shard import Layout
-from mindspore.common.tensor import Tensor
+from mindspore.parallel.function.reshard_func import reshard as new_reshard
 
 
 def reshard(tensor, layout):
     r"""
-    Specify the tensor by the given layout. The given layout must be type mindspore.Layout,
-    can check :class:`mindspore.Layout` for reference.
-
-    - In the Graph mode, this function can set the sharding propagation strategy of a tensor.
-      For those tensor do not manually be set, their strategies are decided by the sharding
-      strategy propagation algorithm automatically.
-    - In the PyNative mode, this function can set a tensor sharding strategy in a Cell that
-      runs in the Graph mode (i.e. inside the Cell processed by Cell.shard/F.shard).
-
-    Note:
-        - In the auto parallel mode, an exception will throw if the search mode is not
-          "sharding_propagation".
-        - In the semi-auto parallel mode, the parallel mode will automatically switch to auto
-          parallel mode with the search mode be set to "sharding_propagation".
-        - Currently, configuring multi-dimension and multi-copy reshard strategy in
-          mindspore.Layout is not supported.
+    Specify the tensor by the given layout.
 
     Args:
         tensor (Tensor): The tensor to be set the sharding strategy.
@@ -46,56 +28,8 @@ def reshard(tensor, layout):
 
     Returns:
         Tensor. The mathematically equivalent of the input tensor.
-
-    Raises:
-        TypeError: Reshard takes in Tensor type as the first input param, but got: `type(tensor)`.
-        TypeError: Reshard only support type mindspore.Layout but got: `type(layout)`.
-
-    Examples:
-        >>> import numpy as np
-        >>> import mindspore as ms
-        >>> from mindspore import ops, nn, Tensor, context, Layout
-        >>> context.set_context(mode=ms.GRAPH_MODE)
-        >>> context.set_auto_parallel_context(parallel_mode=ms.ParallelMode.AUTO_PARALLEL,
-        ...                                   search_mode="sharding_propagation")
-        >>> class Network(nn.Cell):
-        ...     def __init__(self):
-        ...         super().__init__()
-        ...         self.matmul = ops.MatMul()
-        ...         self.relu = ops.ReLU()
-        ...     def construct(self, x, layout):
-        ...         x = self.relu(x)
-        ...         x_reshard = ops.reshard(x, layout)
-        ...         y = Tensor(np.ones(shape=(128, 128)), dtype=ms.float32)
-        ...         x = self.matmul(x_reshard, y)
-        ...         return x
-        >>>
-        >>> layout = Layout((4, 2), ("dp", "mp"))
-        >>> input_layout = layout("dp", "mp")
-        >>> net = Network()
-        >>> tensor = Tensor(np.ones(shape=(128, 128)), dtype=ms.float32)
-        >>> out = net(tensor, input_layout)
     """
-    if not isinstance(tensor, Tensor):
-        raise TypeError(f"Reshard takes in Tensor type as the first input param, but got: {type(tensor)}.")
-    if not isinstance(layout, Layout):
-        raise TypeError(f"Reshard only support type mindspore.Layout, but got: {type(layout)}.")
-
-    def layout_to_tuple(layout):
-        layout_dict = layout.to_dict()
-        tensor_map = layout_dict["tensor_map"]
-        device_matrix_rev = layout_dict["device_matrix"][::-1]
-        axis_stgy = ()
-        for ind in tensor_map:
-            if ind == -1:
-                axis_stgy += (1,)
-            else:
-                axis_stgy += (device_matrix_rev[ind],)
-        return axis_stgy
-
-    in_strategy = layout_to_tuple(layout)
-    _reshard = _get_cache_prim(P.Reshard)(in_layout=(layout,), out_layout=(layout,), in_strategy=(in_strategy,))
-    return _reshard(tensor)
+    return new_reshard(tensor, layout)
 
 __all__ = [
     'reshard'

mindspore/ops/function/sparse_func.py

@@ -461,8 +461,8 @@ def dense_to_sparse_coo(tensor: Tensor) -> COOTensor:
         - shape (tuple(int)): the shape of the COOTensor, is the same as the original dense tensor.
 
     Raises:
-        TypeError: If input is not a tensor.
-        ValueError: If input tensor is not 2-D.
+        TypeError: If `tensor` is not a tensor.
+        ValueError: If `tensor` is not 2-D.
 
     Supported Platforms:
         ``GPU``
@@ -798,7 +798,7 @@ def csr_add(a: CSRTensor, b: CSRTensor, alpha: Tensor, beta: Tensor) -> CSRTenso
 
         - **indptr** -  Indicates the start and end point for non-zero values in each row.
         - **indices** - The column positions of all non-zero values of the input.
-        - **values** - The non-zero values of the dense tensor.
+        - **values** - The non-zero values.
         - **shape** - The shape of the CSRTensor.
 
     Supported Platforms:

mindspore/ops/function/sparse_unary_func.py

@@ -674,7 +674,7 @@ def csr_sqrt(x: CSRTensor) -> CSRTensor:
 
 def coo_sqrt(x: COOTensor) -> COOTensor:
     r"""
-    Returns sqrt of a COOTensor element-wise.
+    Computes sqrt of a COOTensor element-wise.
 
     .. math::
 
@@ -798,11 +798,11 @@ def csr_isnan(x: CSRTensor) -> CSRTensor:
     .. math::
 
         out_i = \begin{cases}
-          & \ True,\ \text{ if } x_{i} = \text{Nan} \\
-          & \ False,\ \text{ if } x_{i} \ne  \text{Nan}
+          & \ True,\ \text{ if } x_{i} = \text{NaN} \\
+          & \ False,\ \text{ if } x_{i} \ne  \text{NaN}
         \end{cases}
 
-    where :math:`Nan` means not a number.
+    where :math:`NaN` means not a number.
 
     Args:
         x (CSRTensor): The input CSRTensor.
@@ -1905,7 +1905,7 @@ def coo_neg(x: COOTensor) -> COOTensor:
         x (COOTensor): The input COOTensor with a dtype of Number.
 
     Returns:
-        COOTensor, has the same shape and dtype as input.
+        COOTensor, has the same shape and dtype as input `x`.
 
     Raises:
         TypeError: If `x` is not a COOTensor.

mindspore/ops/function/spectral_func.py

@@ -22,15 +22,9 @@ from .._primitive_cache import _get_cache_prim
 
 def blackman_window(window_length, periodic=True, *, dtype=None):
     r"""
-    Blackman window function, usually used to extract finite signal segment for FFT.
+    Blackman window function.
 
-    The `window_length` is a input tensor which determines the returned window size, and its data should be
-    an integer. In particular, if `window_length` is equal to `1`, only a single value `1` exists in the
-    returned window.
-
-    Attr `periodic` determines whether the returned window removes the last duplicate value
-    from the symmetric window and prepares to be a periodic window with functions.
-    Therefore, if attr `periodic` is true, the :math:`N` in formula is :math:`window\_length + 1`.
+    Usually used to extract finite signal segment for FFT.
 
     .. math::
 
@@ -39,35 +33,23 @@ def blackman_window(window_length, periodic=True, *, dtype=None):
     where :math:`N` is the full window size, and n is natural number less than :math:`N` :[0, 1, ..., N-1].
 
     Args:
-        window_length (Tensor): The size of returned window, with data type int32, int64.
-            The input data should be an integer with a value of [0, 1000000].
-        periodic (bool, optional): Indicates whether to returns a window to be used as periodic function or
-            a symmetric window. Default: ``True`` .
+        window_length (Tensor): The size of window.
+        periodic (bool, optional): If ``True`` , return a periodic window. If ``False``, return a symmetric window.
+            Default ``True`` .
 
     Keyword Args:
-        dtype (mindspore.dtype, optional): The data type of returned tensor.
-            Only float16, float32 and float64 is allowed. Default: ``None`` .
+        dtype (mindspore.dtype, optional): The data type specified. Default ``None`` .
 
     Returns:
-        A 1-D tensor of size `window_length` containing the window. Its datatype is set by the attr `dtype`.
-        If 'dtype' is None, output datatype is float32.
-
-    Raises:
-        TypeError: If `window_length` is not a Tensor.
-        TypeError: If `periodic` is not a bool.
-        TypeError: If `dtype` is not one of: float16, float32, float64.
-        TypeError: If the type of `window_length` is not one of: int32, int64.
-        ValueError: If the value range of `window_length` is not [0, 1000000].
-        ValueError: If the dimension of `window_length` is not 0.
+        A 1-D tensor.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> import mindspore
-        >>> from mindspore import Tensor, ops
-        >>> window_length = Tensor(10, mindspore.int32)
-        >>> output = ops.blackman_window(window_length, periodic=True, dtype=mindspore.float32)
+        >>> window_length = mindspore.tensor(10)
+        >>> output = mindspore.ops.blackman_window(window_length)
         >>> print(output)
         [-2.9802322e-08  4.0212840e-02  2.0077014e-01  5.0978714e-01
           8.4922993e-01  1.0000000e+00  8.4922981e-01  5.0978690e-01
@@ -82,16 +64,10 @@ def blackman_window(window_length, periodic=True, *, dtype=None):
 
 def bartlett_window(window_length, periodic=True, *, dtype=None):
     r"""
-    Bartlett window function is a triangular-shaped weighting function used for smoothing or frequency analysis of
-    signals in digital signal processing.
+    Bartlett window function.
 
-    The `window_length` is a input tensor which determines the returned window size, and its data should be
-    an integer. In particular, if `window_length` is equal to `1`, only a single value 1 exists in the
-    returned window.
-
-    Attr `periodic` determines whether the returned window removes the last duplicate value from the symmetric
-    window and prepares to be a periodic window with functions. Therefore, if attr `periodic` is true,
-    the :math:`N` in formula is :math:`window\_length + 1`.
+    A triangular-shaped weighting function used for smoothing or frequency analysis of signals in digital signal
+    processing.
 
     .. math::
 
@@ -100,40 +76,31 @@ def bartlett_window(window_length, periodic=True, *, dtype=None):
         2 - \frac{2n}{N - 1} & \text{if } \frac{N - 1}{2} < n < N \\
         \end{cases},
 
-    where N is the full window size.
+    where :math:`N` is the full window size, and n is natural number less than :math:`N` :[0, 1, ..., N-1].
 
     Args:
-        window_length (Tensor): The size of returned window, with data type int32, int64.
-            The input data should be an integer with a value of [0, 1000000].
-        periodic (bool, optional): Indicates whether to returns a window to be used as periodic function or
-            a symmetric window. Default: ``True`` , indicating that the returned window is a periodic function.
+        window_length (Tensor): The size of window.
+        periodic (bool, optional): If ``True`` , return a periodic window. If ``False``, return a symmetric window.
+            Default ``True`` .
 
     Keyword Args:
-        dtype (mindspore.dtype, optional): The datatype of returned tensor.
-            Only float16, float32 and float64 are allowed. Default: ``None`` .
+        dtype (mindspore.dtype, optional): The data type specified. Default ``None`` .
 
     Returns:
-        A 1-D tensor of size `window_length` containing the window. Its datatype is set by the attr `dtype`.
-        If `dtype` is None, output datatype is float32.
-
-    Raises:
-        TypeError: If `window_length` is not a Tensor.
-        TypeError: If the type of `window_length` is not one of: int32, int64.
-        TypeError: If `periodic` is not a bool.
-        TypeError: If `dtype` is not one of: float16, float32, float64.
-        ValueError: If the value range of `window_length` is not [0, 1000000].
-        ValueError: If the dimension of `window_length` is not 0.
+        A 1-D tensor.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
-        >>> from mindspore import Tensor, ops
-        >>> from mindspore import dtype as mstype
-        >>> window_length = Tensor(5, mstype.int32)
-        >>> output = ops.bartlett_window(window_length, periodic=True, dtype=mstype.float32)
+        >>> import mindspore
+        >>> window_length = mindspore.tensor(5)
+        >>> output = mindspore.ops.bartlett_window(window_length)
+        >>> print(output)
+        [0.  0.4 0.8 0.8 0.4]
+        >>> output = mindspore.ops.bartlett_window(window_length, periodic=False)
         >>> print(output)
-        [0. 0.4 0.8 0.8 0.4]
+        [0.  0.5 1.  0.5 0. ]
     """
     if dtype is None:
         dtype = mstype.float32

mindspore/ops/function/vmap_func.py

@@ -26,9 +26,7 @@ def vmap(fn, in_axes=0, out_axes=0):
 
     Vmap is pioneered by Jax and it removes the restriction of batch dimension on the operator, and provides a
     more convenient and unified operator expression. Moreover, it allows users to composite with other functional
-    modules such as :func:`mindspore.grad`, to improve the development efficiency, please refer to the
-    `Automatic Vectorization (Vmap) <https://www.mindspore.cn/docs/en/master/model_train/train_process/optimize/vmap.html>`_
-    tutorial for more detail.
+    modules such as :func:`mindspore.grad`, to improve the development efficiency.
     In addition, the vectorizing map does not execute loops outside the function, but sinks loops
     into the primitive operations of the function for better performance. When combined with `Graph Kernel Fusion`,
     operational efficiency would be further improved.
@@ -49,21 +47,30 @@ def vmap(fn, in_axes=0, out_axes=0):
             argument and returns one or more Tensors or the type of data supported by the MindSpore Tensor. When it is
             a CellList, the model ensembling scenario, please make sure that the structure of each cell is the same
             and the number of cells is consistent with the sizes of the mapped axes (`axis_size`).
-        in_axes (Union[int, list, tuple]): Specifies which dimensions (axes) of the inputs should be mapped over.
-            If `in_axes` is an integer, all arguments of `fn` are mapped over according to this axis index. If `in_axes`
-            is a tuple or list, which only composed of integers or Nones and the length should equal to the number of
-            positional arguments to `fn`, indicates which axis to map for each corresponding positional argument.
-            Note that, axis integers must be in range :math:`[-ndim, ndim)` for each argument, where `ndim` is the
-            number of dimensions of the corresponding argument.  None means not mapping along any axis. Also the
-            mapping axis index of the `in_axes` must have at least one positional parameter not None. The sizes of
-            the mapped axes (`axis_size`) for all arguments must be equal. Default: ``0`` .
+        in_axes (Union[int, list, tuple]): Specifies which dimensions (axes)
+            of the inputs should be mapped over. Default: ``0`` .
+
+            - If `in_axes` is an integer, all arguments of `fn` are mapped over according to this axis index.
+            - If `in_axes` is a tuple or list, which only composed of integers or Nones
+              and the length should equal to the number of
+              positional arguments to `fn`, indicates which axis to map for each corresponding positional argument.
+              Note that, axis integers must be in range :math:`[-ndim, ndim)` for each argument, where `ndim` is the
+              number of dimensions of the corresponding argument.
+            - None means not mapping along any axis. Also the
+              mapping axis index of the `in_axes` must have at least one positional parameter not None. The sizes of
+              the mapped axes (`axis_size`) for all arguments must be equal.
+
         out_axes (Union[int, list, tuple]): Specifies where the mapped dimensions (axes) should appear in the
-            outputs. If `out_axes` is an integer, all outputs of `fn` are specified according to this axis. If
-            `out_axes` is a tuple or list, which only composed of integers or Nones. And its length also should be equal
-            to the number of outputs of `fn`. Note that, axis integers must be in range :math:`[-ndim, ndim)` for each
-            output, where `ndim` is the dimension of the output of the `vmap`-mapped function. All outputs with a
-            non-None mapped axis must specify a non-None `out_axes`, and if outputs with None mapped axis specifies
-            a non-None `out_axes`, the result broadcasts across the mapped axis. Default: ``0`` .
+            outputs. Default: ``0`` .
+
+            - If `out_axes` is an integer, all outputs of `fn` are specified according to this axis.
+            - If `out_axes` is a tuple or list, which only composed of integers or Nones.
+              And its length also should be equal
+              to the number of outputs of `fn`. Note that, axis integers must be in range :math:`[-ndim, ndim)` for each
+              output, where `ndim` is the dimension of the output of the `vmap`-mapped function.
+            - All outputs with a
+              non-None mapped axis must specify a non-None `out_axes`, and if outputs with None mapped axis specifies
+              a non-None `out_axes`, the result broadcasts across the mapped axis.
 
     Returns:
         Function, returns the Vectorized/Batched version function of `fn`. The arguments and outputs of this function

mindspore/ops/functional.py

@@ -20,7 +20,7 @@ from mindspore.common._register_for_tensor import tensor_operator_registry
 from mindspore.ops import _constants
 from mindspore.ops.function import *
 from mindspore.ops.function.array_func import chunk_ext, zero_
-from mindspore.ops.function.math_func import all, argmax_ext, float_power_ext, erfinv_, tanh_
+from mindspore.ops.function.math_func import all, argmax_ext, float_power_ext, erfinv_, tanh_, bernoulli_ext
 from mindspore.ops.function.random_func import random_, uniform_ext, uniform_, normal_
 from mindspore.ops import operations as P
 from mindspore.ops.operations import array_ops
@@ -36,10 +36,10 @@ from mindspore.ops.function.math_func import dot
 from mindspore.ops.function.array_func import new_empty
 from mindspore.ops import auto_generate
 from mindspore.ops.auto_generate import cast
-from mindspore.ops_generate.gen_ops_inner_prim import DtypeToEnum
+from mindspore.ops._utils.arg_dtype_cast import DtypeToEnum
 from mindspore.ops.operations.manually_defined.ops_def import scalar_div, scalar_mod, scalar_add, scalar_mul, \
     scalar_sub, scalar_gt, scalar_ge, scalar_le, scalar_lt, scalar_eq, scalar_floordiv, scalar_log, scalar_pow, \
-    scalar_uadd, scalar_usub
+    scalar_uadd, scalar_usub, scalar_max, scalar_min
 
 typeof = Primitive('typeof')
 hastype = Primitive('hastype')
@@ -117,6 +117,7 @@ switch_layer = Primitive('switch_layer')
 reduced_shape = Primitive("reduced_shape")
 # shape_mul:input must be shape multiply elements in tuple(shape)
 shape_mul = _sequence_ops.shape_mul()
+put_ = auto_generate.put_
 
 setattr(tensor_operator_registry, 'tuple_to_tensor',
         _sequence_ops.TupleToTensor)
@@ -307,6 +308,7 @@ setattr(tensor_operator_registry, 'ormqr', ormqr)
 setattr(tensor_operator_registry, 'masked_scatter', array_ops.MaskedScatter)
 setattr(tensor_operator_registry, 'index_put', array_ops.IndexPut)
 setattr(tensor_operator_registry, 'index_put_', auto_generate.index_put_)
+setattr(tensor_operator_registry, 'put_', put_)
 setattr(tensor_operator_registry, 'quantile', quantile)
 setattr(tensor_operator_registry, 'nanquantile', nanquantile)
 setattr(tensor_operator_registry, 'orgqr', orgqr)
@@ -395,7 +397,7 @@ setattr(tensor_operator_registry, 'tensor_scatter_add', tensor_scatter_add)
 setattr(tensor_operator_registry, 'inplace_scatter_add', auto_generate.inplace_scatter_add)
 setattr(tensor_operator_registry, 'slice_scatter', slice_scatter)
 setattr(tensor_operator_registry, 'select_scatter', select_scatter)
-setattr(tensor_operator_registry, 'bernoulli', bernoulli)
+setattr(tensor_operator_registry, 'bernoulli', bernoulli_ext)
 setattr(tensor_operator_registry, 'poisson', P.Poisson)
 setattr(tensor_operator_registry, 'randperm', P.Randperm)
 setattr(tensor_operator_registry, 'multinomial', multinomial)