mindspore 2.2.14__cp39-cp39-manylinux1_x86_64.whl → 2.3.0rc1__cp39-cp39-manylinux1_x86_64.whl

mindspore/common/dtype.py

@@ -144,7 +144,7 @@ number_type = (int8,
 
 int_type = (int8, int16, int32, int64,)
 uint_type = (uint8, uint16, uint32, uint64,)
-float_type = (float16, float32, float64,)
+float_type = (float16, float32, float64, bfloat16,)
 signed_type = (int8, byte, int16, short, int32, intc, int64,
                intp, float16, half, float32, single, float64,
                double, bfloat16, complex64, complex128)
@@ -348,8 +348,9 @@ class QuantDtype(enum.Enum):
     """
     An enum for quant datatype, contains `INT1` ~ `INT16`, `UINT1` ~ `UINT16`.
 
-    `QuantDtype` is defined in `dtype.py <https://gitee.com/mindspore/mindspore/tree/r2.2/mindspore/python/mindspore/
-    common/dtype.py>`_, use command below to import:
+    `QuantDtype` is defined in
+    `dtype.py <https://gitee.com/mindspore/mindspore/tree/r2.3.q1/mindspore/python/mindspore/common/dtype.py>`_ ,
+    use command below to import:
 
     .. code-block::
 
@@ -357,7 +358,7 @@ class QuantDtype(enum.Enum):
 
     Tutorial Examples:
         - `Quantization algorithm in Golden Stick
-          <https://www.mindspore.cn/golden_stick/docs/en/r0.3/quantization/slb.html
+          <https://www.mindspore.cn/golden_stick/docs/en/master/quantization/slb.html
           #applying-the-quantization-algorithm>`_
     """
     INT1 = 0

mindspore/common/dump.py

@@ -26,12 +26,13 @@ def set_dump(target, enabled=True):
 
     `target` should be an instance of :class:`mindspore.nn.Cell` or :class:`mindspore.ops.Primitive` .
     Please note that this API takes effect only when Asynchronous Dump is enabled and the `dump_mode`
-    field in dump config file is ``"2"`` . See the `dump document <https://www.mindspore.cn/tutorials/
-    experts/en/r2.2/debug/dump.html>`_ for details. The default enabled status for
+    field in dump config file is ``"2"`` . See the `dump document
+    <https://www.mindspore.cn/tutorials/experts/en/r2.3.q1/debug/dump.html>`_ for details.
+    The default enabled status for
     a :class:`mindspore.nn.Cell` or :class:`mindspore.ops.Primitive` is False.
 
     .. warning::
-        This is an experimental API that is subject to change or deletion.
+        This is an experimental API that is subject to change or deletion. It is not supported for 2.3 version.
 
     Note:
         1. This API is only effective for GRAPH_MODE with Ascend backend.
@@ -60,7 +61,7 @@ def set_dump(target, enabled=True):
         .. note::
             Please set environment variable `MINDSPORE_DUMP_CONFIG` to the dump config file and set `dump_mode` field
             in dump config file to 2 before running this example.
-            See `dump document <https://www.mindspore.cn/tutorials/experts/en/r2.2/debug/dump.html>`_ for details.
+            See `dump document <https://www.mindspore.cn/tutorials/experts/en/r2.3.q1/debug/dump.html>`_ for details.
 
         >>> import numpy as np
         >>> import mindspore as ms

mindspore/common/initializer.py

@@ -37,7 +37,7 @@ class Initializer:
         Initializers are intended to be used for delayed initialization in parallel mode rather than Tensor
         initialization. If you have to use Initializers to create a Tensor, :func:`mindspore.Tensor.init_data` should be
         followed in most of the cases. For more information, please refer to `mindspore.Tensor.init_data
-        <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore/Tensor/mindspore.Tensor.init_data.html#
+        <https://www.mindspore.cn/docs/en/r2.3.q1/api_python/mindspore/Tensor/mindspore.Tensor.init_data.html#
         mindspore-tensor-init-data>`_ .
 
     Args:

mindspore/common/jit_config.py

@@ -19,16 +19,15 @@ 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.
 
-            - ``"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/r2.3.q1/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,13 @@ 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.
+
         **kwargs (dict): A dictionary of keyword arguments that the class needs.
 
     Examples:
@@ -60,19 +66,22 @@ 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/r2.3.q1/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", **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']:
             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']:
             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']'.")
         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

mindspore/common/lazy_inline.py

@@ -17,17 +17,18 @@
 from __future__ import absolute_import
 import inspect
 from functools import wraps
+from mindspore import log as logger
 
 
 def lazy_inline(fn=None, attrs=None):
     """
     Make the cell to be reusable. The corresponding sub graph will not be inline at first.
-
     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.
 
     Args:
         fn (function): `__init__` function of a cell.
@@ -153,35 +154,75 @@ 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 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.abspath(file_name)
+    dirname = os.path.dirname(current_path)
+    os.makedirs(dirname, 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/parameter.py

@@ -145,7 +145,9 @@ class Parameter(Tensor_):
     Args:
         default_input (Union[Tensor, int, float, numpy.ndarray, list]): Parameter data,
             to initialize the parameter data.
-        name (str): Name of the parameter. Default: ``None`` .
+        name (str): Name of the parameter. Default: ``None`` . If two or more `Parameter`
+            objects with the same name exist in a network,
+            you will be prompted to set a unique name when defining them.
 
             1) If the parameter is not given a name, the default name is its variable name. For example, the name of
             param_a below is name_a, and the name of param_b is the variable name param_b.
@@ -330,7 +332,10 @@ class Parameter(Tensor_):
                     return (Tensor, data)
                 # make a copy of Tensor to init the parameter.
                 if data.dtype == mstype.bfloat16:
-                    return (Tensor, data.float().asnumpy(), mstype.bfloat16)
+                    from mindspore.ops.operations import Cast
+                    cpu_cast = Cast().set_device("CPU")
+                    data = cpu_cast(data, mstype.float32)
+                    return (Tensor, data.asnumpy(), mstype.bfloat16)
                 return (Tensor, data.asnumpy())
 
             not_init_data = _is_role_sched() or (_is_role_pserver() and _cache_enable()) or _is_in_parallel_mode()
@@ -359,7 +364,7 @@ class Parameter(Tensor_):
 
         Tutorial Examples:
             - `Parameter Server Mode
-              <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/parameter_server_training.html>`_
+              <https://www.mindspore.cn/tutorials/experts/en/r2.3.q1/parallel/parameter_server_training.html>`_
         """
         if not _is_ps_mode() or not (_is_role_worker() or _is_role_pserver() or _is_role_sched()):
             raise RuntimeError("Must complete following two steps before calling set_param_ps: \n"
@@ -782,7 +787,17 @@ class Parameter(Tensor_):
         return new_param
 
     @_LogActionOnce(logger=logger, key='add_pipeline_stage')
+    @deprecated("2.3", "add_pipeline_stage")
     def add_pipeline_stage(self, stage):
+        """
+        Add a pipeline stage to the parameter.
+
+        Args:
+            stage(int): The pipeline stage to be added.
+
+        Raise:
+            TypeError: If `stage` is not a positive number or not int type.
+        """
         logger.warning(f"This interface may be deleted in the future.")
         if not isinstance(stage, int) or stage < 0:
             raise TypeError("`stage` must be a positive number of int type")
@@ -1008,7 +1023,7 @@ class ParameterTuple(tuple):
 
         Tutorial Examples:
             - `Cell and Parameter - Parameter Tuple
-              <https://mindspore.cn/tutorials/en/r2.2/advanced/modules/layer.html#parameter-tuple>`_
+              <https://mindspore.cn/tutorials/en/r2.3.q1/advanced/modules/layer.html#parameter-tuple>`_
         """
         Validator.check_str_by_regular(prefix)
         new = []

mindspore/common/seed.py

@@ -41,18 +41,18 @@ def set_seed(seed):
     Set global seed.
 
     Note:
-        The global seed is used by numpy.random, mindspore.common.Initializer and
-        mindspore.nn.probability.distribution.
+        - The global seed is used by numpy.random, mindspore.common.Initializer and
+          mindspore.nn.probability.distribution.
 
-        If global seed is not set, these packages will use their own default seed independently, numpy.random and
-        mindspore.common.Initializer will choose a random seed, mindspore.nn.probability.distribution will use zero.
+        - If global seed is not set, these packages will use their own default seed independently, numpy.random and
+          mindspore.common.Initializer will choose a random seed, mindspore.nn.probability.distribution will use zero.
 
-        Seed set by numpy.random.seed() only used by numpy.random, while seed set by this API will also used by
-        numpy.random, so just set all seed by this API is recommended.
+        - Seed set by numpy.random.seed() only used by numpy.random, while seed set by this API will also used by
+          numpy.random, so just set all seed by this API is recommended.
 
-        In semi_auto_parallel/auto_parallel mode, when using set_seed, weights with same shape and same sharding
-        strategy in the same device would be initialized to the same result, otherwise, they would be initialized to
-        the different result.
+        - In semi_auto_parallel/auto_parallel mode, when using set_seed, weights with same shape and same sharding
+          strategy in the same device would be initialized to the same result, otherwise, they would be initialized to
+          the different result.
 
     Args:
         seed (int): The seed to be set.