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

mindspore/common/api.py

@@ -50,14 +50,12 @@ from mindspore.parallel._utils import _check_full_batch, _get_parameter_broadcas
     _is_parallel_mode
 from mindspore import _checkparam as Validator
 from mindspore._checkparam import is_stub_tensor
-from mindspore.common._utils import is_shape_unknown, get_func
+from mindspore.common._utils import is_shape_unknown
 from mindspore.common.mutable import mutable, _check_element_type
-from mindspore.common.dynamic_shape.auto_dynamic_shape import get_auto_dynamic_shape_args, \
-    update_auto_dynamic_shape_phase
-from mindspore.common.dynamic_shape.enable_dynamic import generate_dynamic_tensor_args, ENABLE_DYNAMIC
+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.hook_handle import _hook_version
+from mindspore.common.parameter import Parameter, set_parameter_hook_updated, parameter_hook_updated
 from mindspore.common.jit_context import jit_context
 from mindspore.common.jit_trace import _jit_trace
 from mindspore.parallel._utils import _init_auto_parallel_context, _clear_auto_parallel_context
@@ -76,11 +74,6 @@ ARG_SPECIFIED = "arg_specified_infos"
 TOTAL_ARG_LEN = "total_arg_length"
 
 
-def _real_phase(phase, obj):
-    real_phase = phase + '.' + str(obj.create_time) + '.' + str(id(obj)) + '.' + obj.arguments_key
-    return real_phase
-
-
 def _check_recompile_args(compile_args, kwargs):
     """Check recompile of graph"""
 
@@ -545,12 +538,10 @@ 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 = ""
@@ -597,8 +588,6 @@ class _JitExecutor:
 
         self.fn = fn
         self.input_signature = input_signature
-        self.dynamic_args_shapes = getattr(get_func(fn), ENABLE_DYNAMIC, None)
-        self.enable_jit_dynamic = self.dynamic_args_shapes is not None
         self.obj = None
         if obj and hasattr(obj, fn.__name__):
             self.obj = obj
@@ -637,10 +626,12 @@ class _JitExecutor:
         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
-                )
+            compile_args = get_auto_dynamic_shape_args_with_check_input_signature(
+                compile_args,
+                key_id,
+                self.input_signature,
+                self._enable_auto_dynamic
+            )
             self._compile_args = compile_args
 
         new_inputs = self._generate_run_args(args_list, kwargs)
@@ -693,13 +684,18 @@ class _JitExecutor:
 
     def compile(self, method_name, *args, **kwargs):
         """Returns pipeline for the given args."""
+        # Check whether hook function registered on Cell object.
+        if self.obj and hasattr(self.obj, "_hook_fn_registered"):
+            if self.obj._hook_fn_registered():
+                logger.warning(f"For 'Cell', it's not support hook function when using 'jit' decorator. "
+                               f"If you want to use hook function, please use context.set_context to set "
+                               f"pynative mode and remove 'jit' decorator.")
         # Chose dynamic shape tensors or actual input tensors as compile args.
         compile_args = self._generate_compile_args(args)
         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.enable_jit_dynamic
-            )
+        compile_args = get_auto_dynamic_shape_args_with_check_input_signature(compile_args, key_id,
+                                                                              self.input_signature,
+                                                                              self._enable_auto_dynamic)
 
         # Add mutable for compile_args for two scene:
         # 1) Origin args is mutable.
@@ -739,23 +735,20 @@ class _JitExecutor:
 
         self._graph_executor.set_enable_tuple_broaden(self.enable_tuple_broaden)
         key = self._graph_executor.generate_arguments_key(self.fn, compile_args, kwargs, self.enable_tuple_broaden)
-        key = str(key)
 
         parameter_ids = _get_parameter_ids(args, kwargs)
         if parameter_ids != "":
-            key += '.' + parameter_ids
+            key = str(key) + '.' + parameter_ids
 
-        key += "." + _get_hook_key(*args, **kwargs)
-        key += "." + str(_hook_version())
+        key = str(key) + "." + _get_hook_key(*args, **kwargs)
 
-        phase = generate_name + '.' + key
+        phase = generate_name + '.' + str(key)
 
-        if self.input_signature is None:
-            update_auto_dynamic_shape_phase(compile_args, key_id, phase)
+        update_auto_dynamic_shape_phase_with_check_input_signature(compile_args, key_id, phase, self.input_signature)
 
         phase = phase + self._cell_cache_key_extend
 
-        if phase in ms_compile_cache and self._graph_executor.has_compiled(phase):
+        if phase in ms_compile_cache and self._graph_executor.has_compiled(phase) 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()
@@ -772,9 +765,16 @@ class _JitExecutor:
 
         if self.obj is None:
             # Set an attribute to fn as an identifier.
-            setattr(get_func(self.fn), "__jit_function__", True)
-            is_compile = self._graph_executor.compile(self.fn, compile_args, kwargs, phase, jit_config_dict)
-            delattr(get_func(self.fn), "__jit_function__")
+            if isinstance(self.fn, types.MethodType):
+                setattr(self.fn.__func__, "__jit_function__", True)
+            else:
+                setattr(self.fn, "__jit_function__", True)
+            is_compile = self._graph_executor.compile(
+                self.fn, compile_args, kwargs, phase, jit_config_dict)
+            if isinstance(self.fn, types.MethodType):
+                delattr(self.fn.__func__, "__jit_function__")
+            else:
+                delattr(self.fn, "__jit_function__")
         else:
             if isinstance(self.obj, ms.nn.Cell):
                 self._graph_executor.set_weights_values(self.obj.parameters_dict())
@@ -783,6 +783,7 @@ class _JitExecutor:
 
         if not is_compile:
             raise RuntimeError("Executor compile failed.")
+        set_parameter_hook_updated(False)
         ms_compile_cache.add(phase)
         if hasattr(self.obj, "phase"):
             self.obj.phase_cache[self.obj.phase] = phase
@@ -830,70 +831,41 @@ class _JitExecutor:
         if enable_compile_cache is True or enable_compile_cache == "1":
             self._graph_executor.set_compile_cache_dep_files(_get_compile_cache_dep_files())
 
-    def _generate_compile_args_by_enable_dynamic(self, args_list):
-        """Generate compile args by enable_dynamic."""
-        compile_args = generate_dynamic_tensor_args(args_list, self.dynamic_args_shapes)
-        compile_args = _add_mutable_attr(args_list, compile_args, _pynative_executor.requires_grad())
-        if self.obj is not None:
-            _pynative_executor.set_dynamic_input(self.obj, *compile_args)
-        else:
-            _pynative_executor.set_dynamic_input(self.fn, *compile_args)
-        logger.info(f"dynamic shape compile_args: {compile_args}")
-        return compile_args
-
-    def _generate_compile_args_by_set_inputs(self, args_list):
-        """Generate compile args by set_inputs."""
-        compile_args = _generate_dyn_compile_args(args_list, self.obj.get_inputs())
-        if len(compile_args) != len(args_list):
-            raise ValueError(f"The number of actual input tensors: {len(args_list)} is not equal to the number of "
-                             f"dynamic shape tensors: {len(compile_args)}.")
-        self._graph_executor.check_argument_consistency(compile_args, args_list, "set_inputs")
-        Validator.check_symbolic_shape(compile_args, args_list)
-        return compile_args
-
-    def _generate_compile_args_by_input_signature(self, args_list):
-        """Generate compile args by input_signature."""
-        compile_args = list(_generate_dyn_compile_args(args_list, self.input_signature))
-        dyn_shape = any([is_shape_unknown(elem.shape) for elem in compile_args if isinstance(elem, PythonTensor)])
-        Validator.check_symbolic_shape(self.input_signature, args_list)
-        if dyn_shape:
-            # Checkout whether the `sens` has been added to args_list.
-            if len(compile_args) == len(args_list) - 1:
-                logger.warning(f"The number of actual input args '{len(args_list)}' is one more than the number "
-                               f"of input_signature args '{len(compile_args)}'. The last actual args may "
-                               f"be 'sens' and added it to compile args.")
-                compile_args.append(args_list[-1])
-            compile_args = tuple(compile_args)
-            self._graph_executor.check_argument_consistency(compile_args, args_list, "input_signature")
-            if self.obj is not None:
-                _pynative_executor.set_dynamic_input(self.obj, *compile_args)
-            else:
-                _pynative_executor.set_dynamic_input(self.fn, *compile_args)
-        else:
-            if not verify_inputs_signature(compile_args, args_list):
-                raise ValueError("The input args is incompatible with the args in `input_signature`!")
-        return compile_args
-
-    def _check_set_inputs(self):
-        """Check if the `set_inputs()` of Cell object has been set."""
-        return self.fn.__name__ == 'construct' and isinstance(self.obj, ms.nn.Cell) and self.obj.get_inputs()
-
     def _generate_compile_args(self, args_list):
         """Chose dynamic shape tensors or actual input tensors as compile args."""
-        # Case: The `enable_dynamic` is provided and `set_inputs()` of Cell object has been set.
-        if self.enable_jit_dynamic and self._check_set_inputs():
-            raise ValueError("When `enable_dynamic` is provided, the `set_inputs()` cannot be set!")
-        # Case: The `enable_dynamic` is provided.
-        if self.enable_jit_dynamic:
-            return self._generate_compile_args_by_enable_dynamic(args_list)
+        # Case: If the shape of input args is dynamic, get dynamic shape tensor from context and use it to compile.
+        compile_args = _pynative_executor.get_dynamic_input(args_list)
         # Case: The `set_inputs()` of Cell object has been set, using these dynamic shape args as compile args.
-        if self._check_set_inputs():
-            return self._generate_compile_args_by_set_inputs(args_list)
+        if self.fn.__name__ == 'construct' and isinstance(self.obj, ms.nn.Cell) and self.obj.get_inputs():
+            compile_args = _generate_dyn_compile_args(args_list, self.obj.get_inputs())
+            if len(compile_args) != len(args_list):
+                raise ValueError(f"The number of actual input tensors: {len(args_list)} is not equal to the number of "
+                                 f"dynamic shape tensors: {len(compile_args)}.")
+            self._graph_executor.check_argument_consistency(compile_args, args_list, "input_signature")
+            Validator.check_symbolic_shape(compile_args, args_list)
+
         # Case: If dynamic shape tensors have been assigned to `input_signature`, they are preferred as compile args.
         if self.input_signature is not None:
-            return self._generate_compile_args_by_input_signature(args_list)
-        # 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)
+            compile_args = list(_generate_dyn_compile_args(args_list, self.input_signature))
+            dyn_shape = any([is_shape_unknown(elem.shape) for elem in compile_args if isinstance(elem, PythonTensor)])
+            Validator.check_symbolic_shape(self.input_signature, args_list)
+            if dyn_shape:
+                # Checkout whether the `sens` has been added to args_list.
+                if len(compile_args) == len(args_list) - 1:
+                    logger.warning(f"The number of actual input args '{len(args_list)}' is one more than the number "
+                                   f"of input_signature args '{len(compile_args)}'. The last actual args may "
+                                   f"be 'sens' and added it to compile args.")
+                    compile_args.append(args_list[-1])
+                compile_args = tuple(compile_args)
+                self._graph_executor.check_argument_consistency(compile_args, args_list, "input_signature")
+                if self.obj is not None:
+                    _pynative_executor.set_dynamic_input(self.obj, *compile_args)
+                else:
+                    _pynative_executor.set_dynamic_input(self.fn, *compile_args)
+            else:
+                if not verify_inputs_signature(compile_args, args_list):
+                    raise ValueError("The input args is incompatible with the args in `input_signature`!")
+        return compile_args
 
     def _generate_run_args(self, args_list, kwargs):
         """
@@ -1105,7 +1077,10 @@ def _jit_ast(hash_obj, dynamic, jit_config, jit_graph_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())
+                if isinstance(func, types.MethodType):
+                    setattr(func.__func__, "amp_strategy", get_curr_amp_strategy())
+                else:
+                    setattr(func, "amp_strategy", get_curr_amp_strategy())
 
             jit_graph_name = ''
             if hasattr(staging_specialize, "__jit_graph_name__"):
@@ -1113,8 +1088,6 @@ def _jit_ast(hash_obj, dynamic, jit_config, jit_graph_name):
             jit_executor = _JitExecutor(
                 func, hash_obj, None, process_obj, jit_config, dynamic, jit_graph_name)
             out = jit_executor(*args, **kwargs)
-            if isinstance(process_obj, ms.nn.Cell):
-                _clear_auto_parallel_context(process_obj)
             return out
 
         # `inspect.getfullargspec(func)` will get the specification of the decorated function by default. By set
@@ -1154,26 +1127,28 @@ def jit(
 
     Keyword Args:
         capture_mode (str, optional): The method to create a callable MindSpore graph. The value of capture_mode
-            should be ``"ast"`` , ``"bytecode"`` or ``"trace"`` . Default: ``"ast"`` .
+            should be ``ast`` , ``bytecode`` or ``trace`` . Default: ``ast`` .
 
-            - ast: Parse Python ast to build graph.
-            - bytecode: Parse Python bytecode to build graph at runtime. This is an experimental prototype
-              that is subject to change and/or deletion.
-            - trace: Trace the execution of Python code to build graph. This is an experimental prototype
-              that is subject to change and/or deletion.
+            - `ast <https://www.mindspore.cn/docs/en/master/features/compile/graph_construction.html#ast>`_ :
+              Parse Python ast to build graph.
+            - `bytecode <https://www.mindspore.cn/docs/en/master/features/compile/graph_construction.html#bytecode>`_ :
+              Parse Python bytecode to build graph at runtime. This is an experimental prototype that is subject to
+              change and/or deletion.
+            - `trace <https://www.mindspore.cn/docs/en/master/features/compile/graph_construction.html#trace>`_ : Trace the execution of Python code to build graph. This is an experimental prototype that is
+              subject to change and/or deletion.
 
         jit_level (str, optional): Used to control the compilation optimization level. Currently is only effective
-            with ms_backend. The value of jit_level should be ``"O0"`` or ``"O1"`` . Default: ``"O0"`` .
+            with ms_backend. The value of jit_level should be ``O0`` or ``O1`` . Default: ``O0`` .
 
-            - O0: Except for optimizations that may affect functionality, all other optimizations are turned off.
-            - O1: Using commonly used optimizations and automatic operator fusion optimizations. This optimization
+            - `O0`: Except for optimizations that may affect functionality, all other optimizations are turned off.
+            - `O1`: Using commonly used optimizations and automatic operator fusion optimizations. This optimization
               level is experimental and is being improved.
 
         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.
+            - `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
@@ -1181,14 +1156,12 @@ def jit(
             not supported), then it will raise an exception. This currently only applies when capture_mode is ``ast``
             or ``bytecode``. Default: ``False``.
         backend (str, optional): The compilation backend to be used. If this parameter is not set, the framework will
-            use ``"GE"`` backend for Atlas training series products and ``"ms_backend"`` backend for others including
-            Atlas A2 training series products by default.
+            use ``GE`` backend for Atlas training series products and ``ms_backend`` backend for others including Atlas
+            A2 training series products by default.
 
-            - 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.
+            - `ms_backend`: Adopt KernelByKernel execution mode.
+            - `GE`: Adopt Sink execution mode. The whole model will be sinked to device to execute, only applicable to
+              the top cell of model. And only can be used in Ascend platform.
 
         **options (dict): A dictionary of options to pass to the compilation backend.
 
@@ -1211,11 +1184,11 @@ def jit(
               `disable_format_transform` can be set to ``True`` to try to improve training performance.
               Default: ``False`` .
             - exec_order (str, optional): Set the sorting method for operator execution, currently only two sorting
-              methods are supported: ``"bfs"`` and ``"dfs"`` . Default: ``"bfs"`` .
+              methods are supported: ``bfs`` and ``dfs`` . Default: ``bfs`` .
 
-              - bfs: The default sorting method, breadth priority, good communication masking, relatively good
+              - `bfs`: The default sorting method, breadth priority, good communication masking, relatively good
                 performance.
-              - dfs: An optional sorting method, depth-first sorting. The performance is relatively worse than that
+              - `dfs`: An optional sorting method, depth-first sorting. The performance is relatively worse than that
                 of bfs execution order, but it occupies less memory. It is recommended to try dfs in scenarios where
                 other execution orders run out of memory (OOM).
 
@@ -1226,11 +1199,11 @@ def jit(
               - global (dict): Set global options.
               - session (dict): Set session options.
 
-            - infer_boost (str, optional): Used to control the inference mode. Default: ``"off"``, which means
+            - infer_boost (str, optional): Used to control the inference mode. Default: ``off``, which means
               the inference mode is disabled. The range is as follows:
 
-              - on: Enable inference mode, get better infer performance.
-              - off: Disable inference mode, use forward for inference. The performance is poor.
+              - `on`: Enable inference mode, get better infer performance.
+              - `off`: Disable inference mode, use forward for inference. The performance is poor.
 
     Returns:
         Function, if `fn` is not None, returns a callable function that will execute the compiled function; If `fn` is
@@ -1921,19 +1894,6 @@ class _PyNativeExecutor:
         """
         return self._executor.constant_folding(*args)
 
-    def set_creation_type(self, tensor, creation_type):
-        """
-        Set tensor's view creation type
-
-        Args:
-            tensor (Tensor): input tensor.
-            creation_type (CreationType): The type of view tensor when it is created.
-
-        Return:
-            None.
-        """
-        return self._executor.set_creation_type(tensor, creation_type)
-
 
 class _CellGraphExecutor:
     """
@@ -2042,11 +2002,6 @@ class _CellGraphExecutor:
         if not hasattr(obj, obj.__parse_method__):
             raise AttributeError(
                 'The class {} does not have method {}'.format(obj.__class__.__name__, obj.__parse_method__))
-        inner_func = inspect.unwrap(obj.construct)
-        if hasattr(get_func(inner_func), ENABLE_DYNAMIC):
-            raise ValueError(
-                "When using set_context(mode=GRAPH_MODE) together with nn.Cell, the 'enable_dynamic' cannot be set!"
-            )
         key_id = str(id(obj)) + str(obj.create_time)
         args = get_auto_dynamic_shape_args(args, key_id)
 
@@ -2057,25 +2012,20 @@ class _CellGraphExecutor:
         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)
-        key = str(key)
+        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 != "":
-            key += '.' + parameter_ids
-
-        key += "." + _get_hook_key(*args, **kwargs)
-        key += "." + str(_hook_version())
-
-        obj.arguments_key = key
-
+            obj.arguments_key = obj.arguments_key + '.' + parameter_ids
         raw_phase = phase
-
-        phase = _real_phase(phase, obj)
+        phase = phase + '.' + str(obj.create_time) + '.' + str(id(obj)) + '.' + obj.arguments_key
         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.
@@ -2101,6 +2051,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:
@@ -2125,15 +2076,15 @@ class _CellGraphExecutor:
         return self._graph_executor.updata_param_node_default_input(phase, new_param)
 
     def _get_shard_strategy(self, obj):
-        real_phase = _real_phase(obj.phase, obj)
+        real_phase = obj.phase + '.' + str(obj.create_time) + '.' + str(id(obj)) + '.' + obj.arguments_key
         return self._graph_executor.get_strategy(real_phase)
 
     def _get_num_parallel_ops(self, obj):
-        real_phase = _real_phase(obj.phase, obj)
+        real_phase = obj.phase + '.' + str(obj.create_time) + '.' + str(id(obj)) + '.' + obj.arguments_key
         return self._graph_executor.get_num_parallel_ops(real_phase)
 
     def _get_allreduce_fusion(self, obj):
-        real_phase = _real_phase(obj.phase, obj)
+        real_phase = obj.phase + '.' + str(obj.create_time) + '.' + str(id(obj)) + '.' + obj.arguments_key
         return self._graph_executor.get_allreduce_fusion(real_phase)
 
     def __call__(self, obj, *args, phase='predict'):
@@ -2185,10 +2136,10 @@ class _CellGraphExecutor:
             Tensor/Tuple, return execute result.
         """
         if phase == 'save':
-            exe_phase = _real_phase(phase, obj)
+            exe_phase = phase + '.' + str(obj.create_time) + '.' + str(id(obj)) + '.' + obj.arguments_key
             return self._graph_executor((), exe_phase)
 
-        phase_real = _real_phase(phase, obj)
+        phase_real = phase + '.' + str(obj.create_time) + '.' + str(id(obj)) + '.' + obj.arguments_key
         if self.has_compiled(phase_real):
             return self._exec_pip(obj, *args, phase=phase_real)
         raise KeyError('{} graph is not exist.'.format(phase_real))
@@ -2215,7 +2166,7 @@ class _CellGraphExecutor:
 
     def get_optimize_graph_proto(self, obj):
         """Return optimize graph binary proto."""
-        exec_id = _real_phase(obj.phase, obj)
+        exec_id = obj.phase + "." + str(obj.create_time) + '.' + str(id(obj)) + '.' + obj.arguments_key
         if self._graph_executor.has_compiled(exec_id) is False:
             return None
         graph_proto = self._graph_executor.get_optimize_graph_proto(exec_id)

mindspore/common/{dynamic_shape/auto_dynamic_shape.py → auto_dynamic_shape.py}

@@ -1,6 +1,6 @@
 # This is the Python adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
 #
-# Copyright 2020-2025 Huawei Technologies Co., Ltd
+# Copyright 2020-2023 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.
@@ -261,12 +261,7 @@ class _AutoIdentifyDynamicShape:
                 return False
         return True
 
-    @staticmethod
-    def _is_invalid_shape(shape):
-        """Check if input shape is valid"""
-        return is_shape_unknown(shape) or not shape
-
-    def _is_enable_auto_dynamic_shape(self, args_list, is_sink_mode, enable_jit_dynamic=False):
+    def _is_enable_auto_dynamic_shape(self, args_list, is_sink_mode):
         """is enable auto identify shape"""
         if not is_sink_mode and not args_list:
             return False
@@ -275,12 +270,10 @@ 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 (is_shape_unknown(elem.shape) or (not elem.shape)):
                 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)
+                return self._is_enable_auto_dynamic_shape(elem, is_sink_mode)
         return True
 
     @staticmethod
@@ -335,10 +328,10 @@ class _AutoIdentifyDynamicShape:
         logger.info((f'generalize with generalize shape cache, compile args shape = {res_shape}'))
         return new_generalize_shape
 
-    def auto_dynamic_generate_compile_args(self, args_list, is_sink_mode, enable_jit_dynamic=False):
+    def auto_dynamic_generate_compile_args(self, args_list, is_sink_mode):
         """generate compile args in auto dynamic shape"""
         if not self.is_enable_auto_dynamic_shape or \
-            not self._is_enable_auto_dynamic_shape(args_list, is_sink_mode, enable_jit_dynamic) or \
+            not self._is_enable_auto_dynamic_shape(args_list, is_sink_mode) or \
             not self._check_input_number_and_type(args_list):
             self.is_enable_auto_dynamic_shape = False
             return args_list
@@ -482,13 +475,11 @@ class _AutoIdentifyDynamicShape:
 _auto_dynamic_shape = _AutoIdentifyDynamicShape()
 
 
-def get_auto_dynamic_shape_args(compile_args, key_id, enable_auto_dynamic=False, enable_jit_dynamic=False):
+def get_auto_dynamic_shape_args(compile_args, key_id, enable_auto_dynamic=False):
     """get auto dynamic shape args."""
     if key_id not in auto_dynamic_shape_dict:
         auto_dynamic_shape_dict[key_id] = _AutoIdentifyDynamicShape(enable_auto_dynamic)
-    compile_args = auto_dynamic_shape_dict[key_id].auto_dynamic_generate_compile_args(
-        compile_args, False, enable_jit_dynamic
-    )
+    compile_args = auto_dynamic_shape_dict[key_id].auto_dynamic_generate_compile_args(compile_args, False)
     return compile_args
 
 
@@ -496,3 +487,18 @@ def update_auto_dynamic_shape_phase(compile_args, key_id, phase):
     """update auto dynamic shape phase."""
     if key_id in auto_dynamic_shape_dict:
         auto_dynamic_shape_dict[key_id].update_phase_and_compile_args(compile_args, phase, False)
+
+
+def get_auto_dynamic_shape_args_with_check_input_signature(compile_args, key_id, input_signature,
+                                                           enable_auto_dynamic=False):
+    """get auto dynamic shape args."""
+    if input_signature is None:
+        return get_auto_dynamic_shape_args(compile_args, key_id, enable_auto_dynamic)
+    return compile_args
+
+
+def update_auto_dynamic_shape_phase_with_check_input_signature(compile_args, key_id, phase, input_signature):
+    """update auto dynamic shape phase."""
+    if input_signature is None:
+        if key_id in auto_dynamic_shape_dict:
+            auto_dynamic_shape_dict[key_id].update_phase_and_compile_args(compile_args, phase, False)