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

mindspore/common/jit_config.py

@@ -14,21 +14,20 @@
 # ============================================================================
 """JitConfig for compile."""
 
-
 class JitConfig:
     """
     Jit config for compile.
 
-    .. warning::
-        This is an experimental API that is subject to change or deletion.
-
     Args:
         jit_level (str, optional): Used to control the compilation optimization level.
-            Supports ["O0", "O1", "O2"]. Default: ``"O1"`` .
+            Supports ["O0", "O1", "O2"]. Default: ``""`` , The framework automatically selects the execution method.
+            Not recommended, it is recommended to use the jit decorator.
 
-            - ``"O0"``: Except for optimizations that may affect functionality, all other optimizations are turned off.
-            - ``"O1"``: Using commonly used optimizations, recommended to set the O1 level.
-            - ``"O2"``: Activate some experimental level optimizations.
+            - ``"O0"``: Except for optimizations that may affect functionality, all other optimizations are turned off,
+              adopt KernelByKernel execution mode.
+            - ``"O1"``: Using commonly used optimizations and automatic operator fusion optimizations,
+              adopt KernelByKernel execution mode.
+            - ``"O2"``: Ultimate performance optimization, adopt Sink execution mode.
 
         exc_mode (str, optional): Control the execution mode of the model.
             Supports ["auto", "sink", "no_sink"]. Default: ``"auto"`` .
@@ -43,7 +42,7 @@ class JitConfig:
             The value must be ``"STRICT"`` , ``"LAX"`` or ``""`` . Default to an empty string, which means that this
             JitConfig configuration will be ignored and the jit_syntax_level of ms.context will be used.
             For more details about ms.context, refer to
-            `set_context <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore/mindspore.set_context.html>`_ .
+            `set_context <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.set_context.html>`_ .
             Default: ``""`` .
 
             - ``"STRICT"``: Only basic syntax is supported, and execution performance is optimal. Can be used for MindIR
@@ -52,6 +51,20 @@ class JitConfig:
               affected and not optimal. Cannot be used for MindIR load and export due to some syntax that may not be
               able to be exported.
 
+        debug_level (str, optional): Set debugging level for graph compiling.
+            The value must be ``"RELEASE"`` or ``"DEBUG"``. Default value: ``RELEASE``.
+
+            - ``RELEASE``: Used for normally running, and some debug information will be discard to get a better
+              compiling performance.
+            - ``DEBUG``: Used for debugging when errors occur, more information will be record in compiling process.
+
+        infer_boost (str, optional): enable infer boost mode.
+            The value must be ``"on"`` , ``"off"``. Default to an "off", which means that disable infer boost.
+            when infer boost mode is enabled, MindSpore will use high perf kernel lib, use faster runtime make
+            infer speed is best.
+            Note: current infer boost only support `jit_level` == ``"O0"`` and only Atlas A2 series products
+            are supported.
+
         **kwargs (dict): A dictionary of keyword arguments that the class needs.
 
     Examples:
@@ -60,19 +73,26 @@ class JitConfig:
         >>> jitconfig = JitConfig(jit_level="O1")
         >>>
         >>> # Define the network structure of LeNet5. Refer to
-        >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
+        >>> # https://gitee.com/mindspore/docs/blob/master/docs/mindspore/code/lenet.py
         >>> net = LeNet5()
         >>>
         >>> net.set_jit_config(jitconfig)
     """
-    def __init__(self, jit_level="O1", exc_mode="auto", jit_syntax_level="", **kwargs):
-        if jit_level not in ["O0", "O1", "O2"]:
+    def __init__(self, jit_level="", exc_mode="auto", jit_syntax_level="", debug_level="RELEASE",
+                 infer_boost="off", **kwargs):
+        if jit_level not in ["", "O0", "O1", "O2"]:
             raise ValueError("For 'jit_level' must be one of ['O0', 'O1', 'O2'].")
-        if exc_mode not in ['auto', 'sink', 'no_sink']:
+        if exc_mode not in ["auto", "sink", "no_sink"]:
             raise ValueError("For 'exc_mode' must be one of '['auto', 'sink', 'no_sink']'.")
-        if jit_syntax_level != "" and jit_syntax_level not in ['STRICT', 'COMPATIBLE', 'LAX']:
+        if jit_syntax_level != "" and jit_syntax_level not in ["STRICT", "COMPATIBLE", "LAX"]:
             raise ValueError("For 'jit_syntax_level' must be one of '['STRICT', 'LAX']'.")
+        if debug_level not in ["RELEASE", "DEBUG"]:
+            raise ValueError("For 'debug_level' must be one of '['RELEASE', 'DEBUG']'.")
+        if infer_boost != "" and infer_boost not in ["on", "off"]:
+            raise ValueError("For 'infer_boost' must be one of '['on', 'off']'.")
         self.jit_config_dict = kwargs
         self.jit_config_dict["jit_level"] = jit_level
         self.jit_config_dict["exc_mode"] = exc_mode
         self.jit_config_dict["jit_syntax_level"] = jit_syntax_level
+        self.jit_config_dict["debug_level"] = debug_level
+        self.jit_config_dict["infer_boost"] = infer_boost

mindspore/common/lazy_inline.py

@@ -17,21 +17,28 @@
 from __future__ import absolute_import
 import inspect
 from functools import wraps
+from mindspore import log as logger
 
 
-def lazy_inline(fn=None, attrs=None):
+def lazy_inline(fn=None, attrs=None, policy=None):
     """
-    Make the cell to be reusable. The corresponding sub graph will not be inline at first.
-
+    Make the cell to be reusable. The corresponding sub graph will not be inline at first
+    and will be inline with the policy.
     Registering the decorator of the built-in function `__init__` of a cell, the decorator
     will add the parameters of `__init__` according to the `attrs` as the attributes of this cell.
 
     .. warning::
         This feature is only supported on Ascend and is not supported on other hardwares.
+        The construct parameters must be positional or key word arguments and have not default values.
+        The cell has not switch sub graph.
 
     Args:
         fn (function): `__init__` function of a cell.
         attrs (Union[list[string], string]): The attributes list to add for the cell.
+        policy (Union[None, "front"]): The policy of inline. Default is None.
+
+            - ``None``: The cell will be compiled to sub graph and will not be inline.
+            - ``"front"``: The cell will be compiled to sub graph first and will be inline at front end.
 
     Returns:
         function, original function.
@@ -153,35 +160,81 @@ def lazy_inline(fn=None, attrs=None):
         >>> test_compile()
     """
 
-    def wrap_cell(fn):
+    def lazy_inline_wrap(fn):
+        if inspect.isclass(fn):
+            tips = "The lazy_inline should decorate the __init__ function, not the class {}.".format(fn.__name__) \
+                   + " File: " + inspect.getfile(fn)
+            raise ValueError(tips)
+        if fn.__name__ != "__init__":
+            tips = "The lazy_inline should decorate the __init__ function, not the function: {}.".format(fn.__name__) \
+                   + " line: " + str(fn.__code__.co_firstlineno) + " in " \
+                   + fn.__code__.co_filename
+            raise ValueError(tips)
+
+        def check_parameters(self):
+            if hasattr(fn, "has_tips_"):
+                return
+
+            if hasattr(self, "construct"):
+                params = inspect.signature(self.construct).parameters
+                err = False
+                tips = "The function construct's parameters: "
+                for name, parm in params.items():
+                    if parm.default != inspect.Parameter.empty:
+                        if err:
+                            tips += " , " + name
+                        else:
+                            err = True
+                            tips += " " + name
+
+                if err:
+                    tips += " must be  key word or positional arguments and can't have default values." \
+                            + " line: " + str(self.construct.__code__.co_firstlineno) \
+                            + " in " + self.construct.__code__.co_filename
+                    logger.info(tips)
+                    fn.has_tips_ = True
+
+            else:
+                tips = "The " + self.__class__.__name__ + " must be a cell and must has a construct function." \
+                       + " line: " + str(fn.__code__.co_firstlineno) + " in " + fn.__code__.co_filename
+                logger.warning(tips)
+                fn.has_tips_ = True
+
         @wraps(fn)
-        def deco(self, *args, **kwargs):
-            arguments = []
+        def lazy_inline_deco(self, *args, **kwargs):
+            check_parameters(self)
+            new_args = []
             if attrs is None:
                 bound_args = inspect.signature(fn).bind(self, *args, **kwargs)
-                arguments = bound_args.arguments
-                del arguments['self']
-                arguments = arguments.values()
+                new_args = bound_args.arguments
+                del new_args['self']
+                new_args = new_args.values()
             fn(self, *args, **kwargs)
+
+            if isinstance(policy, str) and policy == "front":
+                self.no_inline = False
+            elif policy is not None:
+                raise ValueError(f"policy must be None or 'front'")
+
             if attrs is None:
-                self.cell_init_args = "lazy_inline_" + type(self).__name__ + str(arguments)
+                self.cell_init_args = "lazy_inline_" + type(self).__name__ + str(new_args)
                 return
 
             if isinstance(attrs, list):
-                for item in attrs:
-                    if not isinstance(item, str):
+                for attr in attrs:
+                    if not isinstance(attr, str):
                         raise ValueError(f"attr must be a string")
-                    if hasattr(self, item):
-                        arguments.append(getattr(self, item))
+                    if hasattr(self, attr):
+                        new_args.append(getattr(self, attr))
             elif isinstance(attrs, str):
                 if hasattr(self, attrs):
-                    arguments = getattr(self, attrs)
+                    new_args = getattr(self, attrs)
             else:
                 raise ValueError(f"attrs must be list or string")
-            self.cell_init_args = "lazy_inline_" + type(self).__name__ + str(arguments)
+            self.cell_init_args = "lazy_inline_" + type(self).__name__ + str(new_args)
 
-        return deco
+        return lazy_inline_deco
 
     if fn is not None:
-        return wrap_cell(fn)
-    return wrap_cell
+        return lazy_inline_wrap(fn)
+    return lazy_inline_wrap

mindspore/common/mindir_util.py

@@ -16,6 +16,7 @@
 from __future__ import absolute_import
 
 import os
+import stat
 from mindspore import log as logger
 from mindspore import _checkparam as Validator
 from mindspore.train.mind_ir_pb2 import ModelProto as mindir_model
@@ -86,16 +87,25 @@ def save_mindir(model, file_name):
 
     Validator.check_file_name_by_regular(file_name)
     file_name = os.path.realpath(file_name)
+    if not file_name.endswith('.mindir'):
+        file_name += ".mindir"
+
+    current_path = os.path.realpath(file_name)
+    dirname = os.path.dirname(current_path)
+    os.makedirs(dirname, mode=0o700, exist_ok=True)
+    if os.path.exists(file_name):
+        os.chmod(file_name, stat.S_IWUSR)
 
     if not isinstance(model, mindir_model):
         raise TypeError("For 'save_mindir', the argument 'model' must be ModelProto, "
                         "but got {}.".format(type(model)))
     try:
-        with open(file_name, "wb") as f:
+        with os.fdopen(os.open(file_name, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), "wb") as f:
             f.write(model.SerializeToString())
     except BaseException as e:
         logger.critical(f"Failed to save the file: {file_name} ,"
                         f" please check the correct file.")
         raise ValueError(e.__str__()) from e
     finally:
-        pass
+        if os.path.exists(file_name):
+            os.chmod(file_name, stat.S_IRUSR)

mindspore/common/mutable.py

@@ -1,4 +1,4 @@
-# Copyright 2022 Huawei Technologies Co., Ltd
+# Copyright 2022-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.
@@ -17,6 +17,9 @@ from __future__ import absolute_import
 
 from mindspore.common.tensor import Tensor
 from mindspore._c_expression import Tensor as Tensor_
+from mindspore import log as logger
+
+_check_elements_set = set()
 
 
 class _Int(int):
@@ -39,19 +42,70 @@ class _Dict(dict):
     pass
 
 
-def _check_element_type(value):
-    """Check if all the elements are Tensor."""
+# pylint: disable=super-init-not-called
+class _Bool(int):
+    """Define a _Bool class that inherits from int, because base class 'bool' is a marked final."""
+    def __init__(self, value):
+        self.value = bool(value)
+
+    @property
+    def __class__(self):
+        return bool
+
+    def __and__(self, x):
+        return self.value & x
+
+    def __rand__(self, x):
+        return x & self.value
+
+    def __or__(self, x):
+        return self.value | x
+
+    def __ror__(self, x):
+        return x | self.value
+
+    def __xor__(self, x):
+        return self.value ^ x
+
+    def __rxor__(self, x):
+        return x ^ self.value
+
+    def __str__(self):
+        return str(self.value)
+
+    def __repr__(self):
+        return repr(self.value)
+
+    def __ms_mutable_bool__(self):
+        pass
+
+
+def _check_element_type_recursion(value):
+    """Check if all the elements are valid or self reference."""
+    if id(value) in _check_elements_set:
+        return False
+    _check_elements_set.add(id(value))
+
     if isinstance(value, (tuple, list)):
         for element in value:
-            if not _check_element_type(element):
+            if not _check_element_type_recursion(element):
                 return False
+            _check_elements_set.remove(id(element))
         return True
     if isinstance(value, dict):
         for element in value.values():
-            if not _check_element_type(element):
+            if not _check_element_type_recursion(element):
                 return False
+            _check_elements_set.remove(id(element))
         return True
-    return isinstance(value, (Tensor, Tensor_, int, float)) and not isinstance(value, bool)
+    return isinstance(value, (Tensor, Tensor_, int, float))
+
+
+def _check_element_type(value):
+    """Check if all the elements are valid."""
+    flag = _check_element_type_recursion(value)
+    _check_elements_set.clear()
+    return flag
 
 
 def mutable(input_data, dynamic_len=False):
@@ -76,7 +130,7 @@ def mutable(input_data, dynamic_len=False):
     the length of the tuple or list is different for each run, it does not need to be re-compiled.
 
     Args:
-        input_data (Union[Tensor, tuple, list, dict]): The input data to be made mutable. If
+        input_data (Union[Tensor, scalar, tuple, list, dict]): The input data to be made mutable. If
             'input_data' is list/tuple/dict, the type of each element should also in the valid types.
         dynamic_len (bool): Whether to set the whole sequence to be dynamic length. In graph compilation, if
             `dynamic_len` is ``True`` , the `input_data` must be list or tuple and the elements of `input_data` must
@@ -93,10 +147,10 @@ def mutable(input_data, dynamic_len=False):
         The origin input data which has been set mutable.
 
     Raises:
-        TypeError: If `input_data` is not one of Tensor, tuple, list, dict or their nested structure.
+        TypeError: If `input_data` is not one of Tensor, scalar, tuple, list, dict or their nested structure.
         TypeError: If `dynamic_len` is ``True`` and `input_data` is not tuple or list.
         ValueError: If `dynamic_len` is ``True`` , `input_data` is tuple or list but the elements within `input_data`
-        do not have the same shape and type.
+            do not have the same type.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -139,16 +193,21 @@ def mutable(input_data, dynamic_len=False):
     """
     if not _check_element_type(input_data):
         raise TypeError(
-            f"For 'mutable', the 'input_data' should be one of (int, float, bool, Tensor, tuple, list, dict) "
-            f"or their nested structures, but got {input_data}.")
+            f"For 'mutable', the 'input_data' should be one of (bool, int, float, Tensor, tuple, list, dict) "
+            f"or their nested structures with no self-reference, but got {type(input_data).__name__}: {input_data}.")
+
+    if not isinstance(dynamic_len, bool):
+        raise TypeError(f"For 'mutable', the second input should be bool, but got: {type(input_data).__name__}")
 
     if dynamic_len and not isinstance(input_data, (tuple, list)):
         raise TypeError(
-            f"For mutable, when the variable_len is True, the first input should be list or tuple,"
-            f" but got {input_data}")
+            f"For 'mutable', when the variable_len is True, the first input should be list or tuple, "
+            f"but got: {type(input_data).__name__}")
 
     ret = input_data
-    if isinstance(input_data, int):
+    if isinstance(input_data, bool):
+        ret = _Bool(input_data)
+    elif isinstance(input_data, int):
         ret = _Int(input_data)
     elif isinstance(input_data, float):
         ret = _Float(input_data)
@@ -159,11 +218,17 @@ def mutable(input_data, dynamic_len=False):
     elif isinstance(input_data, dict):
         ret = _Dict(input_data)
     elif isinstance(input_data, Tensor):
+        logger.info("For 'mutable', the Tensor in 'input_data' must not be constant. \
+                     We will add set_const_arg=False statement automatically.")
         ret.set_const_arg(False)
     elif isinstance(input_data, Tensor_):
         ret = Tensor(input_data, internal=True)
+        logger.info("For 'mutable', the Tensor_ in 'input_data' must not be constant. \
+                     We will add set_const_arg=False statement automatically.")
         ret.set_const_arg(False)
 
     setattr(ret, "__ms_mutable__", True)
     setattr(ret, "__ms_dynamic_len__", dynamic_len)
+    setattr(ret, "__ms_origin_object__", input_data)
+    _check_elements_set.clear()
     return ret

mindspore/common/no_inline.py

@@ -0,0 +1,54 @@
+# Copyright 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.
+# 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.
+# ============================================================================
+
+"""no_inline"""
+from __future__ import absolute_import
+
+
+def no_inline(fn=None):
+    """
+    Make the function to be reusable. The corresponding sub graph will not be inline.
+
+    Args:
+        fn (function): It is the python function. If it is a methon of a cell, please
+            refer to :func:`mindspore.lazy_inline`.
+
+    Returns:
+        function, original function.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> from mindspore import no_inline, Tensor, jit
+        >>> @no_inline
+        ... def no_inline_fun(val):
+        ...     x = val * 3 + 2
+        ...     return x
+        >>> @jit
+        ... def call_no_inline_fun(val):
+        ...     for _ in range(100):
+        ...         val = no_inline_fun(val)
+        ...     return val
+        >>> call_no_inline_fun(Tensor(10))
+    """
+
+    def no_inline_wrap(fn):
+        fn.no_inline = True
+        return fn
+
+    if fn is not None:
+        return no_inline_wrap(fn)
+    return no_inline_wrap

mindspore/common/np_dtype.py

@@ -0,0 +1,25 @@
+# This is the Python adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
+#
+# Copyright 2020-2021 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.
+# ============================================================================
+"""Numpy data type for MindSpore."""
+
+from mindspore._c_expression.np_dtypes import np_version_valid
+if np_version_valid(True):
+    from mindspore._c_expression.np_dtypes import bfloat16 # pylint: disable=unused-import
+
+__all__ = []
+if np_version_valid(False):
+    __all__.extend(["bfloat16"])