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

mindspore/ops/operations/other_ops.py

@@ -19,7 +19,8 @@ from mindspore import log as logger
 from mindspore.ops import signature as sig
 from mindspore import _checkparam as validator
 from mindspore.common import dtype as mstype
-from mindspore.ops.primitive import Primitive, PrimitiveWithCheck, PrimitiveWithInfer, prim_attr_register
+from mindspore.ops.primitive import Primitive, PrimitiveWithCheck, PrimitiveWithInfer
+from mindspore.ops.primitive import prim_attr_register, prim_arg_register
 from mindspore.ops.operations._pyfunc_registry import add_pyfunc
 from mindspore._c_expression import typing
 from mindspore.ops._primitive_cache import _get_cache_prim
@@ -142,9 +143,10 @@ class BoundingBoxDecode(Primitive):
 
     Args:
         max_shape (tuple): The max size limit for decoding box calculation.
-        means (tuple): The means of deltas calculation. Default: ``(0.0, 0.0, 0.0, 0.0)`` .
-        stds (tuple): The standard deviations of deltas calculation. Default: ``(1.0, 1.0, 1.0, 1.0)`` .
-        wh_ratio_clip (float): The limit of width and height ratio for decoding box calculation. Default: ``0.016`` .
+        means (tuple, optional): The means of deltas calculation. Default: ``(0.0, 0.0, 0.0, 0.0)`` .
+        stds (tuple, optional): The standard deviations of deltas calculation. Default: ``(1.0, 1.0, 1.0, 1.0)`` .
+        wh_ratio_clip (float, optional): The limit of width and height ratio for decoding box calculation.
+            Default: ``0.016`` .
 
     Inputs:
         - **anchor_box** (Tensor) - Anchor boxes. The shape of `anchor_box` must be :math:`(n, 4)`.
@@ -371,13 +373,13 @@ class IOU(Primitive):
     r"""
     Calculates intersection over union for boxes.
 
-    Computes the intersection over union (IOU) or the intersection over foreground (IOF) based on the ground-truth and
+    Computes the intersection over union (IOU) or the intersection over foreground (IOF) based on the truth and
     predicted regions.
 
     Refer to :func:`mindspore.ops.iou` for more details.
 
     Args:
-        mode (string): The mode is used to specify the calculation method,
+        mode (str): The mode is used to specify the calculation method,
                        now supporting ``'iou'`` (intersection over union) or ``'iof'``
                        (intersection over foreground) mode. Default: ``'iou'`` .
 
@@ -385,7 +387,7 @@ class IOU(Primitive):
         - **anchor_boxes** (Tensor) - Anchor boxes, tensor of shape :math:`(N, 4)`.
           "N" indicates the number of anchor boxes,
           and the value "4" refers to "x0", "y0", "x1", and "y1". Data type must be float16 or float32.
-        - **gt_boxes** (Tensor) - Ground truth boxes, tensor of shape :math:`(M, 4)`. "M" indicates the number of ground
+        - **gt_boxes** (Tensor) - The truth boxes, tensor of shape :math:`(M, 4)`. "M" indicates the number of
           truth boxes, and the value "4" refers to "x0", "y0", "x1", and "y1". Data type must be float16 or float32.
 
     Outputs:
@@ -524,6 +526,57 @@ class Depend(Primitive):
         return value
 
 
+class MoveTo(Primitive):
+    r"""
+    Copy tensor to target device synchronously or asynchronously, default synchronously.
+
+    .. note::
+        This interface currently only supports Graph mode with jit_level of O0 or O1.
+
+    Args:
+        input (Union[Tensor, list[int], tuple[int]]): The input tensor. When the input is list and tuple, it will be
+                                                      converted to tensor before copying.
+        to (str, optional): Specify the target device, with optional values of ``"Ascend"`` and ``"CPU"``.
+                            Default ``"CPU"`` .
+        blocking (bool, optional): Whether use synchronous copying. Default ``True``.
+
+    Returns:
+        A new tensor on target device.
+
+    Supported Platforms:
+        ``Ascend`` ``CPU``
+
+    Examples:
+        >>> import mindspore
+        >>> from mindspore import nn, ops, Tensor
+        >>> mindspore.set_context(mode=mindspore.GRAPH_MODE)
+        >>> class MoveToNet(nn.Cell):
+        ...     def __init__(self):
+        ...         super().__init__()
+        ...         self.move_to = ops.MoveTo()
+        ...
+        ...     def construct(self, x):
+        ...         cpu_x = self.move_to(x, "CPU")
+        ...         npu_x = self.move_to(cpu_x, "Ascend")
+        ...         return npu_x
+        ...
+        >>> net = MoveToNet()
+        >>> x = Tensor([1, 2, 3], mindspore.int64)
+        >>> y = net(x)
+        >>> print(y)
+        [1 2 3]
+    """
+    __mindspore_signature__ = (
+        sig.make_sig('input'),
+        sig.make_sig('to', default='CPU'),
+        sig.make_sig('blocking', default=True)
+    )
+
+    @prim_arg_register
+    def __init__(self):
+        pass
+
+
 class UpdateState(Primitive):
     """
     UpdateState is used for update side-effect state.
@@ -584,7 +637,7 @@ class StopGradient(Primitive):
         pass
 
 
-stop_gradient_ = StopGradient()
+stop_gradient_op = StopGradient()
 
 
 class ConfusionMatrix(PrimitiveWithInfer):
@@ -650,7 +703,7 @@ class Push(PrimitiveWithInfer):
     Pushes the inputs of the corresponding optimizer to parameter server.
 
     Args:
-        optim_type (string): The optimizer type. Default: ``'ApplyMomentum'`` .
+        optim_type (str): The optimizer type. Default: ``'ApplyMomentum'`` .
         only_shape_indices (list): The indices of input of which only shape
                                    will be pushed to parameter server. Default: ``None`` .
 

mindspore/ops/operations/random_ops.py

@@ -373,11 +373,17 @@ class Gamma(PrimitiveWithInfer):
         \text{P}(x|α,β) = \frac{\exp(-x/β)}{{β^α}\cdot{\Gamma(α)}}\cdot{x^{α-1}}
 
     Note:
-        - Random seed: a set of regular random numbers can be obtained through some complex mathematical algorithms,
-          and the random seed determines the initial value of this random number. If the random seed is the same in two
-          separate calls, the random number generated will not change.
-        - Using the Philox algorithm to scramble seed and seed2 to obtain random seed so that the user doesn't need
-          to worry about which seed is more important.
+        - Random Seed: Through some complex mathematical algorithms, a set of regular random numbers can be obtained,
+          and the random seed is the initial value of this random number.
+          The random seed is the same, the random number obtained will not change.
+        - When neither the global random seed nor the operator layer random seed
+          is set or both are 0: generate completely random numbers.
+        - When the global random seed is set, but the operator layer random seed is not set:
+          splice the global random seed with 0.
+        - When the global random seed is not set, but the operator layer random seed is set:
+          splice 0 with the operator layer random seed.
+        - When both the global random seed and the operator layer random seed are set:
+          splice the global random seed with the operator layer random seed.
 
     .. warning::
         The Ascend backend does not support the reproducibility of random numbers, so
@@ -870,7 +876,7 @@ class RandomCategorical(PrimitiveWithInfer):
         the `seed` parameter has no effect.
 
     Args:
-        dtype (mindspore.dtype): The type of output. Its value must be one of mstype.int16,
+        dtype (mindspore.dtype, optional): The type of output. Its value must be one of mstype.int16,
             mstype.int32 and mstype.int64. Default: ``mstype.int64`` .
 
     Inputs:
@@ -1009,7 +1015,7 @@ class MultinomialWithReplacement(Primitive):
         - **x** (Tensor) - the input tensor containing the cumsum of probabilities, must be 1 or 2
           dimensions.
         - **seed** (Tensor) - If `seed` and 'offset' are both set to 0, the random number generator
-          is seeded by a random seed. Otherwise, it is seeded by the given seed and offset.
+          is generated by a random seed. Otherwise, it is seeded by the given seed and offset.
           Supported dtype: int64.
         - **offset** (Tensor) - Offset used to avoid seed collision. Supported dtype: int64.
 

mindspore/ops/operations/reshard_ops.py

@@ -23,7 +23,7 @@ class Reshard(Primitive):
     parallel procedure.
 
     Note:
-        - The in and out layout should be the type mindspore.Layout.
+        - The in and out layout should be the type mindspore.parallel.Layout.
         - The in and out layout should be the same value of layout when invoke
           ops.Reshard(layout, layout, in_strategy).
         - The in_strategy should be the strategy derived from the layout.

mindspore/ops/operations/sparse_ops.py

@@ -636,8 +636,8 @@ class SparseTensorDenseMatmul(Primitive):
     Raises:
         TypeError: If the type of `adjoint_st` or `adjoint_dt` is not bool, or the dtype of `indices`,
             dtype of `values` and dtype of `dense` don't meet the parameter description.
-        ValueError: If `sparse_shape`, shape of `indices`, shape of `values`,
-            and shape of `dense` don't meet the parameter description.
+        ValueError: If the shapes of `sparse_shape`, `indices`, `values`,
+            and `dense` don't meet the constraints in the parameter description.
 
     Supported Platforms:
         ``GPU`` ``CPU``

mindspore/ops/primitive.py

@@ -1,4 +1,4 @@
-# Copyright 2020-2024 Huawei Technologies Co., Ltd
+# Copyright 2020-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.
@@ -26,7 +26,7 @@ from mindspore.parallel._utils import _is_in_auto_parallel_mode, _is_in_data_par
 from mindspore.parallel._ps_context import _is_ps_mode, _is_role_sched
 from mindspore.parallel.shard import Layout
 from mindspore.common.api import _pynative_executor
-from mindspore.common._stub_tensor import _convert_stub
+from mindspore.common.jit_context import jit_context
 from mindspore._c_expression import Primitive_, PrimitiveFunction_, prim_type, typing
 from mindspore import _checkparam as Validator
 from mindspore.ops import signature as sig
@@ -194,13 +194,13 @@ class Primitive(Primitive_):
             layout_value = ()
             for in_ele in layout:
                 if isinstance(in_ele, Layout):
-                    layout_value += (in_ele.to_dict(),)
+                    layout_value += ({k: v for k, v in in_ele.to_dict().items() if k != 'rank_list'},)
                 elif isinstance(in_ele, tuple):
                     new_layout_list = ()
                     for ele in in_ele:
                         if not isinstance(ele, Layout):
                             raise TypeError(f"The {log_info} item should be a object of class Layout.")
-                        new_layout_list += (ele.to_dict(),)
+                        new_layout_list += ({k: v for k, v in ele.to_dict().items() if k != 'rank_list'},)
                     layout_value += (new_layout_list,)
                 else:
                     raise TypeError(f"The {log_info} item should be a object of class Layout or a tuple.")
@@ -401,6 +401,9 @@ class Primitive(Primitive_):
         return (False, None)
 
     def __call__(self, *args):
+        # Add for jit context.
+        if jit_context() and jit_context().compiled:
+            return None
         should_elim, output = self.check_elim(*args)
         if should_elim:
             return output
@@ -498,6 +501,28 @@ class Primitive(Primitive_):
         self.add_prim_attr("recompute", mode)
         return self
 
+    def _offload(self, backward_prefetch="Auto"):
+        """
+        Set the primitive offload. If a primitive set offload feeds into some nodes for offloading
+        gradient, rather than storing the intermediate activation computed in forward pass, we will
+        offload the activations computed in forward pass and upload them backward pass.
+
+        Note:
+            - Not supported in pynative mode
+
+        Args:
+            backward_prefetch(Union[str, int]): Specifies whether the activation is prefetched in backward pass.
+        """
+        if context.get_context("mode") == context.PYNATIVE_MODE:
+            raise ValueError("Offload is not supported in pynative mode currently.")
+        self.add_prim_attr("offload", True)
+        if isinstance(backward_prefetch, str):
+            Validator.check_string(backward_prefetch, ['Auto'], 'backward_prefetch', 'Primitive._offload')
+        else:
+            Validator.check_non_negative_int(backward_prefetch)
+        self.add_prim_attr("backward_prefetch", backward_prefetch)
+        return self
+
     def place(self, role, rank_id):
         """
         Set the label for this primitive.
@@ -563,7 +588,7 @@ class PrimitiveWithCheck(Primitive):
     the shape and type. Method infer_value() can also be defined (such as PrimitiveWithInfer) for constant propagation.
 
     More on how to customize a Op, please refer to `Custom Operators
-    <https://www.mindspore.cn/docs/en/master/model_train/custom_program/op_custom.html>`_.
+    <https://www.mindspore.cn/tutorials/en/master/custom_program/op_custom.html>`_.
 
     Args:
         name (str): Name of the current Primitive.
@@ -657,7 +682,7 @@ class PrimitiveWithInfer(Primitive):
     logic of the shape and type. The infer_value() is used for constant propagation.
 
     More on how to customize a Op, please refer to `Custom Operators
-    <https://www.mindspore.cn/docs/en/master/model_train/custom_program/op_custom.html>`_.
+    <https://www.mindspore.cn/tutorials/en/master/custom_program/op_custom.html>`_.
 
     Args:
         name (str): Name of the current Primitive.
@@ -874,14 +899,15 @@ def constexpr(fn=None, get_instance=True, name=None, reuse_result=True, check=Tr
     """Used to calculate constant in graph copmpiling process and improve compile performance in GRAPH_MODE.
 
     Args:
-        fn (function): A `fn` use as the infer_value of the output operator. Default: ``None`` .
-        get_instance (bool): If ``True`` , return the instance of operator,
+        fn (function, optional): A `fn` use as the infer_value of the output operator. Default: ``None`` .
+        get_instance (bool, optional): If ``True`` , return the instance of operator,
                              otherwise return the operator class. Default: ``True`` .
-        name (str): Defines the operator name. If `name` is ``None`` , use the function name as op name.
+        name (str, optional): Defines the operator name. If `name` is ``None`` , use the function name as op name.
                              Default: ``None`` .
-        reuse_result (bool): If ``True`` , the operator will be executed once and reuse the result next time,
+        reuse_result (bool, optional): If ``True`` , the operator will be executed once
+                             and reuse the result next time,
                              otherwise the operator will always be executed. Default: ``True`` .
-        check (bool): If ``True`` , the parameters will be checked
+        check (bool, optional): If ``True`` , the parameters will be checked
             and the warning message will raised if the parameter is not const value. Default: ``True`` .
 
     Examples:
@@ -1001,29 +1027,14 @@ def _primexpr(fn=None, get_instance=True, name=None, reuse_result=True):
     return deco
 
 
-class _RunOpHook:
-    """Hook for run op"""
-
-    current = None
-
-    def __init__(self, hook):
-        self.hook = hook
-        self.old = _RunOpHook.current
-
-    def __enter__(self):
-        _RunOpHook.current = self
-        return self
-
-    def __exit__(self, *err):
-        _RunOpHook.current = self.old
-
-
 def _run_op(obj, op_name, args):
     """Single op execution function supported by ge in PyNative mode."""
-    if not _RunOpHook.current:
-        stub = _pynative_executor.run_op_async(obj, op_name, args)
-        return _convert_stub(stub)
-    return _RunOpHook.current.hook(obj, args)
+    res = _pynative_executor.run_op_async(obj, op_name, args)
+    # Add for jit context.
+    if jit_context():
+        # todo support TensorPy
+        return jit_context().run_op(obj, res, *args)
+    return res
 
 
 @_wrap_func