mindspore 2.4.1__cp310-cp310-win_amd64.whl → 2.5.0__cp310-cp310-win_amd64.whl

mindspore/common/api.py

@@ -41,19 +41,19 @@ from mindspore.common.sparse_tensor import RowTensor as PythonRowTensor
 from mindspore._c_expression.amp import get_curr_amp_strategy
 from mindspore._c_expression import GraphExecutor_, Tensor, CSRTensor, RowTensor, COOTensor, \
     PyNativeExecutor_, verify_inputs_signature, init_exec_dataset, _set_dataset_mode_config, init_pipeline, \
-    _ms_memory_recycle, _bind_device_ctx
+    _ms_memory_recycle, _bind_device_ctx, StubNode
 from mindspore.parallel._ps_context import _is_role_sched
 from mindspore.parallel._utils import _check_full_batch, _get_parameter_broadcast, _is_pynative_parallel, \
     _is_in_auto_parallel_mode, _is_parallel_mode
 from mindspore import _checkparam as Validator
 from mindspore._checkparam import is_stub_tensor
 from mindspore.common._utils import is_shape_unknown
-from mindspore.common.mutable import mutable
+from mindspore.common.mutable import mutable, _check_element_type
 from mindspore.common._register_for_adapter import ms_adapter_registry
 from mindspore.common.auto_dynamic_shape import get_auto_dynamic_shape_args, update_auto_dynamic_shape_phase, \
     get_auto_dynamic_shape_args_with_check_input_signature, update_auto_dynamic_shape_phase_with_check_input_signature
 from mindspore.common._pijit_context import PIJitCaptureContext
-from mindspore.common.parameter import Parameter
+from mindspore.common.parameter import Parameter, set_parameter_hook_updated, parameter_hook_updated
 
 # Store ms_function class compiled pipeline cache.
 ms_compile_cache = set()
@@ -150,6 +150,8 @@ def _convert_python_data(data):
         return PythonCOOTensor(coo_tensor=data)
     if isinstance(data, RowTensor) and not isinstance(data, PythonRowTensor):
         return PythonRowTensor(row_tensor=data)
+    if isinstance(data, StubNode):
+        return ms.common._stub_tensor._convert_stub(data)
     if data.__class__ is tuple:
         # Handle namedtuple since its type is tuple.
         if hasattr(data, "_fields"):
@@ -273,7 +275,9 @@ def __get_compile_cache_dep_files(file_path, compile_cache_dep_files, pkg):
             else:
                 whole_module = module_name
                 if n.name is not None:
-                    whole_module += "." + n.name
+                    if not whole_module.endswith("."):
+                        whole_module += "."
+                    whole_module += n.name
             try:
                 module_spec = importlib.util.find_spec(whole_module, pkg)
             except (ModuleNotFoundError, ValueError):
@@ -305,7 +309,22 @@ def _get_compile_cache_dep_files():
     return compile_cache_dep_files
 
 
-def _restore_mutable_attr(args_list, compile_args):
+def _contains_auto_grad_tensor(obj):
+    """Check object is or contains auto grad tensor element"""
+    if isinstance(obj, PythonTensor):
+        return obj._has_auto_grad()
+    if isinstance(obj, (tuple, list)):
+        for element in obj:
+            if _contains_auto_grad_tensor(element):
+                return True
+    if isinstance(obj, dict):
+        for key in obj:
+            if _contains_auto_grad_tensor(obj[key]):
+                return True
+    return False
+
+
+def _add_mutable_attr(args_list, compile_args, is_grad):
     """Restore the mutable attr for every arg."""
     new_compile_args = ()
     for idx, arg in enumerate(args_list):
@@ -316,7 +335,12 @@ def _restore_mutable_attr(args_list, compile_args):
             else:
                 new_compile_args += (mutable(compile_args[idx], False),)
         else:
-            new_compile_args += (compile_args[idx],)
+            if is_grad and _contains_auto_grad_tensor(arg):
+                if not _check_element_type(arg):
+                    raise RuntimeError("Input \"%s\" contains tensor with gradient but can not mutable." % (str(arg)))
+                new_compile_args += (mutable(compile_args[idx], False),)
+            else:
+                new_compile_args += (compile_args[idx],)
     return new_compile_args
 
 
@@ -330,6 +354,7 @@ def _get_parameter_layout():
 
 def _handle_arg(obj, arg, compile_arg):
     """Handle arg for runtime .If need handle the arg, return True"""
+    from mindspore._extends.parse import compile_config
     if isinstance(arg, PythonTensor):
         if arg.has_init:
             arg.init_data()
@@ -342,7 +367,8 @@ def _handle_arg(obj, arg, compile_arg):
         if isinstance(arg, list) and not arg:
             return None
         return arg
-    elif context.get_context("grad_for_scalar") and isinstance(arg, (int, float)):
+    elif (context.get_context("grad_for_scalar") or str(compile_config.GRAD_FOR_SCALAR) == '1') and \
+            isinstance(arg, (int, float)):
         return arg
     elif hasattr(obj, "enable_tuple_broaden") and obj.enable_tuple_broaden and isinstance(arg, tuple) and \
             _check_all_tensor(arg):
@@ -528,6 +554,29 @@ def _get_parameter_ids(args, kwargs):
             parameter_ids += str(id(value))
     return parameter_ids
 
+def _get_tensor_hook_key(tensor):
+    """Get the hook key of Tensor/Parameter"""
+    return ".".join(map(str, map(id, tensor.hooks())))
+
+def _get_hook_key(*args, **kwargs):
+    """Get the hook key of Tensors/Parameters"""
+    hook_key = ""
+    for idx, arg in enumerate(args):
+        if idx != 0:
+            hook_key += "."
+        # Only arg of the type Tensor or Parameter is supported now
+        if isinstance(arg, (Tensor, Parameter)):
+            hook_key += _get_tensor_hook_key(arg)
+
+    for idx, value in enumerate(kwargs.values()):
+        if idx != 0:
+            hook_key += "."
+        # Only kwarg of the type Tensor or Parameter is supported now
+        if isinstance(value, (Tensor, Parameter)):
+            hook_key += _get_tensor_hook_key(value)
+
+    return hook_key
+
 
 class _MindsporeFunctionExecutor:
     """
@@ -581,13 +630,14 @@ class _MindsporeFunctionExecutor:
             _pynative_executor.clear_res()
             raise err
 
-        if context.get_context("precompile_only"):
+        if context.get_context("precompile_only") or os.getenv('MS_DEV_PRECOMPILE_ONLY') == '1':
             return None
 
         new_inputs = self._generate_run_args(args_list, kwargs)
-        output = self._graph_executor(tuple(new_inputs), phase)
         if context.get_context("mode") == context.PYNATIVE_MODE:
-            output = _pynative_executor.grad_jit(output, *new_inputs)
+            output = _pynative_executor.grad_jit(*new_inputs)
+        else:
+            output = self._graph_executor(tuple(new_inputs), phase)
 
         return output
 
@@ -605,8 +655,10 @@ class _MindsporeFunctionExecutor:
         compile_args = get_auto_dynamic_shape_args_with_check_input_signature(compile_args, key_id,
                                                                               self.input_signature)
 
-        # Restore the mutable attr for every arg.
-        compile_args = _restore_mutable_attr(args, compile_args)
+        # Add mutable for compile_args for two scene:
+        # 1) Origin args is mutable.
+        # 2) Args contains sequence with gradient tensor.
+        compile_args = _add_mutable_attr(args, compile_args, _pynative_executor.requires_grad())
         self._compile_args = compile_args
         generate_name, echo_function_name = self._get_generate_name()
         # The full Function name
@@ -645,11 +697,14 @@ class _MindsporeFunctionExecutor:
         parameter_ids = _get_parameter_ids(args, kwargs)
         if parameter_ids != "":
             key = str(key) + '.' + parameter_ids
+
+        key = str(key) + "." + _get_hook_key(*args, **kwargs)
+
         phase = generate_name + '.' + str(key)
 
         update_auto_dynamic_shape_phase_with_check_input_signature(compile_args, key_id, phase, self.input_signature)
 
-        if phase in ms_compile_cache:
+        if phase in ms_compile_cache and not parameter_hook_updated():
             # Release resource should be released when CompileInner won't be executed, such as cur_convert_input_
             # generated in generate_arguments_key.
             self._graph_executor.clear_compile_arguments_resource()
@@ -683,6 +738,7 @@ class _MindsporeFunctionExecutor:
 
         if not is_compile:
             raise RuntimeError("Executor compile failed.")
+        set_parameter_hook_updated(False)
         ms_compile_cache.add(phase)
 
         return phase
@@ -1351,8 +1407,6 @@ class _no_grad(contextlib.ContextDecorator):
         self.prev_state = False
 
     def __enter__(self):
-        if context.get_context("mode") == context.GRAPH_MODE:
-            raise RuntimeError("For no_grad feature, currently only support Pynative mode, but got Graph mode.")
         self.prev_state = _pynative_executor.enable_grad()
         _pynative_executor.set_enable_grad(False)
 
@@ -1501,18 +1555,18 @@ class _PyNativeExecutor:
         """
         self._executor.sync()
 
-    def grad_jit(self, output, *args):
+    def grad_jit(self, *args):
         """
         Building grad graph decorated by jit.
 
         Args:
-            output (tuple): The function or cell decorated by jit output object.
             args (tuple): Function or cell decorated by jit input arguments.
 
         Return:
-            None.
+            output: The output object of function or cell decorated by jit.
         """
-        return self._executor.grad_jit(output, *args)
+        output = self._executor.grad_jit(*args)
+        return output
 
     def call_custom_bprop(self, obj, output, *args, **kwargs):
         """
@@ -1703,7 +1757,6 @@ class _CellGraphExecutor:
         self._graph_executor = GraphExecutor_.get_instance()
         self._graph_executor.set_py_exe_path(sys.executable)
         self._graph_executor.set_kernel_build_server_dir(os.path.split(kernel_build_server.__file__)[0] + os.sep)
-        self._pid = os.getpid()
 
     def init_dataset(self, queue_name, dataset_size, batch_size, dataset_types, dataset_shapes,
                      input_indexs, phase='dataset', need_run=True):
@@ -1804,8 +1857,12 @@ class _CellGraphExecutor:
             self.enable_tuple_broaden = obj.enable_tuple_broaden
         logger.debug(f"Convert the network: {do_convert}.")
         self._graph_executor.set_enable_tuple_broaden(self.enable_tuple_broaden)
+
         key = self._graph_executor.generate_arguments_key(obj, args, kwargs, self.enable_tuple_broaden)
         obj.arguments_key = str(key)
+
+        obj.arguments_key = obj.arguments_key + "." + _get_hook_key(*args, **kwargs)
+
         # When exist parameter in the top graph inputs, need check if the parameter object has changed.
         parameter_ids = _get_parameter_ids(args, kwargs)
         if parameter_ids != "":
@@ -1815,7 +1872,7 @@ class _CellGraphExecutor:
         obj.phase_cache[raw_phase] = phase
         update_auto_dynamic_shape_phase(args, key_id, phase)
         obj.current_phase = phase
-        if phase in obj.compile_cache and self.has_compiled(phase):
+        if phase in obj.compile_cache and self.has_compiled(phase) and not parameter_hook_updated():
             logger.debug("%r graph has existed.", phase)
             # Release resource should be released when CompileInner won't be executed, such as cur_convert_input_
             # generated in generate_arguments_key.
@@ -1841,6 +1898,7 @@ class _CellGraphExecutor:
         obj.compile_cache.add(phase)
         if not result:
             raise RuntimeError("Executor compile failed.")
+        set_parameter_hook_updated(False)
         graph = self._graph_executor.get_func_graph(phase)
 
         if graph is None:
@@ -1876,7 +1934,7 @@ class _CellGraphExecutor:
         return self._graph_executor.get_allreduce_fusion(real_phase)
 
     def __call__(self, obj, *args, phase='predict'):
-        if context.get_context("precompile_only") or _is_role_sched():
+        if context.get_context("precompile_only") or os.getenv('MS_DEV_PRECOMPILE_ONLY') == '1' or _is_role_sched():
             return None
         return self.run(obj, *args, phase=phase)
 
@@ -1934,9 +1992,7 @@ class _CellGraphExecutor:
 
     def del_net_res(self, obj, net_id):
         """Clear the memory resource of a network."""
-        # no need to del net res by gc in independent dataset process which is a subprocess forked by main process
-        if self._pid == os.getpid():
-            self._graph_executor.del_net_res(obj, net_id)
+        self._graph_executor.del_net_res(obj, net_id)
 
     def _get_branch_control_input(self):
         if ('obf_ratio' not in self.obfuscate_config.keys()) or (
@@ -2015,6 +2071,24 @@ def ms_memory_recycle():
     _ms_memory_recycle()
 
 
+def set_recursion_limit(recursion_limit=1000):
+    """
+    Specify the recursion depth limit of function call before compiling graph.
+    It needs to be call when the nested function call is too deep or the number of sub graphs is too large.
+    If recursion_limit is set larger than before, the system max stack depth should be set larger too,
+    otherwise a `core dumped` exception may be raised because of system stack overflow.
+
+    Args:
+        recursion_limit (int, optional): The recursion depth limit. Must be a positive integer. Default: ``1000`` .
+
+    Examples:
+        >>> import mindspore as ms
+        >>> ms.set_recursion_limit(10000)
+    """
+    recursion_limit = Validator.check_positive_int(recursion_limit)
+    GraphExecutor_.get_instance().set_max_call_depth(recursion_limit)
+
+
 def _generate_branch_control_input(obf_random_seed):
     """Generate append network input for dynamic obfuscation in random seed mode."""
     seed_max = 2 ** 32 - 1

mindspore/common/dtype.py

@@ -59,58 +59,58 @@ __all__.extend(__dtype__)
 __all__.extend(__method__)
 
 # type definition
-bool_ = typing.Bool()
+bool_ = typing.kBool
 
-qint4x2 = typing.Int(4)
-int8 = typing.Int(8)
+qint4x2 = typing.kInt4
+int8 = typing.kInt8
 byte = int8
-int16 = typing.Int(16)
+int16 = typing.kInt16
 short = int16
-int32 = typing.Int(32)
+int32 = typing.kInt32
 intc = int32
-int64 = typing.Int(64)
+int64 = typing.kInt64
 intp = int64
 
-uint8 = typing.UInt(8)
+uint8 = typing.kUInt8
 ubyte = uint8
-uint16 = typing.UInt(16)
+uint16 = typing.kUInt16
 ushort = uint16
-uint32 = typing.UInt(32)
+uint32 = typing.kUInt32
 uintc = uint32
-uint64 = typing.UInt(64)
+uint64 = typing.kUInt64
 uintp = uint64
 
-float16 = typing.Float(16)
+float16 = typing.kFloat16
 half = float16
-float32 = typing.Float(32)
+float32 = typing.kFloat32
 single = float32
-float64 = typing.Float(64)
+float64 = typing.kFloat64
 double = float64
-bfloat16 = typing.BFloat(16)
-complex64 = typing.Complex(64)
-complex128 = typing.Complex(128)
-
-number = typing.Number()
-int_ = typing.Int()
-uint = typing.UInt()
-float_ = typing.Float()
-string = typing.String()
-list_ = typing.List()
-tuple_ = typing.Tuple()
-type_none = typing.TypeNone()
-_null = typing.TypeNull()
-
-tensor_type = typing.TensorType()
-index_slices = typing.RowTensorType()
-coo_tensor = typing.COOTensorType()
-csr_tensor = typing.CSRTensorType()
+bfloat16 = typing.kBFloat16
+complex64 = typing.kComplex64
+complex128 = typing.kComplex128
+
+number = typing.kNumber
+int_ = typing.kInt
+uint = typing.kUInt
+float_ = typing.kFloat
+string = typing.kString
+list_ = typing.kList
+tuple_ = typing.kTuple
+type_none = typing.kTypeNone
+_null = typing.kTypeNull
+
+tensor_type = typing.kTensorType
+index_slices = typing.kRowTensorType
+coo_tensor = typing.kCOOTensorType
+csr_tensor = typing.kCSRTensorType
 undetermined = typing.UndeterminedType()
 
 function = typing.Function()
 symbolic_key = typing.SymbolicKeyType()
-env_type = typing.EnvType()
-type_type = typing.TypeType()
-type_refkey = typing.RefKeyType()
+env_type = typing.kTypeEnv
+type_type = typing.kTypeType
+type_refkey = typing.kRefKeyType
 
 Int = typing.Int
 Float = typing.Float

mindspore/common/dump.py

@@ -64,7 +64,8 @@ def set_dump(target, enabled=True):
         >>> import mindspore.nn as nn
         >>> from mindspore import Tensor, set_dump
         >>>
-        >>> ms.set_context(device_target="Ascend", mode=ms.GRAPH_MODE)
+        >>> ms.set_context(mode=ms.GRAPH_MODE)
+        >>> ms.set_device(device_target="Ascend")
         >>>
         >>> class MyNet(nn.Cell):
         ...     def __init__(self):

mindspore/common/file_system.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 # ============================================================================
 """File system registration management"""
+from mindspore import log as logger
 
 
 class FileSystem:
@@ -39,7 +40,13 @@ def _register_mindio_file_system(fs: FileSystem):
         import mindio
     except ImportError:
         return False
-    if mindio.initialize() != 0:
+    try:
+        ret = mindio.initialize()
+    except AttributeError as e:
+        logger.warning(f"Failed to initialize MindIO: {e}")
+        return False
+    if ret != 0:
+        logger.warning(f"Failed to initialize MindIO: ret = {ret}")
         return False
     fs.create = mindio.create_file
     fs.create_args = ()

mindspore/common/generator.py

@@ -80,6 +80,7 @@ class Generator:
             Tensor(0, mstype.int64), name="offset", requires_grad=False)
 
         self._generator = GeneratorOp().set_device("CPU")
+        self._generator.add_prim_attr("manual_seed", False)
         self._to_scalar = TensorToScalar()
 
     def set_state(self, state):
@@ -125,6 +126,7 @@ class Generator:
             raise TypeError("Seed must be an integer.")
         seed = Tensor(seed, mstype.int64)
         self._generator(MANUAL_SEED, (self._seed, self._offset, seed))
+        self._generator.add_prim_attr("manual_seed", True)
         return self
 
     def initial_seed(self):

mindspore/common/hook_handle.py

@@ -29,8 +29,9 @@ class _TensorHookHandle:
         ``Ascend`` ``GPU`` ``CPU``
     """
 
-    def __init__(self):
+    def __init__(self, tensor):
         self.id = None
+        self.tensor = tensor
 
     def remove(self):
         """
@@ -66,6 +67,7 @@ class _TensorHookHandle:
         """
         if self.id is not None:
             Tensor_.remove_hook(self.id)
+            self.tensor._remove_hook() # pylint:disable=protected-access
 
 
 class HookHandle:

mindspore/common/initializer.py

@@ -36,9 +36,7 @@ class Initializer:
     Note:
         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/master/api_python/mindspore/Tensor/mindspore.Tensor.init_data.html#
-        mindspore-tensor-init-data>`_ .
+        followed in most of the cases. For more information, please refer to :func:`mindspore.Tensor.init_data` .
 
     Args:
         kwargs (dict): Keyword arguments for Initializer.
@@ -841,7 +839,8 @@ def initializer(init, shape=None, dtype=mstype.float32):
         dtype (:class:`mindspore.dtype`): The type of data in initialized tensor. Default: ``mstype.float32`` .
 
     Returns:
-        Tensor, return is Tensor object.
+        Returns a Tensor with the shape specified by the input `shape`. If `shape` is ``None``,
+        the returned Tensor will have the same shape as ``init``.
 
     Raises:
         TypeError: The type of the argument 'init' is not correct.

mindspore/common/lazy_inline.py

@@ -27,6 +27,10 @@ def lazy_inline(fn=None, attrs=None, policy=None):
     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.
 
+    For a detailed description of the function, see `Using the lazy_inline decorator
+    <https://www.mindspore.cn/docs/en/master/model_train/program_form/static_graph_syntax/
+    static_graph_expert_programming.html#using-lazy-inline-decorator>`_ .
+
     .. 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.
@@ -47,6 +51,7 @@ def lazy_inline(fn=None, attrs=None, policy=None):
         ``Ascend``
 
     Examples:
+        >>> import os
         >>> import numpy as np
         >>> from mindspore import Tensor
         >>> import mindspore.nn as nn
@@ -154,8 +159,9 @@ def lazy_inline(fn=None, attrs=None, policy=None):
         ...     inp = Tensor(np.ones([1, 3, 224, 224]).astype(np.float32))
         ...     net(inp)
         ...
-        >>> context.set_context(mode=context.GRAPH_MODE,
-        ...                     save_graphs=True, save_graphs_path="./lazy")
+        >>> context.set_context(mode=context.GRAPH_MODE)
+        >>> os.environ["MS_DEV_SAVE_GRAPHS"] = "2"
+        >>> os.environ["MS_DEV_SAVE_GRAPHS_PATH"] = os.path.realpath("./lazy")
         ...
         >>> test_compile()
     """

mindspore/common/mindir_util.py

@@ -26,6 +26,9 @@ def load_mindir(file_name):
     """
     load protobuf file.
 
+    Note:
+        The interface is deprecated from version 2.5 and will be removed in a future version.
+
     Args:
         file_name (str): File name.
 
@@ -42,7 +45,8 @@ def load_mindir(file_name):
         >>> import mindspore as ms
         >>> md = ms.load_mindir("test.mindir")
     """
-
+    logger.warning("The interface 'mindspore.load_mindir' is deprecated from version 2.5 "
+                   "and will be removed in a future version.")
     Validator.check_file_name_by_regular(file_name)
     file_name = os.path.realpath(file_name)
     model = mindir_model()
@@ -65,6 +69,9 @@ def save_mindir(model, file_name):
     """
     save protobuf file.
 
+    Note:
+        The interface is deprecated from version 2.5 and will be removed in a future version.
+
     Args:
         model (ModelProto): mindir model
         file_name (str): File name.
@@ -84,7 +91,8 @@ def save_mindir(model, file_name):
         >>> md_new = ms.load_mindir("test_new.mindir")
         >>> md_new.user_info
     """
-
+    logger.warning("The interface 'mindspore.save_mindir' is deprecated from version 2.5 "
+                   "and will be removed in a future version.")
     Validator.check_file_name_by_regular(file_name)
     file_name = os.path.realpath(file_name)
     if not file_name.endswith('.mindir'):