mindspore 2.2.14__cp39-cp39-win_amd64.whl → 2.4.0__cp39-cp39-win_amd64.whl

mindspore/ops/composite/base.py

@@ -1,6 +1,6 @@
 # This is the Python adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
 #
-# Copyright 2020-2023 Huawei Technologies Co., Ltd
+# Copyright 2020-2024 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.
@@ -30,7 +30,8 @@ from mindspore._c_expression import GradOperation_, HyperMap_, Map_, MultitypeFu
     SequenceSliceGetItem_, ListSliceSetItem_, VmapOperation_, TaylorOperation_, ListPop_, \
     ListClear_, ListReverse_, ListExtend_, DictClear_, DictHasKey_, DictUpdate_, DictFromKeys_, \
     ZerosLike_, TensorIndexGetitem_, TensorIndexSetitem_, ListAdd_, DictSetItem_, \
-    HandleBoolTensor_, HandleEmptySlice_, PreSetitemByTuple_, HandleScalarTensorIndex_
+    HandleBoolTensor_, PreSetitemByTuple_, StarredGetItem_, \
+    StarredUnpack_, StarredUnpackMerge_, IterConverter_, HasNext_, Next_, MSContext
 from mindspore.common import dtype as mstype
 from mindspore.common.api import jit, _pynative_executor, _wrap_func
 from mindspore.common.api import _add_flags, _core
@@ -39,7 +40,7 @@ from mindspore.ops import signature as sig
 
 __all__ = [TupleAdd_, ListAdd_, UnpackCall_, TupleGetItemTensor_, SequenceSliceGetItem_,
            ListSliceSetItem_, ZerosLike_, TensorIndexGetitem_, TensorIndexSetitem_,
-           HandleBoolTensor_, HandleEmptySlice_, PreSetitemByTuple_, HandleScalarTensorIndex_]
+           HandleBoolTensor_, PreSetitemByTuple_]
 
 
 def add_flags(fn=None, **flags):
@@ -201,7 +202,7 @@ class GradOperation(GradOperation_):
             If sens_param is ``False`` , a 'ones_like(outputs)' sensitivity will be attached automatically.
             Default: ``False`` .
             If the sensor_param is ``True`` , a sensitivity (gradient with respect to output) needs to be transferred
-            through the location parameter or key-value pair parameter. If the value is transferred through
+            through the positional parameter or key-value pair parameter. If the value is transferred through
             the key-value pair parameter, the key must be sens.
 
     Returns:
@@ -345,9 +346,11 @@ class GradOperation(GradOperation_):
         self.grad_position = (0,)
 
     def __call__(self, fn, weights=None):
-        weights_id = _get_grad_weights_id(weights)
-        if self.grad_fn is not None and self.fn == fn and self.weights_id == weights_id:
-            return self.grad_fn
+        weights_id = ''
+        if context.get_context("mode") == context.GRAPH_MODE:
+            weights_id = _get_grad_weights_id(weights)
+            if self.grad_fn is not None and self.fn == fn and self.weights_id == weights_id:
+                return self.grad_fn
         grad_ = GradOperation(self.get_all, self.get_by_list, self.sens_param)
         # If calling Grad in GRAPH_MODE or calling Grad in functions decorated with 'jit', do grad in GRAPH_MODE
         # If calling Grad in pure PYNATIVE_MODE do grad in PYNATIVE_MODE
@@ -373,12 +376,12 @@ class GradOperation(GradOperation_):
 
             @_wrap_func
             def after_grad(*args, **kwargs):
-                self._pynative_forward_run(fn, grad_, weights, args, kwargs)
-                _pynative_executor.grad(fn, grad_, weights, self.grad_position, *args, **kwargs)
-                out = _pynative_executor()
+                run_args = self._pynative_forward_run(fn, grad_, weights, *args, **kwargs)
+                out = _pynative_executor.grad(fn, grad_, weights, self.grad_position, *run_args)
                 out = _grads_divided_by_device_num_if_recomputation(out)
                 return out
         else:
+            MSContext.get_instance()._set_not_convert_jit(True)
             grad_.pynative_ = True
             if not _pynative_executor.enable_grad():
                 raise RuntimeError("In no_grad context, you can not calculate gradient")
@@ -395,27 +398,39 @@ class GradOperation(GradOperation_):
         self.weights_id = weights_id
         return self.grad_fn
 
-    def _pynative_forward_run(self, fn, grad, weights, args, kwargs):
-        """ Pynative forward run to build grad graph. """
-        new_kwargs = kwargs
+    def _pynative_forward_run(self, fn, grad, weights, *args, **kwargs):
+        """ PyNative forward run to build grad graph. """
+        sens = None
         if self.sens_param:
-            if 'sens' not in kwargs.keys():
-                args = args[:-1]
+            if 'sens' in kwargs.keys():
+                sens = kwargs.pop('sens')
             else:
-                new_kwargs = kwargs.copy()
-                new_kwargs.pop('sens')
+                # default use args last elem as sens
+                sens = args[-1]
+                args = args[:-1]
+        run_args = args
+        if kwargs:
+            run_args = args + tuple(kwargs.values())
+
+        # check run exclude sens
         if isinstance(fn, (FunctionType, MethodType)):
-            if not _pynative_executor.check_run(grad, fn, weights, None, *args, **new_kwargs):
+            if not _pynative_executor.check_run(grad, fn, weights, None, *run_args):
                 _pynative_executor.set_grad_flag(True)
-                _pynative_executor.new_graph(fn, *args, **new_kwargs)
-                output = fn(*args, **new_kwargs)
-                _pynative_executor.end_graph(fn, output, *args, **new_kwargs)
+                _pynative_executor.new_graph(fn, *args, **kwargs)
+                output = fn(*args, **kwargs)
+                _pynative_executor.end_graph(fn, output, *args, **kwargs)
         else:
-            # Check if fn have run already
-            if not _pynative_executor.check_run(grad, fn, weights, None, *args, **new_kwargs):
-                fn.set_grad()
-                fn(*args, **new_kwargs)
-                fn.set_grad(False)
+            # Check if fn has run already
+            if not _pynative_executor.check_run(grad, fn, weights, None, *run_args):
+                requires_grad = fn.requires_grad
+                fn.requires_grad = True
+                fn(*args, **kwargs)
+                fn.requires_grad = requires_grad
+
+        # If it has sens, keep sens as the last element
+        if sens is not None:
+            run_args += (sens,) if sens is not isinstance(run_args, tuple) else sens
+        return run_args
 
 
 class _TaylorOperation(TaylorOperation_):
@@ -552,13 +567,15 @@ class _Grad(GradOperation_):
         self.weights_id = None
 
     def __call__(self, fn, weights=None, grad_position=0):
-        weights_id = _get_grad_weights_id(weights)
-        if self.grad_fn is not None and self.fn == fn and self.grad_position == grad_position and \
-                self.weights_id == weights_id:
-            return self.grad_fn
+        weights_id = ''
+        if context.get_context("mode") == context.GRAPH_MODE:
+            weights_id = _get_grad_weights_id(weights)
+            if self.grad_fn is not None and self.fn == fn and self.grad_position == grad_position and \
+                    self.weights_id == weights_id:
+                return self.grad_fn
 
-        def aux_fn(*args):
-            outputs = fn(*args)
+        def aux_fn(*args, **kwargs):
+            outputs = fn(*args, **kwargs)
             if not isinstance(outputs, tuple) or len(outputs) < 2:
                 raise ValueError("When has_aux is True, origin fn requires more than one outputs.")
             res = (outputs[0],)
@@ -597,9 +614,8 @@ class _Grad(GradOperation_):
 
             @_wrap_func
             def after_grad(*args, **kwargs):
-                res = self._pynative_forward_run(fn, grad_, weights, args, kwargs)
-                _pynative_executor.grad(fn, grad_, weights, grad_position, *args, **kwargs)
-                out = _pynative_executor()
+                run_args, res = self._pynative_forward_run(fn, grad_, weights, *args, **kwargs)
+                out = _pynative_executor.grad(fn, grad_, weights, grad_position, *run_args)
                 out = _grads_divided_by_device_num_if_recomputation(out)
                 if self.return_ids and out:
                     out = _combine_with_ids(grad_position, weights, out)
@@ -609,6 +625,7 @@ class _Grad(GradOperation_):
                     return out, res[1:]
                 return out
         else:
+            MSContext.get_instance()._set_not_convert_jit(True)
             if not _pynative_executor.enable_grad():
                 raise RuntimeError("In no_grad context, you can not calculate gradient")
             grad_.pynative_ = True
@@ -633,33 +650,49 @@ class _Grad(GradOperation_):
         self.weights_id = weights_id
         return self.grad_fn
 
-    def _pynative_forward_run(self, fn, grad, weights, args, kwargs):
-        """ Pynative forward runs to build grad graph. """
-        new_kwargs = kwargs
-        outputs = ()
+    def _pynative_forward_run(self, fn, grad, weights, *args, **kwargs):
+        """ PyNative forward runs to build grad graph. """
+        sens = None
         if self.sens_param:
             if 'sens' in kwargs.keys():
-                new_kwargs = kwargs.copy()
-                new_kwargs.pop('sens')
+                sens = kwargs.pop('sens')
             else:
+                # default use args last elem as sens
+                sens = args[-1]
                 args = args[:-1]
+        run_args = args
+        if kwargs:
+            run_args = args + tuple(kwargs.values())
+
+        # check run exclude sens
+        outputs = ()
+        run_forward = False
         if isinstance(fn, (FunctionType, MethodType)):
-            if not _pynative_executor.check_run(grad, fn, weights, self.grad_position, *args, **new_kwargs):
+            if not _pynative_executor.check_run(grad, fn, weights, self.grad_position, *run_args):
                 _pynative_executor.set_grad_flag(True)
-                _pynative_executor.new_graph(fn, *args, **new_kwargs)
-                outputs = fn(*args, **new_kwargs)
-                _pynative_executor.end_graph(fn, outputs, *args, **new_kwargs)
-                return outputs
+                _pynative_executor.new_graph(fn, *args, **kwargs)
+                outputs = fn(*args, **kwargs)
+                _pynative_executor.end_graph(fn, outputs, *args, **kwargs)
+                run_forward = True
         else:
             # Check if fn has run already.
-            if not _pynative_executor.check_run(grad, fn, weights, self.grad_position, *args, **new_kwargs):
-                fn.set_grad()
-                outputs = fn(*args, **new_kwargs)
-                fn.set_grad(False)
-                return outputs
+            if not _pynative_executor.check_run(grad, fn, weights, self.grad_position, *run_args):
+                requires_grad = fn.requires_grad
+                fn.requires_grad = True
+                outputs = fn(*args, **kwargs)
+                fn.requires_grad = requires_grad
+                run_forward = True
+        # If it has sens, keep sens as the last element
+        if sens is not None:
+            run_args += (sens,) if sens is not isinstance(run_args, tuple) else sens
+
+        # Normal run grad
+        if run_forward:
+            return run_args, outputs
+
         if (self.get_value or self.has_aux) and not outputs:
-            outputs = fn(*args, **new_kwargs)
-        return outputs
+            outputs = fn(*args, **kwargs)
+        return run_args, outputs
 
 
 class _Vmap(VmapOperation_):
@@ -714,9 +747,8 @@ class MultitypeFuncGraph(MultitypeFuncGraph_):
         >>> # `add` is a metagraph object which will add two objects according to
         >>> # input type using ".register" decorator.
         >>> from mindspore import Tensor
-        >>> from mindspore import ops
         >>> from mindspore import dtype as mstype
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>>
         >>> tensor_add = ops.Add()
         >>> add = ops.MultitypeFuncGraph('add')
@@ -738,11 +770,14 @@ class MultitypeFuncGraph(MultitypeFuncGraph_):
         """Initialize MultitypeFuncGraph."""
         MultitypeFuncGraph_.__init__(self, name)
         self.entries = list()
+        self.default_func = None
         if read_value:
             self.set_signatures((
                 sig.make_sig('args', sig.sig_rw.RW_READ, sig.sig_kind.KIND_VAR_POSITIONAL),))
 
     def __call__(self, *args):
+        if callable(self.default_func):
+            return self.default_func(*args)
         for arg in args:
             if isinstance(arg, np.ndarray):
                 raise TypeError("For 'MultitypeFuncGraph', the input can not be numpy.ndarray")
@@ -788,6 +823,13 @@ class MultitypeFuncGraph(MultitypeFuncGraph_):
 
         return deco
 
+    def register_default(self):
+        def deco(fn):
+            self.default_func = fn
+            return fn
+
+        return deco
+
     # pylint: disable=missing-docstring
     def set_doc_url(self, doc_url):
         self.set_doc_url_(doc_url)
@@ -798,17 +840,19 @@ class MultitypeFuncGraph(MultitypeFuncGraph_):
 
 class HyperMap(HyperMap_):
     """
-    Hypermap will apply the set operation to input sequences.
+    HyperMap will apply the set operation to input sequences.
 
     Apply the operations to every element of the sequence or nested sequence. Different
-    from `mindspore.ops.Map`, the `HyperMap` supports to apply on nested structure.
+    from `mindspore.ops.Map`, the `HyperMap` supports to apply on nested structure. The
+    `HyperMap` also supports dynamic sequences as input, but it does not extend this
+    support to nested dynamic sequences.
 
     Args:
-        ops (Union[MultitypeFuncGraph, None]): `ops` is the operation to apply. If `ops` is `None`,
+        ops (Union[MultitypeFuncGraph, None], optional): `ops` is the operation to apply. If `ops` is `None`,
             the operations should be put in the first input of the instance. Default is None.
-        reverse (bool): The optimizer needs to be inverted in some scenarios to improve parallel performance,
-          general users please ignore. `reverse` is the flag to decide if apply the operation reversely.
-          Only supported in graph mode. Default is False.
+        reverse (bool, optional): The optimizer needs to be inverted in some scenarios to improve parallel
+            performance, general users please ignore. `reverse` is the flag to decide if apply
+            the operation reversely. Only supported in graph mode. Default is False.
 
     Inputs:
         - **args** (Tuple[sequence]) -
@@ -822,10 +866,10 @@ class HyperMap(HyperMap_):
 
     Outputs:
         Sequence or nested sequence, the sequence of output after applying the function.
-        e.g. `operation(args[0][i], args[1][i])`.
+        e.g. `operation(args[0][i], args[1][i])`, `operation` is the function assigned by `ops`.
 
     Raises:
-        TypeError: If `ops` is neither MultitypeFuncGraph nor None.
+        TypeError: If `ops` is neither :class:`mindspore.ops.MultitypeFuncGraph` nor None.
         TypeError: If `args` is not a Tuple.
 
     Supported Platforms:
@@ -887,15 +931,15 @@ class Map(Map_):
         ops (Union[MultitypeFuncGraph, None]): `ops` is the operation to apply. If `ops` is `None`,
             the operations should be put in the first input of the instance. Default: ``None`` .
         reverse (bool): The optimizer needs to be inverted in some scenarios to improve parallel performance,
-          general users please ignore. `Reverse` is the flag to decide if apply the operation reversely.
-          Only supported in graph mode. Default is ``False`` .
+            general users please ignore. `Reverse` is the flag to decide if apply the operation reversely.
+            Only supported in graph mode. Default is ``False`` .
 
     Inputs:
         - **args** (Tuple[sequence]) - If `ops` is not `None`, all the inputs should be the same length sequences,
           and each row of the sequences. e.g. If the length of args is 2, and for `i` in length of each sequence
           `(args[0][i], args[1][i])` will be the input of the operation.
 
-          If `ops` is `None`, the first input is the operation, and the other is inputs.
+          If `ops` is `None`, the first input is the operation, and the other is the sequence.
 
     Outputs:
         Sequence, the sequence of output after applying the ops function. e.g. `ops(args[0][i], args[1][i])`.
@@ -951,6 +995,7 @@ class _ListAppend(ListAppend_):
     Args:
         name (str): The name of the metafuncgraph object.
     """
+
     # `__init__` method removed entirely
     def __call__(self, *args):
         pass
@@ -1181,3 +1226,93 @@ class _ZipOperation(ZipOperation_):
 
 zip_operation = _ZipOperation('zip_operation')
 """`zip_operation` will generate a tuple of zip iterations of inputs."""
+
+
+class _StarredGetItem(StarredGetItem_):
+    """Generates a list of starred get_item for inputs."""
+
+    def __init__(self, name):
+        """Initialize _StarredGetItem."""
+        StarredGetItem_.__init__(self, name)
+
+    def __call__(self, *args):
+        pass
+
+
+starred_get_item = _StarredGetItem('starred_get_item')
+"""`starred_get_item` will generate a list of starred get_item for inputs."""
+
+
+class _StarredUnpack(StarredUnpack_):
+    """Generates a tuple of starred unpack for inputs."""
+
+    def __init__(self, name):
+        """Initialize _StarredUnpack."""
+        StarredUnpack_.__init__(self, name)
+
+    def __call__(self, *args):
+        pass
+
+
+starred_unpack = _StarredUnpack('starred_unpack')
+"""`starred_unpack` will generate a tuple of starred unpack for inputs."""
+
+
+class _StarredUnpackMerge(StarredUnpackMerge_):
+    """Generates a tuple of starred unpack merge for inputs."""
+
+    def __init__(self, name):
+        """Initialize _StarredUnpackMerge."""
+        StarredUnpackMerge_.__init__(self, name)
+
+    def __call__(self, *args):
+        pass
+
+
+starred_unpack_merge = _StarredUnpackMerge('starred_unpack_merge')
+"""`starred_unpack_merge` will generate a tuple of starred unpack merge for inputs."""
+
+
+class _IterConverter(IterConverter_):
+    """Convert input to interable object"""
+
+    def __init__(self, name):
+        """Initialize _IterConverter."""
+        IterConverter_.__init__(self, name)
+
+    def __call__(self, *args):
+        pass
+
+
+iter_converter = _IterConverter('iter_converter')
+"""`iter_converter` will convert input to ietrable object"""
+
+
+class _HasNext(HasNext_):
+    """Check whether the input has next value"""
+
+    def __init__(self, name):
+        """Initialize _HasNext."""
+        HasNext_.__init__(self, name)
+
+    def __call__(self, *args):
+        pass
+
+
+ms_hasnext = _HasNext('has_next')
+"""`ms_hasnext` will check whether the input has next value"""
+
+
+class _Next(Next_):
+    """Get next element and res elements for input"""
+
+    def __init__(self, name):
+        """Initialize _Next."""
+        Next_.__init__(self, name)
+
+    def __call__(self, *args):
+        pass
+
+
+ms_next = _Next('next')
+"""`ms_next` will get next element and res elements for input"""

mindspore/ops/composite/math_ops.py

@@ -15,7 +15,7 @@
 """math Operations."""
 import mindspore.ops as ops
 from mindspore.ops import functional as F
-from mindspore.ops.function.math_func import cummin as cummin_
+from mindspore.ops.function.math_func import cummin
 from mindspore.ops._primitive_cache import _get_cache_prim
 
 
@@ -89,14 +89,15 @@ def mm(input, mat2):
     :math:`(m \times p)` Tensor, `out` will be a :math:`(n \times p)` Tensor.
 
     Note:
-        This function cannot support broadcasting.
-        Refer to :func:`mindspore.ops.matmul` instead if you need a broadcastable function.
+        - This function cannot support broadcasting.
+          Refer to :func:`mindspore.ops.matmul` instead if you need a broadcastable function.
+        - On Ascend, float64 doesn't be supported.
 
     Args:
         input (Tensor): The first matrix of matrix multiplication.
-          The last dimension of `input` must be the same size as the first dimension of `mat2`.
+            The last dimension of `input` must be the same size as the first dimension of `mat2`.
         mat2 (Tensor): The second matrix of matrix multiplication.
-          The last dimension of `input` must be the same size as the first dimension of `mat2`.
+            The last dimension of `input` must be the same size as the first dimension of `mat2`.
 
     Returns:
         Tensor or scalar, the matrix product of the inputs.
@@ -104,17 +105,17 @@ def mm(input, mat2):
     Raises:
         ValueError: If the last dimension of `input` is not the same size as the
             second-to-last dimension of `mat2`.
-        ValueError: If `input` or `mat2` is not a matrix.
+        ValueError: If `input` or `mat2` is not a Tensor.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
         >>> import mindspore as ms
-        >>> import mindspore.ops as ops
+        >>> from mindspore import ops
         >>> import numpy as np
-        >>> x1 = ms.Tensor(np.random.rand(2, 3))
-        >>> x2 = ms.Tensor(np.random.rand(3, 4))
+        >>> x1 = ms.Tensor(np.random.rand(2, 3), ms.float32)
+        >>> x2 = ms.Tensor(np.random.rand(3, 4), ms.float32)
         >>> out = ops.mm(x1, x2)
         >>> print(out.shape)
         (2, 4)
@@ -122,43 +123,3 @@ def mm(input, mat2):
     _matmul = _get_cache_prim(ops.MatMul)()
     out = _matmul(input, mat2)
     return out
-
-
-def cummin(x, axis):
-    r"""
-    Returns a tuple (values,indices) where 'values' is the cumulative minimum value of input Tensor `x`
-    along the dimension `axis`, and `indices` is the index location of each minimum value.
-
-    .. math::
-        \begin{array}{ll} \\
-            y{i} = min(x{1}, x{2}, ... , x{i})
-        \end{array}
-
-    Args:
-        x (Tensor): The input Tensor, rank of `x` > 0.
-        axis (int): The dimension to do the operation over. The value of `axis` must be in the range
-            `[-x.ndim, x.ndim - 1]`.
-
-    Returns:
-        tuple [Tensor], tuple of 2 Tensors, containing the cumulative minimum of elements and the index,
-        The shape of each output tensor is the same as input `x`.
-
-    Raises:
-        TypeError: If `x` is not a Tensor.
-        TypeError: If `axis` is not an int.
-        ValueError: If `axis` is out the range of `[-x.ndim, x.ndim - 1]`.
-
-    Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
-
-    Examples:
-        >>> from mindspore import Tensor, ops
-        >>> import mindspore
-        >>> a = Tensor([-0.2284, -0.6628,  0.0975,  0.2680, -1.3298, -0.4220], mindspore.float32)
-        >>> output = ops.cummin(a, axis=0)
-        >>> print(output[0])
-        [-0.2284 -0.6628 -0.6628 -0.6628 -1.3298 -1.3298]
-        >>> print(output[1])
-        [0 1 1 1 4 4]
-    """
-    return cummin_(x, axis)