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

mindspore/ops/operations/debug_ops.py

@@ -13,23 +13,25 @@
 # limitations under the License.
 # ============================================================================
 """debug_ops"""
-import os
 import stat
+from pathlib import Path
 
 import numpy as np
 from mindspore import log as logger
 from mindspore._c_expression import security, HookType
-from mindspore._c_expression import Tensor as Tensor_
+from mindspore._c_expression import TensorPy as Tensor_
+from mindspore._c_expression import _tensordump_process_file
 from mindspore import _checkparam as validator
 from mindspore.common import dtype as mstype
 from mindspore.common.parameter import Parameter
 from mindspore.common.tensor import Tensor
+from mindspore.common.jit_context import jit_context
 from mindspore.ops.primitive import prim_attr_register, Primitive, PrimitiveWithInfer
 from mindspore._checkparam import check_hook_fn
+from mindspore.ops import operations as P
 
 
 SUMMARY_TENSOR_CACHE = []
-TENSORDUMP_ID = 0
 
 
 def _cache_summary_data(op_name, define_name, tensor):
@@ -61,11 +63,9 @@ class ScalarSummary(Primitive):
     """
     This operator will put a scalar to a summary file with protocol buffer format.
     It must be used with :class:`mindspore.SummaryRecord` or :class:`mindspore.SummaryCollector`,
-    which specify the directory of the summary file. The summary file can
-    be loaded and shown by MindInsight, see `MindInsight documents <https://www.mindspore.cn/
-    mindinsight/docs/en/master/index.html>`_ for details.
-    In Ascend platform with graph mode, can set environment variables `MS_DUMP_SLICE_SIZE` and `MS_DUMP_WAIT_TIME`
-    to solve operator execution failure when calling this operator intensively.
+    which specify the directory of the summary file.
+    In Ascend platform with graph mode, the environment variables `MS_DUMP_SLICE_SIZE` and `MS_DUMP_WAIT_TIME`
+    can be set to solve operator execution failure when calling this operator intensively.
 
     Inputs:
         - **name** (str) - The name of the input variable, it must not be an empty string.
@@ -121,11 +121,9 @@ class ScalarSummary(Primitive):
 class ImageSummary(Primitive):
     """
     This operator will put an image tensor to a summary file with protocol buffer format. It must be used with
-    SummaryRecord or SummaryCollector, which specify the directory of the summary file. The summary file can
-    be loaded and shown by MindInsight, see `MindInsight documents <https://www.mindspore.cn/
-    mindinsight/docs/en/master/index.html>`_ for details.
-    In Ascend platform with graph mode, can set environment variables `MS_DUMP_SLICE_SIZE` and `MS_DUMP_WAIT_TIME`
-    to solve operator execution failure when calling this operator intensively.
+    SummaryRecord or SummaryCollector, which specify the directory of the summary file.
+    In Ascend platform with graph mode, the environment variables `MS_DUMP_SLICE_SIZE` and `MS_DUMP_WAIT_TIME`
+    can be set to solve execution failure when calling this operator intensively.
 
     Inputs:
         - **name** (str) - The name of the input variable, it must not be an empty string.
@@ -174,11 +172,9 @@ class ImageSummary(Primitive):
 class TensorSummary(Primitive):
     """
     This operator will put a tensor to a summary file with protocol buffer format. It must be used with SummaryRecord
-    or SummaryCollector, which specify the directory of the summary file. The summary file can
-    be loaded and shown by MindInsight, see `MindInsight documents <https://www.mindspore.cn/
-    mindinsight/docs/en/master/index.html>`_ for details.
-    In Ascend platform with graph mode, can set environment variables `MS_DUMP_SLICE_SIZE` and `MS_DUMP_WAIT_TIME`
-    to solve operator execution failure when calling this operator intensively.
+    or SummaryCollector, which specify the directory of the summary file.
+    In Ascend platform with graph mode, the environment variables `MS_DUMP_SLICE_SIZE` and `MS_DUMP_WAIT_TIME`
+    can be set to solve operator execution failure when calling this operator intensively.
 
     Inputs:
         - **name** (str) - The name of the input variable.
@@ -235,15 +231,15 @@ class TensorDump(Primitive):
     Save the Tensor as an npy file in numpy format.
 
     .. warning::
-        - If a large amount of data is stored within a short period, it may lead to memory overflow on the device side.
-          Consider slicing the data to reduce the data scale.
-        - Since data saving is processed asynchronously, when the amount of data is too large or the main process exits
-          too quickly, data loss may occur. You need to actively control the destruction time of the main process,
-          such as using sleep.
+        The parameter input_output will no longer support the value 'all'.
+
+    .. note::
+        In Ascend platform with graph mode, the environment variables `MS_DUMP_SLICE_SIZE` and `MS_DUMP_WAIT_TIME`
+        can be set to solve operator execution failure when outputting big tensor or outputting tensor intensively.
 
     Args:
         input_output (str, optional): Used to control Tensordump behavior.
-            Available value is one of ['in', 'out', 'all']. Default value is ``out``.
+            Available value is one of ['in', 'out']. Default value is ``out``.
 
             In case of OpA --> RedistributionOps --> OpB,
             The dump data of OpA's output is not equal to OpB's input (Due to the redistribution operators).
@@ -253,21 +249,19 @@ class TensorDump(Primitive):
             Different requirements of saving dump data can be achieved by configuring parameter input_output:
 
             - If the input_output is 'out', the dump data contains only OpA's output slice.
-            - If the input_output is 'all', the dump data contains both OpA's output slice and OpB's input slice.
             - If the input_output is 'in', the dump data contains only OpB's input slice.
 
-            For input_output is 'all' or 'in', the input slice npy file format is:
-            id_fileName_cNodeID_dumpMode_rankID.npy.
+            For input_output is 'in', the input slice npy file format is:
+            fileName_dumpMode_dtype_id.npy.
 
-            For input_output is 'out' or 'all' the output slice npy file format is:
-            id_fileName.npy.
+            For input_output is 'out', the output slice npy file format is:
+            fileName_dtype_id.npy.
 
-            - id: An auto increment ID.
             - fileName: Value of the parameter file
               (if parameter file_name is a user-specified path, the value of fileName is the last level of the path).
-            - cNodeID: The node ID of the Tensordump node in the step_parallel_end.ir file.
             - dumpMode: Value of the parameter input_output.
-            - rankID: Logical device id.
+            - dtype: The original data type. Data of type bfloat16 stored in the .npy file will be converted to float32.
+            - id: An auto increment ID.
 
     Inputs:
         - **file** (str) - The path of the file to be saved.
@@ -285,7 +279,8 @@ class TensorDump(Primitive):
         >>> import mindspore as ms
         >>> import time
         >>> from mindspore import nn, Tensor, ops
-        >>> ms.set_context(mode=ms.GRAPH_MODE, device_target="Ascend")
+        >>> ms.set_context(mode=ms.GRAPH_MODE)
+        >>> ms.set_device(device_target="Ascend")
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
@@ -305,7 +300,7 @@ class TensorDump(Primitive):
         >>> net = Net()
         >>> out = net(input_x)
         >>> time.sleep(0.5)
-        >>> add = np.load('0_add.npy')
+        >>> add = np.load('add_float32_0.npy')
         >>> print(add)
         [[2. 3. 4. 5.]
          [6. 7. 8. 9.]]
@@ -318,35 +313,34 @@ class TensorDump(Primitive):
         self.add_prim_attr("side_effect_io", True)
         self.add_prim_attr("channel_name", "ms_tensor_dump")
 
+    def _save_file(self, file, data):
+        file = Path(file)
+        if file.exists():
+            file.chmod(stat.S_IWUSR)
+        np.save(file, data)
+        file.chmod(stat.S_IRUSR)
+
     def __call__(self, file, input_x):
         validator.check_value_type('file', file, [str], self.__class__.__name__)
         if not file:
             raise ValueError("For 'TensorDump', the input argument[file] cannot be an empty string.")
         validator.check_value_type('input_x', input_x, [Tensor], self.__class__.__name__)
-        global TENSORDUMP_ID
-        npy_suffix = ".npy"
-        directory, filename = os.path.split(file)
-        if directory and not os.path.exists(directory):
-            os.makedirs(directory, mode=0o700, exist_ok=True)
-        new_filename = f"{TENSORDUMP_ID}_{filename}"
-        new_file = os.path.join(directory, new_filename)
-        if not new_file.endswith(npy_suffix):
-            new_file += npy_suffix
-        if os.path.exists(new_file):
-            os.chmod(new_file, stat.S_IWUSR)
-        np.save(new_file, input_x.asnumpy())
-        os.chmod(new_file, stat.S_IRUSR)
-        TENSORDUMP_ID += 1
+
+        dtype = input_x.dtype
+        file = _tensordump_process_file(file, str(dtype))
+        if not file:
+            return
+        if dtype == mstype.bfloat16:
+            input_x = P.Cast()(input_x, mstype.float32)
+        self._save_file(file, input_x.asnumpy())
 
 
 class HistogramSummary(Primitive):
     """
     This operator will calculate the histogram of a tensor and put it to a summary file with protocol buffer format.
     It must be used with SummaryRecord or SummaryCollector, which specify the directory of the summary file.
-    The summary file can be loaded and shown by MindInsight, see `MindInsight documents <https://www.mindspore.cn/
-    mindinsight/docs/en/master/index.html>`_ for details.
-    In Ascend platform with graph mode, can set environment variables `MS_DUMP_SLICE_SIZE` and `MS_DUMP_WAIT_TIME`
-    to solve operator execution failure when calling this operator intensively.
+    In Ascend platform with graph mode, the environment variables `MS_DUMP_SLICE_SIZE` and `MS_DUMP_WAIT_TIME`
+    can be set to solve operator execution failure when calling this operator intensively.
 
     Inputs:
         - **name** (str) - The name of the input variable.
@@ -398,7 +392,7 @@ class HistogramSummary(Primitive):
         _cache_summary_data(self.name, args[0], args[1])
 
 
-class InsertGradientOf(PrimitiveWithInfer):
+class InsertGradientOf(Primitive):
     """
     Attaches callback to the graph node that will be invoked on the node's gradient.
 
@@ -464,11 +458,106 @@ class InsertGradientOf(PrimitiveWithInfer):
         self.add_prim_attr('side_effect_backprop', True)
         self.f = f
 
-    def infer_shape(self, x_shape):
-        return x_shape
 
-    def infer_dtype(self, x_type):
-        return x_type
+class Morph(PrimitiveWithInfer):
+    """
+    The `Morph` Primitive is used to encapsulate a user-defined function `fn`, allowing it to be used as a custom
+    Primitive.
+    The primary application scenario of the `Morph` Primitive is in the auto-parallel case after `GRAPH_MODE` mode,
+    where collective communication operators are used within the user-defined `fn` to implement custom parallel
+    computation logic, especially in scenarios where `fn` involves dynamic shapes.
+    When the `Morph` Primitive is applied to inputs, it is actually the encapsulated user-defined function `fn` that is
+    applied to the inputs.
+    The main difference between the `Morph` Primitive and :func:`mindspore.ops.Custom` is that the former is expanded
+    and replaced by the user-defined `fn` before automatic differentiation, so there is no need to implement a backward
+    function.
+
+    .. note::
+        - This primitive is only supported in GRAPH_MODE.
+        - `fn` must satisfy the syntax constraints of the graph mode.
+        - Users do not need to implement a custom backward function.
+        - `vararg`, `kwarg`, `kwonlyargs` and free variables are not supported in user-defined function.
+
+    Args:
+        fn (Function): Mindspore's function, user-defined function.
+        infer_shape (Function): Mindspore's function, user-defined infer_shape function.
+        infer_dtype (Function): Mindspore's function, user-defined infer_dtype function.
+
+    Inputs:
+        The inputs of user-defined `fn`.
+
+    Outputs:
+        The outputs of user-defined `fn`.
+
+    Raises:
+        RuntimeError: if not used in GRAPH_MODE.
+
+    Examples:
+        >>> import numpy as np
+        >>> import mindspore as ms
+        >>> from mindspore import context, nn, ops, Tensor, Parameter
+        >>>
+        >>> np_weight0 = np.array([1.0, 2.0, 3.0])
+        >>> np_weight1 = np.array([4.0, 5.0, 6.0])
+        >>> np_input_x = np.array([7.0, 8.0, 9.0])
+        >>>
+        >>> def infer_dtype(args):
+        ...     return args
+        >>>
+        >>> def infer_shape(args):
+        ...     return args
+        >>>
+        >>> def mul_by(*args):
+        ...     def inner(x):
+        ...         return args[0] * x
+        ...     return inner
+        >>>
+        >>> NUMBER_100 = 100
+        >>> class MorphNet(nn.Cell):
+        ...     def __init__(self):
+        ...         super(MorphNet, self).__init__()
+        ...         self.weight0 = Parameter(Tensor(np_weight0, ms.float32), name="weight0")
+        ...         self.weight1 = Parameter(Tensor(np_weight1, ms.float32), name="weight1")
+        ...         self.mul_by_100 = ops.Morph(mul_by(NUMBER_100), infer_shape, infer_dtype)
+        ...     def construct(self, x):
+        ...         a = x * self.weight0
+        ...         b = self.mul_by_100(a)
+        ...         out = b * self.weight1
+        ...         return out
+        >>>
+        >>> context.set_context(mode=context.GRAPH_MODE)
+        >>> input_x = Tensor(np_input_x, ms.float32)
+        >>> net = MorphNet()
+        >>> grad_op = ops.GradOperation(get_all=True, get_by_list=True)
+        >>> grad_net = grad_op(net, net.trainable_params())
+        >>> bwd_out = grad_net(input_x)
+        >>> x_grad = bwd_out[0][0].asnumpy()
+        >>> weight0_grad = bwd_out[1][0].asnumpy()
+        >>> weight1_grad = bwd_out[1][1].asnumpy()
+        >>> print("x_grad", x_grad)
+        >>> print("weight0_grad", weight0_grad)
+        >>> print("weight1_grad", weight1_grad)
+        x_grad [ 400. 1000. 1800.]
+        weight0_grad [2800. 4000. 5400.]
+        weight1_grad [ 700. 1600. 2700.]
+    """
+    @prim_attr_register
+    def __init__(self, fn, infer_shape, infer_dtype):
+        self.add_prim_attr('side_effect_backprop', True)
+        self.add_prim_attr('side_effect_mem', True)
+        self.add_prim_attr('side_effect_io', True)
+        self.add_prim_attr('__metamorphosis__', fn)
+        self._infer_shape = infer_shape
+        self._infer_dtype = infer_dtype
+
+    def infer_shape(self, *args):
+        return self._infer_shape(*args)
+
+    def infer_dtype(self, *args):
+        return self._infer_dtype(*args)
+
+    def __call__(self, *args):
+        raise RuntimeError("Morph is only supported in GRAPH_MODE.")
 
 
 class HookBackward(PrimitiveWithInfer):
@@ -532,8 +621,7 @@ class HookBackward(PrimitiveWithInfer):
     def __init__(self, hook_fn, cell_id=""):
         """Initialize HookBackward."""
         super(HookBackward, self).__init__(self.__class__.__name__)
-        if not check_hook_fn("HookBackward", hook_fn):
-            return
+        check_hook_fn(hook_fn)
         if cell_id != "":
             logger.warning(f"The args 'cell_id' of HookBackward will be removed in a future version. If the value of "
                            f"'cell_id' is set, the hook function will not work.")
@@ -605,6 +693,9 @@ class Print(Primitive):
         self.add_prim_attr("side_effect_io", True)
 
     def __call__(self, *args):
+        # Add for jit context.
+        if jit_context() and jit_context().compiled:
+            return
         for arg in args:
             if isinstance(arg, Parameter):
                 print(Tensor_.__repr__(arg))
@@ -612,6 +703,9 @@ class Print(Primitive):
                 print(arg.__repr__())
             else:
                 print(arg)
+        # Add for jit context.
+        if jit_context():
+            jit_context().run_op(self, None, *args)
 
 
 class Assert(PrimitiveWithInfer):

mindspore/ops/operations/inner_ops.py

@@ -87,7 +87,7 @@ class NoRepeatNGram(Primitive):
     Because 3 consecutive words [2, 3, 2] do not appear twice in the word sequence.
 
     Args:
-        ngram_size (int): Size of n-grams, must be greater than 0. Default: ``1`` .
+        ngram_size (int, optional): Size of n-grams, must be greater than 0. Default: ``1`` .
 
     Inputs:
         - **state_seq** (Tensor) - n-gram word series, a 3-D tensor with shape: :math:`(batch\_size, beam\_width, m)`.
@@ -302,8 +302,8 @@ class FusedWeightScaleApplyMomentum(PrimitiveWithInfer):
           Default: ``0.0`` .
         - **loss_scale** (Tensor) - The loss scale value, must be a scalar tensor with float data type.
           Default: ``1.0`` .
-        - **variable** (Parameter) - Weights to be updated. data type must be float.
-        - **accumulation** (Parameter) - Accumulated gradient value by moment weight.
+        - **variable** (Union[Parameter, Tensor]) - Weights to be updated. data type must be float.
+        - **accumulation** (Union[Parameter, Tensor]) - Accumulated gradient value by moment weight.
           Has the same data type with `variable`.
         - **learning_rate** (Union[Number, Tensor]) - The learning rate value, must be a float number or
           a scalar tensor with float data type.
@@ -425,7 +425,8 @@ class FusedCastAdamWeightDecay(PrimitiveWithInfer):
         ...     def construct(self, lr, beta1, beta2, epsilon, decay, grad, norm):
         ...         out = self.opt(self.var, self.m, self.v, lr, beta1, beta2, epsilon, decay, grad, norm)
         ...         return out
-        >>> ms.set_context(mode=ms.GRAPH_MODE, device_target="CPU")
+        >>> ms.set_context(mode=ms.GRAPH_MODE)
+        >>> ms.set_device(device_target="CPU")
         >>> net = Net()
         >>> gradient = Tensor(np.ones([2, 2]), mstype.float16)
         >>> output = net(0.001, 0.9, 0.999, 1e-8, 0.0, gradient, 1.0)
@@ -560,7 +561,8 @@ class FusedAdaFactor(PrimitiveWithInfer):
         ...         out = self.opt(epsilon, clip_threshold, beta1, beta2, weight_decay, lr, grad, self.param,
         ...                        self.exp_avg, self.exp_avg_sq_row, self.exp_avg_sq_col, self.exp_avg_sq)
         ...         return out
-        >>> ms.set_context(mode=ms.GRAPH_MODE, device_target="CPU")
+        >>> ms.set_context(mode=ms.GRAPH_MODE)
+        >>> ms.set_device(device_target="CPU")
         >>> net = Net()
         >>> gradient = Tensor(np.ones(param_shape), mstype.float32)
         >>> output = net((1e-30, 1e-3), 1.0, 0.9, 0.8, 1e-2, 0.03, gradient)

mindspore/ops/operations/linalg_ops.py

@@ -19,63 +19,7 @@ from __future__ import absolute_import
 from mindspore import _checkparam as Validator
 from mindspore.ops.primitive import Primitive
 from mindspore.ops.primitive import prim_attr_register
-from ..auto_generate import Geqrf
-
-
-class Svd(Primitive):
-    """
-    Computes the singular value decompositions of one or more matrices.
-
-    Refer to :func:`mindspore.ops.svd` for more details.
-
-    Args:
-        full_matrices (bool, optional): If ``True`` , compute full-sized :math:`U` and :math:`V`. If ``False``,
-                                        compute only the leading P singular vectors, with P is the minimum of M and N.
-                                        Default: ``False`` .
-        compute_uv (bool, optional): If ``True`` , compute the left and right singular vectors.
-                                     If ``False`` , compute only the singular values. Default: ``True`` .
-
-    Inputs:
-        - **input** (Tensor) - Tensor of the matrices to be decomposed. The shape should be :math:`(*, M, N)`,
-          the supported dtype are float32 and float64.
-
-    Outputs:
-        - **s**  (Tensor) - Singular values. The shape is :math:`(*, P)`.
-        - **u**  (Tensor) - Left singular vectors. If `compute_uv` is ``False`` , u will be zero value.
-          The shape is :math:`(*, M, P)`. If `full_matrices` is ``True`` , the shape will be :math:`(*, M, M)`.
-        - **v**  (Tensor) - Right singular vectors. If `compute_uv` is ``False`` , v will be zero value.
-          The shape is :math:`(*, N, P)`. If `full_matrices` is ``True`` , the shape will be :math:`(*, N, N)`.
-
-    Supported Platforms:
-        ``GPU`` ``CPU``
-
-    Examples:
-        >>> import numpy as np
-        >>> from mindspore import Tensor, set_context
-        >>> from mindspore import ops
-        >>> set_context(device_target="CPU")
-        >>> svd = ops.Svd(full_matrices=True, compute_uv=True)
-        >>> a = Tensor(np.array([[1, 2], [-4, -5], [2, 1]]).astype(np.float32))
-        >>> s, u, v = svd(a)
-        >>> print(s)
-        [7.0652843 1.040081 ]
-        >>> print(u)
-        [[ 0.30821905 -0.48819482 0.81649697]
-         [-0.90613353  0.11070572 0.40824813]
-         [ 0.2896955   0.8656849  0.4082479 ]]
-        >>> print(v)
-        [[ 0.63863593 0.769509  ]
-         [ 0.769509  -0.63863593]]
-    """
-
-    @prim_attr_register
-    def __init__(self, full_matrices=False, compute_uv=True):
-        super().__init__(name="Svd")
-        self.init_prim_io_names(inputs=['a'], outputs=['s', 'u', 'v'])
-        self.full_matrices = Validator.check_value_type("full_matrices", full_matrices, [bool], self.name)
-        self.compute_uv = Validator.check_value_type("compute_uv", compute_uv, [bool], self.name)
-        self.add_prim_attr('full_matrices', self.full_matrices)
-        self.add_prim_attr('compute_uv', self.compute_uv)
+from ..auto_generate import Geqrf, Svd
 
 
 class Eigh(Primitive):

mindspore/ops/operations/manually_defined/_inner.py

@@ -66,7 +66,7 @@ class TensorReport(Primitive):
     @prim_attr_register
     def __init__(self):
         """Initialize TensorReport"""
-        self.add_prim_attr("side_effect_io", True)
+        self.add_prim_attr("side_effect_mem", True)
         self.add_prim_attr("channel_name", "ms_tensor_report")
 
     def __call__(self, file, input_x):