mindspore 2.7.0__cp310-cp310-win_amd64.whl → 2.7.1__cp310-cp310-win_amd64.whl

mindspore/common/api.py

@@ -44,7 +44,7 @@ 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_, JitExecutor_, CSRTensor, RowTensor, COOTensor, \
     PyNativeExecutor_, verify_inputs_signature, init_exec_dataset, _set_dataset_mode_config, init_pipeline, \
-    _run_jit_pipeline, _ms_memory_recycle, _bind_device_ctx, MSContext, TensorPy as Tensor
+    _run_jit_pipeline, _ms_memory_recycle, _bind_device_ctx, TensorPy as Tensor, dump_func_graph, _GraphFragment_
 from mindspore.parallel._ps_context import _is_role_sched
 from mindspore.parallel._utils import _check_full_batch, _get_parameter_broadcast, _is_in_auto_parallel_mode, \
     _is_parallel_mode
@@ -208,6 +208,11 @@ def _handle_func_args(func, *args, **kwargs):
         args = bound_arguments.args
         kwargs = bound_arguments.kwargs
 
+    return args, kwargs
+
+
+def _check_func_args(func, *args):
+    """Check the *args inputs of the function"""
     positional_args = 0
     default_args = 0
     has_var = False
@@ -221,14 +226,13 @@ def _handle_func_args(func, *args, **kwargs):
                 default_args += 1
 
     if has_var:
-        return args, kwargs
+        return
 
     if len(args) < positional_args:
         raise TypeError(f"Function {func.__name__} needs {positional_args} positional argument, but got {len(args)}.")
     if len(args) > positional_args + default_args:
         raise TypeError(f"Function {func.__name__} needs {positional_args} positional argument and {default_args} "
                         f"default argument, total {positional_args + default_args}, but got {len(args)}.")
-    return args, kwargs
 
 
 sys_path = list(sys.path)
@@ -349,7 +353,7 @@ def _get_parameter_layout():
     return layout
 
 
-def _handle_arg(obj, arg, has_mutable_arg):
+def _handle_arg(obj, arg, has_mutable_arg, is_predict):
     """Handle arg for runtime .If need handle the arg, return True"""
     from mindspore._extends.parse import compile_config
     if isinstance(arg, PythonTensor):
@@ -364,7 +368,7 @@ def _handle_arg(obj, arg, has_mutable_arg):
         if isinstance(arg, list) and not arg:
             return None
         return arg
-    elif (context.get_context("grad_for_scalar") or str(compile_config.GRAD_FOR_SCALAR) == '1') and \
+    elif not is_predict and (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 \
@@ -394,17 +398,16 @@ def _handle_arg_predict(obj, arg, has_mutable_arg):
     return arg
 
 
-def _get_args_for_run(obj, args, kwargs, has_mutable_args_list, is_predict):
+def _get_args_for_run(obj, args, kwargs, has_mutable_args_list, is_predict=False):
     """Get the actual input args and kwargs for runtime."""
     new_args = []
-    fn = _handle_arg_predict if is_predict else _handle_arg
     for arg, has_mutable_arg in zip(args, has_mutable_args_list):
-        new_arg = fn(obj, arg, has_mutable_arg)
+        new_arg = _handle_arg(obj, arg, has_mutable_arg, is_predict)
         if new_arg is not None:
             new_args.append(new_arg)
 
     for _, value in kwargs.items():
-        new_value = fn(obj, value, None)
+        new_value = _handle_arg(obj, value, None, is_predict)
         if new_value is not None:
             new_args.append(new_value)
 
@@ -609,7 +612,7 @@ class _JitExecutor:
         else:
             self._graph_executor = GraphExecutor_.get_instance()
         self._create_time = ms_create_time
-        self._compile_args = None
+        self._mutable_flags = None
         self._enable_auto_dynamic = dynamic == 1
         self.jit_config_dict = jit_config.jit_config_dict if jit_config else None
         self._cell_cache_key_extend = cell_cache_key_extend
@@ -634,16 +637,8 @@ class _JitExecutor:
             except Exception as err:
                 _pynative_executor.clear_res()
                 raise err
-        else:  # get compiled args to generate run args by _generate_run_args
-            compile_args = self._generate_compile_args(args_list)
-            key_id = self._get_key_id()
-            if self.input_signature is None:
-                compile_args = get_auto_dynamic_shape_args(
-                    compile_args, key_id, self._enable_auto_dynamic
-                )
-            self._compile_args = compile_args
 
-        new_inputs = self._generate_run_args(args_list, kwargs)
+        new_inputs = self._generate_run_args(args_list, kwargs, is_predict=True)
         if self.jit_config_dict:
             jit_config_dict = self.jit_config_dict
         else:
@@ -656,11 +651,25 @@ class _JitExecutor:
         res = _convert_python_data(output)
         return True, res
 
+    def compile_frontend(self, *args, **kwargs):
+        """Only compile to the frontend graph."""
+        args_list = args
+        if self.obj is not None:
+            args_list = args_list[1:]
+        os.environ['MS_DEV_PRECOMPILE_ONLY'] = '1'
+        phase = ""
+        _pynative_executor.set_jit_compile_phase(phase)
+        phase = self.compile(self.fn.__name__, *args_list, **kwargs)
+        _pynative_executor.set_jit_compile_phase(phase)
+        os.unsetenv('MS_DEV_PRECOMPILE_ONLY')
+        return self._graph_executor.get_func_graph(phase), self._mutable_flags, phase, self.enable_tuple_broaden
+
     @_wrap_func
     def __call__(self, *args, **kwargs):
         predict, res = self._predict(*args, **kwargs)
         if predict:
             return res
+        _check_func_args(self.fn, *args)
         if jit_context() and jit_context().is_nested():
             return jit_context().run_graph("", None, *())
         args_list = args
@@ -668,9 +677,9 @@ class _JitExecutor:
             args_list = args_list[1:]
         phase = ""
         try:
-            _pynative_executor.set_jit_compile_status(True, phase)
+            _pynative_executor.set_jit_compile_phase(phase)
             phase = self.compile(self.fn.__name__, *args_list, **kwargs)
-            _pynative_executor.set_jit_compile_status(False, phase)
+            _pynative_executor.set_jit_compile_phase(phase)
         except Exception as err:
             _pynative_executor.clear_res()
             raise err
@@ -694,6 +703,7 @@ class _JitExecutor:
     def compile(self, method_name, *args, **kwargs):
         """Returns pipeline for the given args."""
         # Chose dynamic shape tensors or actual input tensors as compile args.
+        self._graph_executor.set_real_args(args, kwargs)
         compile_args = self._generate_compile_args(args)
         key_id = self._get_key_id()
         if self.input_signature is None:
@@ -705,7 +715,11 @@ class _JitExecutor:
         # 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
+        mutable_flags = _get_mutable_flags(compile_args)
+        self._mutable_flags = mutable_flags
+        # Store the _mutable_flags in the cell obj for incremental inference.
+        if self.obj is not None:
+            self.obj._mutable_flags = mutable_flags
         generate_name, echo_function_name = self._get_generate_name()
         # The full Function name
         full_function_name = generate_name
@@ -839,6 +853,7 @@ class _JitExecutor:
         else:
             _pynative_executor.set_dynamic_input(self.fn, *compile_args)
         logger.info(f"dynamic shape compile_args: {compile_args}")
+        Validator.check_symbolic_shape(compile_args, args_list)
         return compile_args
 
     def _generate_compile_args_by_set_inputs(self, args_list):
@@ -895,7 +910,7 @@ class _JitExecutor:
         # Case: If the shape of input args is dynamic, get dynamic shape tensor from context and use it to compile.
         return _pynative_executor.get_dynamic_input(args_list)
 
-    def _generate_run_args(self, args_list, kwargs):
+    def _generate_run_args(self, args_list, kwargs, is_predict=False):
         """
         Generate input args, which are required for running.
 
@@ -906,7 +921,11 @@ class _JitExecutor:
         Returns:
             new_inputs, new input args, which are required for running.
         """
-        return _get_args_for_run(self, args_list, kwargs, _get_mutable_flags(self._compile_args), False)
+        if self.obj is not None and hasattr(self.obj, '_mutable_flags'):
+            mutable_flags = self.obj._mutable_flags
+        else:
+            mutable_flags = self._mutable_flags
+        return _get_args_for_run(self, args_list, kwargs, mutable_flags, is_predict)
 
     def _get_func_graph_proto(self, obj, exec_id, ir_type="onnx_ir", use_prefix=False, incremental=False):
         """Get graph proto from pipeline."""
@@ -978,7 +997,7 @@ def _check_option_backend(option, backend):
         'ge_options': ['GE'],
         'infer_boost': ['ms_backend'],
     }
-    if option in option_backend_cfgs and backend not in option_backend_cfgs[option]:
+    if option in option_backend_cfgs and backend != '' and backend not in option_backend_cfgs[option]:
         logger.warning(f"For 'jit(options)', the option '{option}' is only support backend in "
                        f"'{option_backend_cfgs[option]}', but got '{backend}', ignore it.")
 
@@ -1187,8 +1206,10 @@ def jit(
             - ms_backend: Utilizes the built-in backend engine of MindSpore for hardware-related compilation
               optimization and execution, supporting multiple hardware forms such as Ascend, GPU, and CPU.
             - GE: Utilizes the GraphEngine, a graph compilation and execution engine within CANN,
-              for Ascend model compilation and execution. Note: This backend takes effect only in static graph mode
-              and can be executed only on Ascend hardware.
+              for Ascend model compilation and execution. Note: This backend only supports GRAPH Mode in Ascend,
+              only supports whole graph sinking or sub graph sinking in pipeline parallel, and does not support
+              dynamic shape scenes. In addition, this backend incurs additional compilation costs and is difficult to
+              debug and tune.
 
         **options (dict): A dictionary of options to pass to the compilation backend.
 
@@ -1333,9 +1354,8 @@ def jit(
     jit_level = Validator.check_string(jit_level, ["O0", "O1"], "jit_level", "jit")
     dynamic = Validator.check_int_range(dynamic, 0, 1, Validator.INC_BOTH, "dynamic", "jit")
     fullgraph = Validator.check_bool(fullgraph, "fullgraph", "jit")
-    if backend == "":
-        backend = "GE" if MSContext.get_instance().get_ascend_soc_version() == "ascend910" else "ms_backend"
-    backend = Validator.check_string(backend, ["ms_backend", "GE"], "backend", "jit")
+    if backend != "":
+        backend = Validator.check_string(backend, ["ms_backend", "GE"], "backend", "jit")
     jit_syntax_level = "LAX" if fullgraph is False else "STRICT"
     hash_obj = _get_hash_obj(options)
     _check_options(options, backend)
@@ -1350,7 +1370,7 @@ def jit(
     elif capture_mode == "bytecode":
         wrap_func = PIJitCaptureContext(fullgraph=fullgraph, jit_config=jit_config)
     else:
-        wrap_func = _jit_trace()
+        wrap_func = _jit_trace(jit_config)
 
     if function is not None:
         return wrap_func(function)
@@ -1557,6 +1577,20 @@ def _parameter_broadcast(obj):
     _build_broadcast_graph(broadcast_params_dict, broadcast_phase)
 
 
+def _run_in_jit():
+    """In jit, this function always returns true. Otherwise, returns false."""
+    def _temp_func():
+        return 0
+
+    from mindspore.ops.primitive import constexpr
+
+    @constexpr(check=False)
+    def _check_func(func):
+        return func is None
+
+    return _check_func(_temp_func)
+
+
 class _no_grad(contextlib.ContextDecorator):
     """
     Context Manager to disable gradient calculation. When enter this context, we will disable calculate
@@ -1826,17 +1860,16 @@ class _PyNativeExecutor:
         """
         return self._executor.requires_grad()
 
-    def set_jit_compile_status(self, status, phase):
+    def set_jit_compile_phase(self, phase):
         """
-        Set jit is compiling
+        Set jit phase
 
         Args:
-            status(bool): jit compile status
             phase (str): The phase of cell/function instance.
         Return:
             None.
         """
-        self._executor.set_jit_compile_status(status, phase)
+        self._executor.set_jit_compile_phase(phase)
 
     def set_is_run_recompute(self, status):
         """
@@ -1934,6 +1967,19 @@ class _PyNativeExecutor:
         """
         return self._executor.set_creation_type(tensor, creation_type)
 
+    def queue_backward_final_callback(self, callback):
+        """
+        add backward final callback
+
+        Args:
+            callback(Function): callback function.
+
+        Return:
+            None.
+        """
+        return self._executor.queue_backward_final_callback(callback)
+
+
 
 class _CellGraphExecutor:
     """
@@ -2075,6 +2121,8 @@ class _CellGraphExecutor:
         obj.phase_cache[raw_phase] = phase
         update_auto_dynamic_shape_phase(args, key_id, phase)
         obj.current_phase = phase
+        obj._add_attr("compile_phase", phase)
+        obj.compile_phase = phase
         if phase in obj.compile_cache and self.has_compiled(phase):
             logger.debug("%r graph has existed.", phase)
             # Release resource should be released when CompileInner won't be executed, such as cur_convert_input_
@@ -2124,6 +2172,10 @@ class _CellGraphExecutor:
         new_param = {x.name: replace[x] for x in replace if id(x) != id(replace[x])}
         return self._graph_executor.updata_param_node_default_input(phase, new_param)
 
+    def set_real_args(self, args, kwargs):
+        """Set real arguments to graph executor."""
+        self._graph_executor.set_real_args(args, kwargs)
+
     def _get_shard_strategy(self, obj):
         real_phase = _real_phase(obj.phase, obj)
         return self._graph_executor.get_strategy(real_phase)
@@ -2213,6 +2265,19 @@ class _CellGraphExecutor:
             return None
         return self._graph_executor.get_func_graph_proto(exec_id, ir_type, incremental)
 
+    def _get_onnx_func_graph_proto(self, obj, exec_id, use_prefix=False, input_names=None, output_names=None,
+                                   opset_version=11, export_params=True, keep_initializers_as_inputs=False,
+                                   dynamic_axes=None, extra_save_params=False, save_file_dir=None):
+        """Get graph proto from pipeline."""
+        if use_prefix:
+            exec_id = exec_id + '.' + obj.arguments_key
+        if self._graph_executor.has_compiled(exec_id) is False:
+            return None
+
+        return self._graph_executor.get_onnx_func_graph_proto(exec_id, input_names, output_names, opset_version,
+                                                              export_params, keep_initializers_as_inputs, dynamic_axes,
+                                                              extra_save_params, save_file_dir)
+
     def get_optimize_graph_proto(self, obj):
         """Return optimize graph binary proto."""
         exec_id = _real_phase(obj.phase, obj)
@@ -2295,5 +2360,190 @@ def flops_collection(phase='train'):
     return _cell_graph_executor.flops_collection(phase)
 
 
+class _ScriptGraph:
+    """Store the graph compiled by the frontend compiler."""
+    def __init__(self, func_graph, func, origin_cell, mutable_flags, phase, enable_tuple_broaden):
+        self.func_graph = func_graph
+        self.func = func
+        self.origin_cell = origin_cell
+        self.mutable_flags = mutable_flags
+        self.phase = phase
+        self.enable_tuple_broaden = enable_tuple_broaden
+
+    def print(self):
+        """Print the MindIR of the frontend graph."""
+        graph_str = dump_func_graph(self.func_graph)
+        print(graph_str, flush=True)
+
+
+def _frontend_compile_ast(dynamic, jit_config, jit_graph_name=''):
+    """Return the wrapped function for ast mode jit."""
+    def wrap_func(func):
+        if hasattr(func, "construct") and isinstance(func, ms.nn.Cell):
+            # Bound the cell object to get the self arg.
+            return types.MethodType(_frontend_compile_ast(dynamic, jit_config,
+                                                          func._jit_graph_name)(func.construct.__func__), func)
+
+        if isinstance(func, types.MethodType):
+            return types.MethodType(_frontend_compile_ast(dynamic, jit_config)(func.__func__), func.__self__)
+
+        if not isinstance(func, types.FunctionType):
+            logger.warning(f"The func should be function, method or cell instance/class, but got {func}")
+            return func
+
+        hash_obj = int(time.time() * 1e9)
+
+        @wraps(func)
+        def staging_specialize(*args, **kwargs):
+            if os.getenv("MS_JIT") == '0':
+                return func(*args, **kwargs)
+
+            args, kwargs = _handle_func_args(func, *args, **kwargs)
+            process_obj = None
+            if args and not isinstance(args[0], PythonTensor) and hasattr(args[0], func.__name__):
+                process_obj = args[0]
+            # Handle auto mixed precision strategy.
+            if not hasattr(func, "amp_strategy"):
+                setattr(get_func(func), "amp_strategy", get_curr_amp_strategy())
+
+            jit_graph_name = ''
+            if hasattr(staging_specialize, "__jit_graph_name__"):
+                jit_graph_name = staging_specialize.__jit_graph_name__
+            jit_executor = _JitExecutor(func, hash_obj, None, process_obj, jit_config, dynamic, jit_graph_name)
+            func_graph, mutable_flags, phase, enable_tuple_broaden = jit_executor.compile_frontend(*args, **kwargs)
+            return _ScriptGraph(func_graph, func, process_obj, mutable_flags, phase, enable_tuple_broaden)
+
+        # `inspect.getfullargspec(func)` will get the specification of the decorated function by default. By set
+        # `__signature__` for the decorated function, `inspect.getfullargspec(func)` will get the specification of
+        # original `func`.
+        staging_specialize.__signature__ = inspect.signature(func)
+        setattr(staging_specialize, "__jit_graph_name__", jit_graph_name)
+        return staging_specialize
+
+    return wrap_func
+
+
+def _frontend_compile(function: Callable,
+                      *,
+                      dynamic: int = 0,
+                      fullgraph: bool = False):
+    """
+    Create a frontend MindSpore graph from a Python function by the ast capture mode.
+
+    Args:
+        function (Callable, optional): The Python function or Cell instance that will be compiled as a frontend graph.
+            Default: ``None``.
+
+    Keyword Args:
+        dynamic (int, optional): Whether dynamic shape compilation should be performed. Default: ``0``. The value range
+            is as follows:
+
+            - `0`: Do not perform dynamic shape compilation.
+            - `1`: Enable dynamic shape compilation and automatically detect shape changes.
+
+        fullgraph (bool, optional): Whether to capture the entire function into graph. If False, jit attempts to
+            be compatible with all Python syntax in the function as much as possible. If True, we require that the
+            entire function can be captured into graph. If this is not possible (that is, if there is Python syntax
+            not supported), then it will raise an exception. This currently only applies when capture_mode is ``ast``
+            or ``bytecode``. Default: ``False``.
+
+    Returns:
+        a :class:`_ScriptGraph` object.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor
+        >>> from mindspore import ops
+        >>> from mindspore.common.api import _frontend_compile
+        ...
+        >>> x = Tensor(np.ones([1, 1, 3, 3]).astype(np.float32))
+        >>> y = Tensor(np.ones([1, 1, 3, 3]).astype(np.float32))
+        ...
+        >>> def tensor_add(x, y):
+        ...     z = x + y
+        ...     return z
+        ...
+        >>> tensor_add_graph = _frontend_compile(tensor_add)(x, y)
+        >>> tensor_add_graph.print()
+        ...
+    """
+
+    dynamic = Validator.check_int_range(dynamic, 0, 1, Validator.INC_BOTH, "dynamic", "jit")
+    fullgraph = Validator.check_bool(fullgraph, "fullgraph", "jit")
+    jit_syntax_level = "LAX" if fullgraph is False else "STRICT"
+    jit_config = JitConfig(jit_syntax_level=jit_syntax_level)
+    return _frontend_compile_ast(dynamic, jit_config)(function)
+
+
+class _GraphFragment(_GraphFragment_):
+    """
+    Represents the output by backend graph split.
+    """
+    def __init__(self, frag):
+        if frag is None or not isinstance(frag, _GraphFragment_):
+            raise TypeError(f"Expect input `frag` to be a _GraphFragment_, but got {type(frag)}")
+        _GraphFragment_.__init__(self, frag)
+
+    def __call__(self, *args):
+        return super().__call__(args)
+
+    def __repr__(self):
+        return self.__str__()
+
+    def id(self):
+        return self.id_()
+
+    def is_graph(self):
+        return self.is_graph_()
+
+    def py_key(self):
+        return self.py_key_()
+
+    def args_list(self):
+        return self.args_list_()
+
+
+def _graph_split(script_graph):
+    """
+    Split the script_graph into several fragments according to the nodes with the split op attribute.
+
+    Args:
+        a :class:`_ScriptGraph` object.
+
+    Returns:
+        several :class:`_GraphFragment` object.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor
+        >>> from mindspore import ops
+        >>> from mindspore.common.api import _frontend_compile, _graph_split
+        ...
+        >>> x = Tensor(np.ones([1, 1, 3, 3]).astype(np.float32))
+        >>> y = Tensor(np.ones([1, 1, 3, 3]).astype(np.float32))
+        >>> add = ops.Add().add_prim_attr("split_op", True).add_prim_attr("func_id", "add_func")
+        ...
+        >>> def tensor_add(x, y):
+        ...     z1 = x + y
+        ...     z2 = add(z1, x)
+        ...     return z2
+        ...
+        >>> tensor_add_graph = _frontend_compile(tensor_add)(x, y)
+        >>> frags = _graph_split(tensor_add_graph)
+        >>> print(frags)
+        ...
+    """
+    outputs = JitExecutor_.get_instance().split_graph(script_graph.func_graph)
+    fragments = []
+    for arg in outputs:
+        fragments.append(_GraphFragment(arg))
+    return fragments
+
 _cell_graph_executor = _CellGraphExecutor()
 _pynative_executor = _PyNativeExecutor()

mindspore/common/dump.py

@@ -1,4 +1,4 @@
-# Copyright 2021-2022 Huawei Technologies Co., Ltd
+# Copyright 2021-2025 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.
@@ -14,115 +14,14 @@
 # ============================================================================
 """Controlling dump behavior."""
 from __future__ import absolute_import
-from warnings import warn
-
-import mindspore.context as context
-from mindspore._c_expression import security
+from mindspore.tools import set_dump as tools_set_dump
+from mindspore.common._decorator import deprecated
 
 
+@deprecated("2.7.1", "mindspore.tools.set_dump", module_prefix="mindspore.")
 def set_dump(target, enabled=True):
     """
-    Enable or disable dump for the `target` and its contents.
-
-    `target` should be an instance of :class:`mindspore.nn.Cell` or :class:`mindspore.ops.Primitive` .
-    Please note that this API takes effect only when the Dump function is enabled, and the `dump_mode`
-    field in the Dump configuration file is set to `"2"` with the `ms_backend` compilation backend
-    (please refer to the backend parameter in
-    `jit <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.jit.html>`_).
-    See the `dump document <https://www.mindspore.cn/tutorials/en/master/debug/dump.html>`_ for details.
-    The default enabled status for
-    a :class:`mindspore.nn.Cell` or :class:`mindspore.ops.Primitive` is False.
-
-    Note:
-        1. This API is only available for JIT compilation, requires 'Ascend' as the device_target and
-           `ms_backend` as the compilation backend (please refer to the backend parameter in
-           `jit <https://www.mindspore.cn/docs/en/master/api_python/mindspore/mindspore.jit.html>`_),
-           and does not support fused operators.
-        2. This API only supports being called before training starts.
-           If you call this API during training, it may not be effective.
-        3. After using `set_dump(Cell, True)` , operators in forward and backward
-           computation  (computation generated by the grad operations) of the
-           cell will be dumped.
-        4. For :class:`mindspore.nn.SoftmaxCrossEntropyWithLogits` layer, the forward
-           computation and backward computation use the same set of
-           operators. So you can only see dump data from backward computation.
-           Please note that :class:`mindspore.nn.SoftmaxCrossEntropyWithLogits` layer will also use
-           the above operators internally when initialized with `sparse=True` and
-           `reduction="mean"` .
-
-    Args:
-        target (Union[Cell, Primitive]): The Cell instance or Primitive instance
-            to which the dump flag is set.
-        enabled (bool, optional): ``True`` means enable dump, ``False`` means disable dump.
-            Default: ``True`` .
-
-    Supported Platforms:
-        ``Ascend``
-
-    Examples:
-        .. 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/en/master/debug/dump.html>`_ for details.
-
-        >>> import numpy as np
-        >>> import mindspore as ms
-        >>> import mindspore.nn as nn
-        >>> from mindspore import Tensor, set_dump, jit
-        >>>
-        >>> ms.set_device(device_target="Ascend")
-        >>>
-        >>> class MyNet(nn.Cell):
-        ...     def __init__(self):
-        ...         super().__init__()
-        ...         self.conv1 = nn.Conv2d(5, 6, 5, pad_mode='valid')
-        ...         self.relu1 = nn.ReLU()
-        ...
-        ...     @jit
-        ...     def construct(self, x):
-        ...         x = self.conv1(x)
-        ...         x = self.relu1(x)
-        ...         return x
-        >>>
-        >>> if __name__ == "__main__":
-        ...     net = MyNet()
-        ...     set_dump(net.conv1)
-        ...     input_tensor = Tensor(np.ones([1, 5, 10, 10], dtype=np.float32))
-        ...     output = net(input_tensor)
+    This api will be deprecated and removed in future versions, please use the api
+    :func:`mindspore.tools.set_dump` instead.
     """
-    if security.enable_security():
-        raise ValueError('The set_dump API is not supported, please recompile '
-                         'source without "-s on".')
-
-    import mindspore.nn as nn  # avoid circular import
-    from mindspore.ops import Primitive
-    if not isinstance(target, nn.Cell) and not isinstance(target, Primitive):
-        raise ValueError(f"The \"target\" parameter must be an instance of "
-                         f"Cell or Primitive, "
-                         f"but got an instance of {type(target)}.")
-
-    if not isinstance(enabled, bool):
-        raise ValueError("The \"enabled\" parameter must be bool.")
-
-    # Checking for device target and mode.
-    current_target = context.get_context("device_target")
-    if current_target != "Ascend":
-        # We will not return here in case user changed device_target later.
-        warn("Current device_target is {}, which is not supported by set_dump. "
-             "Only Ascend device target is supported currently. "
-             "If you have Ascend device, consider set device_target to Ascend "
-             "before calling set_dump.".format(current_target))
-
-    # The actual set dump logic.
-    if isinstance(target, nn.Cell):
-        target.add_flags(dump=enabled)
-        for cell in target.cells():
-            set_dump(cell, enabled)
-
-        primitives = getattr(target, "_primitives", {})
-        for value in primitives.values():
-            if value and "dump" in value.attrs:
-                set_dump(value, enabled)
-
-    if isinstance(target, Primitive):
-        target.add_prim_attr("dump", "true" if enabled else "false")
+    tools_set_dump(target, enabled)

mindspore/common/dynamic_shape/auto_dynamic_shape.py

@@ -275,9 +275,7 @@ class _AutoIdentifyDynamicShape:
                 continue
             if not isinstance(elem, (list, tuple, Tensor, int, float)):
                 return False
-            if isinstance(elem, Tensor) and \
-                self._is_invalid_shape(elem.shape) and \
-                not enable_jit_dynamic:
+            if isinstance(elem, Tensor) and self._is_invalid_shape(elem.shape) and not enable_jit_dynamic:
                 return False
             if not is_sink_mode and isinstance(elem, (list, tuple)):
                 return self._is_enable_auto_dynamic_shape(elem, is_sink_mode, enable_jit_dynamic)