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

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.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/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"])

mindspore/common/parameter.py

@@ -1,4 +1,4 @@
-# Copyright 2020-2022 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.
@@ -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.
@@ -186,6 +188,9 @@ class Parameter(Tensor_):
         parallel_optimizer (bool): It is used to filter the weight shard operation in `SEMI_AUTO_PARALLEL` or
             `AUTO_PARALLEL` mode. It works only when enable parallel optimizer in
             `mindspore.set_auto_parallel_context()`. Default: ``True`` .
+        storage_format (str): Only Ascend device target is supported. It is used to specify the format of the weight
+            loaded to the device. By default, the format is not changed. The optional values are ``"FRACTAL_NZ"`` ,
+            ``"NC1HWC0"`` , ``"FRACTAL_Z"`` , etc. Default: ``""`` .
 
     Examples:
         >>> import numpy as np
@@ -221,6 +226,7 @@ class Parameter(Tensor_):
         # it's better to make the Initializer a kind of tensor.
         obj.init_mode = None
         obj.is_default_input_init = init_data_flag
+        obj.from_ckpt = False
         if obj.has_init:
             obj.init_mode = default_input
         else:
@@ -237,7 +243,8 @@ class Parameter(Tensor_):
         return (
             Parameter, (data, self.name, self.requires_grad, self.layerwise_parallel))
 
-    def __init__(self, default_input, name=None, requires_grad=True, layerwise_parallel=False, parallel_optimizer=True):
+    def __init__(self, default_input, name=None, requires_grad=True, layerwise_parallel=False, parallel_optimizer=True,
+                 storage_format=""):
         self.param_info = ParamInfo()
         self.init_in_server = False
         self.name = name
@@ -260,6 +267,7 @@ class Parameter(Tensor_):
         self.is_in_shard = False
         self._pipeline_stage_list = []
         self.slice_num = 1
+        self.from_ckpt = False
         if -1 in self.shape:
             raise ValueError(f"All shape elements of the Parameter must be positive. But got None.")
         if isinstance(default_input, (Tensor_, Tensor)):
@@ -287,6 +295,7 @@ class Parameter(Tensor_):
             raise TypeError(f"The type of the argument 'default_input' must be in ['Tensor', 'int', 'float',"
                             f" 'numpy.ndarray', 'list']. But got type {type(default_input)}.")
         self.param_info.parameter_shape = self.shape
+        self.param_info.storage_format = storage_format
 
         import mindspore.ops.operations.other_ops as other_ops
         self.load = other_ops.Load()
@@ -329,8 +338,8 @@ class Parameter(Tensor_):
                     # in other place, so we can make a Tensor without copy data.
                     return (Tensor, data)
                 # make a copy of Tensor to init the parameter.
-                if data.dtype == mstype.bfloat16:
-                    return (Tensor, data.float().asnumpy(), mstype.bfloat16)
+                if data.dtype == mstype.qint4x2:
+                    return (Tensor, data.asnumpy(), mstype.qint4x2)
                 return (Tensor, data.asnumpy())
 
             not_init_data = _is_role_sched() or (_is_role_pserver() and _cache_enable()) or _is_in_parallel_mode()
@@ -359,7 +368,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/master/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"
@@ -741,6 +750,7 @@ class Parameter(Tensor_):
     def requires_grad(self, value=True):
         if not isinstance(value, bool):
             raise TypeError("The argument `requires_grad` must be bool type")
+        Tensor_.wait_pipeline(self)
         self.param_info.requires_grad = value
 
     @property
@@ -783,6 +793,15 @@ class Parameter(Tensor_):
 
     @_LogActionOnce(logger=logger, key='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")
@@ -794,9 +813,9 @@ class Parameter(Tensor_):
                         f"Use .set_dtype(xxx) to change the dtype.")
 
     @staticmethod
-    def _set_data_check_input_valid(current_shape, data_shape, current_tensor_is_init,
-                                    incoming_tensor_is_init, slice_shape=False, slice_num=1):
-        if incoming_tensor_is_init and not current_tensor_is_init:
+    def _set_data_check_input_valid(current_shape, data_shape, current_tensor_is_init, incoming_tensor_is_init,
+                                    from_ckpt, slice_shape=False, slice_num=1):
+        if not from_ckpt and incoming_tensor_is_init and not current_tensor_is_init:
             raise TypeError("The original tensor data is initialized, but the argument 'data' is not initialized."
                             "Please initialize 'data' before call this method.")
         if tuple(current_shape) != tuple(data_shape):
@@ -851,7 +870,7 @@ class Parameter(Tensor_):
         incoming_tensor_is_init = isinstance(data, Tensor) and not data.has_init
         current_tensor_is_init = isinstance(self, Tensor) and not self.has_init
         Parameter._set_data_check_input_valid(self.shape, data.shape, current_tensor_is_init, incoming_tensor_is_init,
-                                              slice_shape, self.slice_num)
+                                              self.from_ckpt, slice_shape, self.slice_num)
         if self.dtype != data.dtype:
             if mstype.implicit_conversion_seq.get(self.dtype) < mstype.implicit_conversion_seq.get(data.dtype):
                 self._raise_type_error(data.dtype)
@@ -1008,7 +1027,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/master/advanced/modules/layer.html#parameter-tuple>`_
         """
         Validator.check_str_by_regular(prefix)
         new = []