mindspore 1.10.0__cp38-cp38-win_amd64.whl → 2.0.0rc1__cp38-cp38-win_amd64.whl

mindspore/ops/operations/spectral_ops.py

@@ -0,0 +1,107 @@
+# Copyright 2022 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.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+
+"""Spectral operators."""
+from mindspore import _checkparam as validator
+from mindspore.common import dtype as mstype
+from mindspore.ops.primitive import Primitive, prim_attr_register
+
+
+class BartlettWindow(Primitive):
+    r"""
+    Bartlett window function.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Refer to :func:`mindspore.ops.bartlett_window` for more details.
+
+    Args:
+        periodic (bool, optional): If True, returns a window to be used as periodic function.
+          If False, return a symmetric window. Default: True.
+        dtype (mindspore.dtype, optional): The desired datatype of returned tensor.
+            Only float16, float32 and float64 are allowed. Default: mstype.float32.
+
+    Inputs:
+        - **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].
+
+    Outputs:
+        A 1-D tensor of size `window_length` containing the window. Its datatype is set by the attr `dtype`.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> window_length = Tensor(5, mstype.int32)
+        >>> bartlett_window = ops.BartlettWindow(periodic=True, dtype=mstype.float32)
+        >>> output = bartlett_window(window_length)
+        >>> print(output)
+        [0.  0.4 0.8 0.8 0.4]
+    """
+
+    @prim_attr_register
+    def __init__(self, periodic=True, dtype=mstype.float32):
+        """Initialize BartlettWindow"""
+        self.add_prim_attr("max_length", 1000000)
+        validator.check_value_type("periodic", periodic, [bool], self.name)
+        validator.check_value_type("dtype", dtype, [mstype.Type], self.name)
+        valid_values = (mstype.float16, mstype.float32, mstype.float64)
+        validator.check_type_name("dtype", dtype, valid_values, self.name)
+
+
+class BlackmanWindow(Primitive):
+    r"""
+    Blackman window function.
+
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
+
+    Refer to :func:`mindspore.ops.blackman_window` for more details.
+
+    Args:
+        periodic (bool, optional): If True, returns a window to be used as periodic function.
+            If False, return a symmetric window. Default: True.
+        dtype (mindspore.dtype, optional): the desired data type of returned tensor.
+            Only float16, float32 and float64 is allowed. Default: mstype.float32.
+
+    Inputs:
+        - **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].
+
+    Outputs:
+        A 1-D tensor of size `window_length` containing the window. Its datatype is set by the attr `dtype`.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> window_length = Tensor(10, mindspore.int32)
+        >>> blackman_window = ops.BlackmanWindow(periodic = True, dtype = mindspore.float32)
+        >>> output = 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
+          2.0077008e-01  4.0212870e-02]
+    """
+
+    @prim_attr_register
+    def __init__(self, periodic=True, dtype=mstype.float32):
+        """Initialize BlackmanWindow"""
+        self.add_prim_attr("max_length", 1000000)
+        validator.check_value_type("periodic", periodic, [bool], self.name)
+        validator.check_value_type("dtype", dtype, [mstype.Type], self.name)
+        valid_values = (mstype.float16, mstype.float32, mstype.float64)
+        validator.check_type_name("dtype", dtype, valid_values, self.name)

mindspore/ops/primitive.py

@@ -20,10 +20,13 @@ import copy
 from mindspore.common.api import _wrap_func
 from mindspore.log import _LogActionOnce
 from mindspore import context, log as logger
-from mindspore.parallel._utils import _is_in_auto_parallel_mode
+from mindspore.parallel._utils import _is_in_auto_parallel_mode, _is_in_data_parallel_mode, _is_in_hybrid_parallel_mode
+from mindspore.parallel._ps_context import _is_ps_mode, _is_role_sched
 from mindspore.common.parameter import Parameter
-from mindspore._c_expression import Primitive_, real_run_op, prim_type
-from mindspore._checkparam import Validator
+from mindspore.common.api import _pynative_executor
+from mindspore.common._stub_tensor import _convert_stub
+from mindspore._c_expression import Primitive_, prim_type
+from mindspore import _checkparam as Validator
 from mindspore.ops import signature as sig
 
 
@@ -81,6 +84,22 @@ class Primitive(Primitive_):
         self.add_attr(name, value)
         return self
 
+    def set_device(self, device_target):
+        """
+        Set primitive been executed device.
+
+        Args:
+            device_target (str): The target device to run, support "Ascend", "GPU", and "CPU".
+
+        Examples:
+            >>> import mindspore.ops as ops
+            >>> a = ops.Add()
+            >>> a = a.set_device("GPU")
+            >>> print(a.primitive_target)
+            GPU
+        """
+        return self.add_prim_attr("primitive_target", device_target)
+
     def _fill_signature(self, signatures):
         """fills signature."""
         signatures_new = []
@@ -103,8 +122,10 @@ class Primitive(Primitive_):
         flag self.__setattr_flag__ is True.
         """
         cloned = copy.deepcopy(self)
-        init_params = inspect.getfullargspec(cloned.__init__.decorated_func).args[1:]
-        init_args = {}
+        init_params = list()
+        if hasattr(cloned.__init__, 'decorated_func'):
+            init_params = inspect.getfullargspec(cloned.__init__.decorated_func).args[1:]
+        init_args = self.init_attrs
         for name in init_params:
             value = self.attrs[name]
             init_args[name] = value
@@ -387,6 +408,59 @@ class Primitive(Primitive_):
         self.add_prim_attr("recompute", mode)
         return self
 
+    def place(self, role, rank_id):
+        """
+        Set the label for this primitive.
+        This label tells MindSpore compiler on which process this operator should be launched.
+        And each process's identical label consists of input 'role' and 'rank_id'.
+        So by setting different operators with different labels,
+        which will be launched on different processes, users can launch a distributed training job.
+
+        Note:
+            - This method is effective only after
+              "mindspore.communication.init()" is called for dynamic cluster building.
+
+        Args:
+            role (str): The role of the process on which this operator will be launched.
+                        Only 'MS_WORKER' is supported for now.
+            rank_id (int): The rank id of the process on which this operator will be launched.
+                           The rank_id is unique in processes with the same role.
+
+        Examples:
+            >>> from mindspore import context
+            >>> import mindspore.ops as ops
+            >>> context.set_context(mode=context.GRAPH_MODE)
+            >>> matmul = ops.MatMul()
+            >>> matmul.place('MS_WORKER', 0)
+        """
+        if _is_role_sched():
+            return
+
+        Validator.check_non_negative_int(rank_id, "rank_id", "Primitive.place")
+        Validator.check_string(role, "MS_WORKER", "role", "Primitive.place")
+
+        if context.get_context("mode") == context.PYNATIVE_MODE:
+            raise RuntimeError("You are calling Primitive.place in pynative mode."
+                               "It's only supported in graph mode. Please switch to graph mode.")
+
+        # Get the execution context and check whether calling of this 'place' method is valid.
+        # This is because placing operators to arbitrary processes while other distributed training mode
+        # is enabled is very unpredictable and may cause fatal error.
+        # Some of these cases are under development and others should not be supported.
+        if _is_ps_mode():
+            raise RuntimeError(
+                "You are calling Primitive.place mixed with Parameter Server training. "
+                "This case is not supported yet. "
+                "Please call Primitive.place without Parameter Server training.")
+        if _is_in_auto_parallel_mode() or _is_in_data_parallel_mode() or _is_in_hybrid_parallel_mode():
+            raise RuntimeError(
+                "You are calling Primitive.place mixed with other parallel features: "
+                "'auto_parallel', 'data_parallel' and 'hybrid_parallel'. "
+                "This case is still under development and not supported yet. "
+                "Please call Primitive.place without these features.")
+        self.add_prim_attr("ms_role", role)
+        self.add_prim_attr("rank_id", rank_id)
+
 
 class PrimitiveWithCheck(Primitive):
     """
@@ -405,6 +479,7 @@ class PrimitiveWithCheck(Primitive):
         ``Ascend`` ``GPU`` ``CPU``
 
     Examples:
+        >>> from mindspore import dtype as mstype
         >>> from mindspore.ops import prim_attr_register, PrimitiveWithCheck
         >>> # init a Primitive class with check
         >>> class Flatten(PrimitiveWithCheck):
@@ -412,10 +487,10 @@ class PrimitiveWithCheck(Primitive):
         ...     def __init__(self):
         ...         pass
         ...     def check_shape(self, input_x):
-        ...         validator.check_int(len(input_x), 1, Rel.GE, 'input_x rank', self.name)
+        ...         Validator.check_int(len(input_x), 1, validator.GE, 'input_x rank', self.name)
         ...
         ...     def check_dtype(self, input_x):
-        ...         validator.check_subclass("input_x", input_x, mstype.tensor, self.name)
+        ...         Validator.check_subclass("input_x", input_x, mstype.tensor, self.name)
         ...
         >>> # init a Primitive obj
         >>> add = Flatten()
@@ -427,10 +502,18 @@ class PrimitiveWithCheck(Primitive):
 
     def __check__(self, *args):
         """Checking the input shape and the input type of ops is valid """
-        tracks = ['dtype', 'shape']
-        for track in tracks:
-            fn = getattr(self, 'check_' + track)
-            fn(*(x[track] for x in args))
+        check_dtype_fn = getattr(self, 'check_dtype')
+        check_dtype_fn(*(x['dtype'] for x in args))
+
+        is_shape_known = True
+        for x in args:
+            shape = x['shape']
+            if shape is None or -1 in shape or -2 in shape:
+                is_shape_known = False
+                break
+        if is_shape_known:
+            check_shape_fn = getattr(self, 'check_shape')
+            check_shape_fn(*(x['shape'] for x in args))
 
     def _clone(self):
         """
@@ -657,6 +740,24 @@ def prim_attr_register(fn):
     return deco
 
 
+def _check_contains_variable(item_dtype, item_value):
+    """
+    Check whether the item is or contains variable.
+    """
+    if isinstance(item_value, (list, tuple)):
+        for i, element in enumerate(item_value):
+            if _check_contains_variable(item_dtype[i], element):
+                return True
+    elif isinstance(item_value, dict):
+        for i in range(len(item_value)):
+            if _check_contains_variable(item_dtype[i], list(item_value.keys())[i]):
+                return True
+        for i in range(len(item_value)):
+            if _check_contains_variable(item_dtype[i], list(item_value.values())[i]):
+                return True
+    return item_dtype is not None and item_value is None
+
+
 def constexpr(fn=None, get_instance=True, name=None, reuse_result=True, check=True):
     """
     Creates a PrimitiveWithInfer operator that can infer the value at compile time. We can use it to define a function
@@ -703,20 +804,22 @@ def constexpr(fn=None, get_instance=True, name=None, reuse_result=True, check=Tr
                 op_name = name if name else fn.__name__
                 PrimitiveWithInfer.__init__(self, op_name)
                 self.set_const_prim(True)
+                self.fn = fn
+                self.add_prim_attr('constexpr_prim', True)
                 if not reuse_result:
                     self.add_prim_attr('forbid_reuse_result', True)
 
             def __infer__(self, *args):
                 value_args = []
                 for item in args:
-                    if (item["dtype"] is not None and item["value"] is None and check):
+                    if _check_contains_variable(item["dtype"], item["value"]) and check:
                         logger.warning("The \"" + self.name + "\" is a constexpr function." \
                                                               " The input arguments must be all constant value.")
                     value_args.append(item["value"])
                 return {'dtype': None, 'shape': None, 'value': fn(*value_args)}
 
             def __call__(self, *args, **kwargs):
-                return fn(*args)
+                return fn(*args, **kwargs)
 
         if get_instance:
             return CompileOp()
@@ -727,8 +830,82 @@ def constexpr(fn=None, get_instance=True, name=None, reuse_result=True, check=Tr
     return deco
 
 
-@_wrap_func
+def _primexpr(fn=None, get_instance=True, name=None, reuse_result=True):
+    """
+    _primexpr is similar as constexpr except that when the input to the function decorated by _primexpr contains
+    variable, the function will be compiled as graph.
+
+    _primexpr is only for internal use.
+
+    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,
+                             otherwise return the operator class. Default: True.
+        name (str): 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,
+                             otherwise the operator will always be executed. Default: True.
+    """
+    def deco(fn):
+        """Decorator for CompileOp."""
+
+        class CompileOp(PrimitiveWithInfer):
+            """
+            CompileOp is a temporary operator used to execute the constexpr function.
+            """
+
+            def __init__(self):
+                op_name = name if name else fn.__name__
+                PrimitiveWithInfer.__init__(self, op_name)
+                self.set_const_prim(True)
+                self.fn = fn
+                self.add_prim_attr('constexpr_prim', True)
+                if not reuse_result:
+                    self.add_prim_attr('forbid_reuse_result', True)
+
+            def __infer__(self, *args):
+                value_args = []
+                for item in args:
+                    if _check_contains_variable(item["dtype"], item["value"]):
+                        return {'dtype': None, 'shape': None, 'value': None, 'fn': (fn,)}
+                    value_args.append(item["value"])
+                return {'dtype': None, 'shape': None, 'value': fn(*value_args)}
+
+            def __call__(self, *args, **kwargs):
+                return fn(*args, **kwargs)
+
+        if get_instance:
+            return CompileOp()
+        return CompileOp
+
+    if fn is not None:
+        return deco(fn)
+    return deco
+
+
+_RUN_OP_ASYNC = True
+
+
 def _run_op(obj, op_name, args):
     """Single op execution function supported by ge in PyNative mode."""
-    output = real_run_op(obj, op_name, args)
+    if _RUN_OP_ASYNC:
+        stub = _pynative_executor.run_op_async(obj, args)
+        return _convert_stub(stub)
+    return _run_op_sync(obj, op_name, args)
+
+
+@_wrap_func
+def _run_op_sync(obj, op_name, args):
+    """Single op execution function in synchronous mode."""
+    output = _pynative_executor.real_run_op(obj, op_name, args)
     return output
+
+
+class _PrimitiveC(Primitive):
+    def __init__(self, name, attrs):
+        super().__init__(name)
+        for key, value in attrs.items():
+            super().add_prim_attr(key, value)
+
+
+def _get_primitivec(name, attrs):
+    return _PrimitiveC(name, attrs)

mindspore/ops/vm_impl_registry.py

@@ -19,11 +19,32 @@ User debug operators registry.
 User can define a python implementation of primitive operator and
 register it with the registry, this mechanism applied for debugging currently.
 """
-
 from __future__ import absolute_import
+from __future__ import division
+
 from mindspore.ops._register_for_op import Registry
+from mindspore.ops.primitive import Primitive
+
+
+class VmImplRegistry(Registry):
+    """Registry class for registry functions for vm_impl on Primitive or string."""
+
+    def register(self, prim):
+        """register the function."""
+
+        def deco(fn):
+            """Decorate the function."""
+            if isinstance(prim, str):
+                self[prim] = fn
+            elif issubclass(prim, Primitive):
+                self[id(prim)] = fn
+                self[prim.__name__] = fn
+            return fn
+
+        return deco
+
 
-vm_impl_registry = Registry()
+vm_impl_registry = VmImplRegistry()
 """
 Register the python primitive debug implementation function of a primitive operator.
 

mindspore/parallel/__init__.py

@@ -14,7 +14,12 @@
 # ============================================================================
 """Interfaces for parallel-related functionality"""
 from __future__ import absolute_import
+
 from mindspore.parallel.algo_parameter_config import get_algo_parameters, reset_algo_parameters, \
     set_algo_parameters
+from mindspore.parallel.checkpoint_transform import rank_list_for_transform, transform_checkpoint_by_rank, \
+    transform_checkpoints, merge_pipeline_strategys
+from mindspore.parallel.shard import shard
 
-__all__ = ["set_algo_parameters", "reset_algo_parameters", "get_algo_parameters"]
+__all__ = ["set_algo_parameters", "reset_algo_parameters", "get_algo_parameters", "rank_list_for_transform",
+           "transform_checkpoint_by_rank", "transform_checkpoints", "merge_pipeline_strategys", "shard"]