mindspore 2.2.14__cp38-cp38-manylinux1_x86_64.whl → 2.3.0rc1__cp38-cp38-manylinux1_x86_64.whl

mindspore/amp.py

@@ -39,13 +39,18 @@ _partial = ops.Partial()
 
 
 @constexpr
-def _ascend_910A_target():
+def _ascend_target():
+    return context.get_context("device_target") == "Ascend"
+
+
+@constexpr
+def _ascend_910a_target():
     return MSContext.get_instance().get_ascend_soc_version() == "ascend910"
 
 
 @constexpr
-def _ascend_910B_target():
-    return MSContext.get_instance().get_ascend_soc_version() == "ascend910b"
+def _ascend_910bc_target():
+    return MSContext.get_instance().get_ascend_soc_version() in ["ascend910b", "ascend910c"]
 
 
 @constexpr
@@ -81,16 +86,17 @@ def _overflow(inputs):
 @jit
 def _all_finite(inputs, check_overflow_mode):
     """all finite check"""
-    if (_ascend_910A_target()) or \
-       (_ascend_910B_target() and check_overflow_mode != "INFNAN_MODE"):
-        status = Tensor([0] * 8, mstype.int32)
-        status = ops.depend(status, inputs)
-        get_status = _get_cache_prim(NPUGetFloatStatusV2)()(status)
-        status = ops.depend(status, get_status)
-        clear_status = _get_cache_prim(NPUClearFloatStatusV2)()(status)
-        get_status = ops.depend(get_status, clear_status)
-        status_finite = get_status.equal(Tensor(0, mstype.int32)).all()
-        return status_finite
+    if _ascend_target():
+        if (_ascend_910a_target()) or \
+           (_ascend_910bc_target() and check_overflow_mode == "SATURATION_MODE"):
+            status = Tensor([0] * 8, mstype.int32)
+            status = ops.depend(status, inputs)
+            get_status = _get_cache_prim(NPUGetFloatStatusV2)()(status)
+            status = ops.depend(status, get_status)
+            clear_status = _get_cache_prim(NPUClearFloatStatusV2)()(status)
+            get_status = ops.depend(get_status, clear_status)
+            status_finite = get_status.equal(Tensor(0, mstype.int32)).all()
+            return status_finite
 
     outputs = _hypermap(_partial(_overflow), inputs)
     flag_sum = ops.addn(outputs).reshape(())
@@ -126,7 +132,7 @@ def all_finite(inputs):
 
     Tutorial Examples:
         - `Automatic Mix Precision - Loss Scaling
-          <https://mindspore.cn/tutorials/en/r2.2/advanced/mixed_precision.html#loss-scaling>`_
+          <https://mindspore.cn/tutorials/en/r2.3.q1/advanced/mixed_precision.html#loss-scaling>`_
     """
     inputs = mutable(inputs)
     _check_overflow_mode = os.environ.get('MS_ASCEND_CHECK_OVERFLOW_MODE')
@@ -142,7 +148,7 @@ class LossScaler(ABC):
     to scale and unscale the loss value and gradients to avoid overflow, `adjust` is used to update the
     loss scale value.
 
-    For more information, refer to the `tutorials  <https://mindspore.cn/tutorials/en/r2.2/advanced/
+    For more information, refer to the `tutorials  <https://mindspore.cn/tutorials/en/r2.3.q1/advanced/
     mixed_precision.html#loss-scaling>`_.
 
     .. warning::
@@ -334,7 +340,7 @@ class DynamicLossScaler(LossScaler):
 
         Tutorial Examples:
             - `Automatic Mix Precision - Loss Scaling
-              <https://mindspore.cn/tutorials/en/r2.2/advanced/mixed_precision.html#loss-scaling>`_
+              <https://mindspore.cn/tutorials/en/r2.3.q1/advanced/mixed_precision.html#loss-scaling>`_
         """
         inputs = mutable(inputs)
         return _grad_scale_map(self.scale_value, inputs)
@@ -351,7 +357,7 @@ class DynamicLossScaler(LossScaler):
 
         Tutorial Examples:
             - `Automatic Mix Precision - Loss Scaling
-              <https://mindspore.cn/tutorials/en/r2.2/advanced/mixed_precision.html#loss-scaling>`_
+              <https://mindspore.cn/tutorials/en/r2.3.q1/advanced/mixed_precision.html#loss-scaling>`_
         """
         inputs = mutable(inputs)
         return _grad_unscale_map(self.scale_value, inputs)
@@ -365,7 +371,7 @@ class DynamicLossScaler(LossScaler):
 
         Tutorial Examples:
             - `Automatic Mix Precision - Loss Scaling
-              <https://mindspore.cn/tutorials/en/r2.2/advanced/mixed_precision.html#loss-scaling>`_
+              <https://mindspore.cn/tutorials/en/r2.3.q1/advanced/mixed_precision.html#loss-scaling>`_
         """
         one = ops.ones((), self.scale_value.dtype)
         scale_mul_factor = self.scale_value * self.scale_factor

mindspore/boost/boost_cell_wrapper.py

@@ -136,7 +136,7 @@ class BoostTrainOneStepCell(TrainOneStepCell):
         >>> from mindspore import boost
         >>> from mindspore import nn
         >>> # Define the network structure of LeNet5. Refer to
-        >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
+        >>> # https://gitee.com/mindspore/docs/blob/r2.3.q1/docs/mindspore/code/lenet.py
         >>> net = LeNet5()
         >>> loss_fn = nn.SoftmaxCrossEntropyWithLogits()
         >>> optim = nn.Momentum(net.trainable_params(), learning_rate=0.1, momentum=0.9)

mindspore/boost/group_loss_scale_manager.py

@@ -94,7 +94,7 @@ class GroupLossScaleManager(Cell):
         ...                        loss_scale_manager=loss_scale_manager,
         ...                        boost_level="O1", boost_config_dict=boost_config_dict)
         >>> # Create the dataset taking MNIST as an example. Refer to
-        >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/mnist.py
+        >>> # https://gitee.com/mindspore/docs/blob/r2.3.q1/docs/mindspore/code/mnist.py
         >>> dataset = create_dataset()
         >>> model.train(2, dataset)
     """

mindspore/common/__init__.py

@@ -31,6 +31,7 @@ from mindspore.common.mutable import mutable
 from mindspore.common.jit_config import JitConfig
 from mindspore.common.lazy_inline import lazy_inline
 from mindspore.common.mindir_util import load_mindir, save_mindir
+from mindspore.common.symbol import Symbol
 
 # symbols from dtype
 __all__ = [
@@ -69,5 +70,6 @@ __all__.extend([
     "set_dump",
     "ms_memory_recycle",
     "mutable", "JitConfig",
-    "lazy_inline", "load_mindir", "save_mindir"
+    "lazy_inline", "load_mindir", "save_mindir",
+    "Symbol",
 ])

mindspore/common/_jit_fallback_utils.py

@@ -16,7 +16,6 @@
 # ============================================================================
 """common _jit_fallback_utils."""
 
-
 _local_value_nodes = {}
 
 
@@ -81,8 +80,8 @@ def list_inplace_pop(list_obj, index):
     # This will be removed after empty list problem is solved.
     if isinstance(list_obj, tuple) and not list_obj == 0:
         list_obj = []
-    list_obj.pop(index)
-    return list_obj
+    ret = list_obj.pop(index)
+    return list_obj, ret
 
 
 def list_inplace_reverse(list_obj):

mindspore/common/_register_for_adapter.py

@@ -24,6 +24,7 @@ class Registry:
         self._tensor = None
         self._parameter = None
         self._convert_map = {}
+        self.convert_adapter_tensor_map = {}
 
     @property
     def tensor(self):
@@ -63,5 +64,11 @@ class Registry:
             raise ValueError(f"Expect a dict type, but got {type(value)}.")
         self._convert_map = value
 
+    def register_convert_adapter_tensor_map(self, value):
+        """Register the convert map for adapter tensor."""
+        if not isinstance(value, dict):
+            raise ValueError(f"Expect a dict type, but got {type(value)}.")
+        self.convert_adapter_tensor_map = value
+
 
 ms_adapter_registry = Registry()

mindspore/common/_stub_tensor.py

@@ -29,7 +29,7 @@ def _stub_member(var, init):
         if stub.tensor is not None:
             return getattr(stub.tensor, var)
         if hasattr(stub, "member_cache"):
-            return getattr(stub.member_cache, var, init)
+            return stub.member_cache.get(var, init)
         return init
 
     def setx(stub, value):
@@ -61,6 +61,11 @@ class StubTensor:
     index_of_parent_ = _stub_member("index_of_parent_", None)
     slice_num_of_persistent_data_ = _stub_member("slice_num_of_persistent_data_", None)
     slice_shape_of_persistent_data_ = _stub_member("slice_shape_of_persistent_data_", None)
+    # auto gradient information
+    _grad = _stub_member("_grad", None)
+    _grad_fn = _stub_member("_grad_fn", None)
+    _requires_grad = _stub_member("_requires_grad", False)
+    _retain_grad = _stub_member("_retain_grad", False)
 
     def __init__(self, stub=None, tensor=None):
         self.stub = stub

mindspore/common/_utils.py

@@ -21,7 +21,6 @@ import math
 import ctypes
 import functools
 
-import mindspore
 from mindspore import log as logger
 from mindspore.common import dtype as mstype
 from mindspore.parallel._ps_context import _is_ps_mode, _is_role_pserver, _is_role_sched
@@ -97,16 +96,6 @@ def _jit_fallback_set_attr(class_obj, attr_name, target_obj):
     return target_obj
 
 
-def ones_like(x):
-    """Implement `oneslike`."""
-    return mindspore.ops.composite.ones_like(x)
-
-
-def zeros_like(x):
-    """Implement `zeroslike`."""
-    return mindspore.ops.composite.zeros_like(x)
-
-
 def load_lib(lib_path):
     """load specified library."""
     try:
@@ -120,15 +109,14 @@ def load_lib(lib_path):
 
 def _jit_fallback_next_func(xs):
     """Generate ms_next for xs"""
-    if hasattr(xs, "__next__"):
-        # Convert an iterator to tuple first.
-        xs = tuple(xs)
     return xs[0], xs[1:]
 
 
 def _jit_fallback_has_next_func(xs):
     """Determine whether xs has next value"""
-    if hasattr(xs, "__next__"):
-        # Convert an iterator to tuple first.
-        xs = tuple(xs)
     return len(xs) > 0
+
+
+def _jit_fallback_len_func(obj):
+    """Calculate length for obj"""
+    return len(obj)

mindspore/common/api.py

@@ -40,7 +40,7 @@ from mindspore.common.sparse_tensor import COOTensor as PythonCOOTensor
 from mindspore.common.sparse_tensor import RowTensor as PythonRowTensor
 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, jit_mode_pi_enable, jit_mode_pi_compile
 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
@@ -63,6 +63,14 @@ BROADCAST_PHASE = "_broadcast_"
 _PYNATIVE_PARALLEL_FUNC_NAME = "after_shard"
 
 
+def _ms_adapter_tensor_as_parameter_output(data):
+    """Check whether the data is an output from a parameter which is a ms_adapter tensor.
+       Pylint: disable=unidiomatic-typecheck.
+    """
+    return ms_adapter_registry.is_registered and isinstance(data, ms_adapter_registry.tensor) \
+           and hasattr(data, "__ms_parameter_output__") and getattr(data, "__ms_parameter_output__")
+
+
 def _convert_python_data(data):
     """
     Convert C++ data to python.
@@ -73,8 +81,10 @@ def _convert_python_data(data):
     Returns:
         data, a data convert C++ to python
     """
-    if isinstance(data, Tensor) and data.adapter_flag:
+    if isinstance(data, (Tensor, PythonTensor)) and data.adapter_flag:
         return ms_adapter_registry.tensor(data)
+    if _ms_adapter_tensor_as_parameter_output(data):
+        return data.tensor
     if isinstance(data, Tensor) and not isinstance(data, PythonTensor):
         return PythonTensor(data, internal=True)
     if isinstance(data, CSRTensor) and not isinstance(data, PythonCSRTensor):
@@ -83,7 +93,7 @@ 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, tuple):
+    if data.__class__ is tuple:
         # Handle namedtuple since its type is tuple.
         if hasattr(data, "_fields"):
             type_name = data.__class__.__name__
@@ -91,12 +101,12 @@ def _convert_python_data(data):
             fields = data_dict.keys()
             return namedtuple(type_name, fields)(**_convert_python_data(data_dict))
         return tuple(_convert_python_data(x) for x in data)
-    if isinstance(data, list):
+    if data.__class__ is list:
         # Keep list object not change for inplace operation.
         for i in range(len(data)):
             data[i] = _convert_python_data(data[i])
         return data
-    if isinstance(data, dict):
+    if data.__class__ is dict:
         # Keep the dict object not change.
         keys = tuple(data.keys())
         for key in keys:
@@ -260,7 +270,7 @@ def _get_parameter_layout():
     return layout
 
 
-def _handle_arg(obj, arg):
+def _handle_arg(obj, arg, compile_arg):
     """Handle arg for runtime .If need handle the arg, return True"""
     if isinstance(arg, PythonTensor):
         if arg.has_init:
@@ -269,7 +279,7 @@ def _handle_arg(obj, arg):
             return arg
     elif isinstance(arg, (Tensor, CSRTensor, COOTensor)):
         return arg
-    elif hasattr(arg, "__ms_mutable__") and getattr(arg, "__ms_mutable__"):
+    elif compile_arg is not None and hasattr(compile_arg, "__ms_mutable__") and getattr(compile_arg, "__ms_mutable__"):
         # mutable([]) will be eliminated by FuncGraphSpecializer, and empty list is not supported by backend.
         if isinstance(arg, list) and not arg:
             return None
@@ -282,16 +292,16 @@ def _handle_arg(obj, arg):
     return None
 
 
-def _get_args_for_run(obj, args, kwargs):
+def _get_args_for_run(obj, args, kwargs, compile_args):
     """Get the actual input args and kwargs for runtime."""
     new_args = []
-    for arg in args:
-        new_arg = _handle_arg(obj, arg)
+    for arg, compile_arg in zip(args, compile_args):
+        new_arg = _handle_arg(obj, arg, compile_arg)
         if new_arg is not None:
             new_args.append(new_arg)
 
     for _, value in kwargs.items():
-        new_value = _handle_arg(obj, value)
+        new_value = _handle_arg(obj, value, None)
         if new_value is not None:
             new_args.append(new_value)
 
@@ -329,6 +339,7 @@ class _MindsporeFunctionExecutor:
         self.enable_tuple_broaden = False
         self._graph_executor = GraphExecutor_.get_instance()
         self._create_time = ms_create_time
+        self._compile_args = None
         self.jit_config_dict = jit_config.jit_config_dict if jit_config else None
 
 
@@ -376,6 +387,7 @@ class _MindsporeFunctionExecutor:
 
         # Restore the mutable attr for every arg.
         compile_args = _restore_mutable_attr(args, compile_args)
+        self._compile_args = compile_args
         generate_name, echo_function_name = self._get_generate_name()
         # The full Function name
         full_function_name = generate_name
@@ -414,6 +426,9 @@ class _MindsporeFunctionExecutor:
         update_auto_dynamic_shape_phase_with_check_input_signature(compile_args, key_id, phase, self.input_signature)
 
         if phase in ms_compile_cache:
+            # 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()
             return phase
 
         self._check_recompile(full_function_name, create_time, echo_function_name)
@@ -448,7 +463,9 @@ class _MindsporeFunctionExecutor:
 
         return phase
 
-    def _check_recompile(self, full_function_name, create_time, echo_function_name):
+
+    @staticmethod
+    def _check_recompile(full_function_name, create_time, echo_function_name):
         """Warning when the function has been compiled."""
         ignore_dirs = ["mindspore/ops", "mindspore/nn"]
         if any((lambda x: x in full_function_name)(x) for x in ignore_dirs):
@@ -529,6 +546,7 @@ class _MindsporeFunctionExecutor:
             for i, elem in enumerate(compile_args):
                 if isinstance(elem, PythonTensor):
                     Validator.check_dynamic_shape(compile_args[i], args_list[i], i)
+            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:
@@ -540,6 +558,7 @@ class _MindsporeFunctionExecutor:
                 if isinstance(elem, PythonTensor) and is_shape_unknown(elem.shape):
                     Validator.check_dynamic_shape(self.input_signature[i], args_list[i], i)
                     dyn_shape = True
+            Validator.check_symbolic_shape(self.input_signature, args_list)
             if dyn_shape:
                 # Checkout whether the `sens` has been added to args_list.
                 if len(self.input_signature) == len(args_list) - 1:
@@ -568,7 +587,7 @@ class _MindsporeFunctionExecutor:
         Returns:
             new_inputs, new input args, which are required for running.
         """
-        return _get_args_for_run(self, args_list, kwargs)
+        return _get_args_for_run(self, args_list, kwargs, self._compile_args)
 
 
 # The attributes used to identify a given object.
@@ -596,18 +615,19 @@ def _get_jit_hash(hash_input):
     return _get_obj_id(hash_input)
 
 
-def jit(fn=None, input_signature=None, hash_args=None, jit_config=None, compile_once=False):
+def jit(fn=None, mode="PSJit", input_signature=None, hash_args=None, jit_config=None, compile_once=False):
     """
     Create a callable MindSpore graph from a Python function.
 
     This allows the MindSpore runtime to apply optimizations based on graph.
 
-    Note:
-        If `input_signature` is specified, each input of `fn` must be a Tensor. And the input arguments for `fn`
-        will not accept `**kwargs`.
-
     Args:
         fn (Function): The Python function that will be run as a graph. Default: ``None`` .
+        mode (str): The type of jit used, the value of mode should be ``PIJit`` or ``PSJit``. Default: ``PSJit`` .
+
+            - `PSJit <https://www.mindspore.cn/docs/en/r2.3.q1/note/static_graph_syntax_support.html>`_ : MindSpore GRAPH_MODE.
+            - `PIJit <https://www.mindspore.cn/docs/en/r2.3.q1/design/dynamic_graph_and_static_graph.html>`_ : MindSpore PYNATIVE_MODE.
+
         input_signature (Tensor): The Tensor which describes the input arguments. The shape and dtype of the Tensor
             will be supplied to this function. If input_signature is specified, each input to `fn` must be a `Tensor`.
             And the input parameters of `fn` cannot accept `**kwargs`. The shape and dtype of actual inputs should
@@ -618,9 +638,13 @@ def jit(fn=None, input_signature=None, hash_args=None, jit_config=None, compile_
         jit_config (JitConfig): Jit config for compile. Default: ``None`` .
         compile_once(bool): ``True``: The function would be compiled once when it was created many times.
             But it may be wrong if the free variables were changed. ``False`` : It would be recompiled when
-            it was created again
+            it was created again.
             Default: ``False`` .
 
+    Note:
+        If `input_signature` is specified, each input of `fn` must be a Tensor. And the input arguments for `fn`
+        will not accept `**kwargs`.
+
     Returns:
         Function, if `fn` is not None, returns a callable function that will execute the compiled function; If `fn` is
         None, returns a decorator and when this decorator invokes with a single `fn` argument, the callable function is
@@ -720,9 +744,43 @@ def jit(fn=None, input_signature=None, hash_args=None, jit_config=None, compile_
 
         return staging_specialize
 
+    def pi_wrap_mindspore(decorated):
+        func = decorated
+        if isinstance(func, ms.nn.Cell):
+            func = func.construct
+        if isinstance(func, type) and issubclass(func, ms.nn.Cell):
+            func = func.construct
+        if isinstance(func, types.MethodType):
+            func = func.__func__
+        if not isinstance(func, types.FunctionType):
+            logger.warning("only support function and mindspore.nn.Cell instance")
+            return decorated
+
+        # generator, coroutine, awaitable and a function that return them is unsupported
+        UNSUPPORTED_CODE_TYPE = (inspect.CO_GENERATOR | inspect.CO_COROUTINE |
+                                 inspect.CO_ASYNC_GENERATOR | inspect.CO_ITERABLE_COROUTINE)
+        if func.__code__.co_flags & UNSUPPORTED_CODE_TYPE:
+            return decorated
+
+        config = dict()
+        if isinstance(jit_config, JitConfig):
+            config.update(jit_config.jit_config_dict)
+        elif jit_config is not None:
+            config.update(jit_config)
+        jit_mode_pi_enable()
+
+        if jit_mode_pi_compile(func, config) is False:
+            logger.warning('add fn {} to compile failed '.format(func))
+
+        return decorated
+
+    wrap_func = wrap_mindspore
+    if mode == "PIJit":
+        wrap_func = pi_wrap_mindspore
+
     if fn is not None:
-        return wrap_mindspore(fn)
-    return wrap_mindspore
+        return wrap_func(fn)
+    return wrap_func
 
 
 def ms_function(fn=None, input_signature=None, hash_args=None, jit_config=None):
@@ -732,15 +790,14 @@ def ms_function(fn=None, input_signature=None, hash_args=None, jit_config=None):
     This allows the MindSpore runtime to apply optimizations based on graph.
 
     Note:
-        `ms_function` will be deprecated and removed in a future version. Please use `jit` instead.
-        If `input_signature` is specified, each input of `fn` must be a Tensor. And the input arguments for `fn`
-        will not accept `**kwargs`.
+        - `ms_function` will be deprecated and removed in a future version. Please use :func:`mindspore.jit` instead.
+        - If `input_signature` is specified, each input of `fn` must be a Tensor. And the input arguments for `fn`
+          will not accept `**kwargs`.
 
     Args:
         fn (Function): The Python function that will be run as a graph. Default: ``None`` .
         input_signature (Tensor): The Tensor which describes the input arguments. The shape and dtype of the Tensor
-            will be supplied to this function. If input_signature is specified, each input to `fn` must be a `Tensor`.
-            And the input parameters of `fn` cannot accept `**kwargs`. The shape and dtype of actual inputs should
+            will be supplied to this function. The shape and dtype of actual inputs of `fn` should
             keep the same as input_signature. Otherwise, TypeError will be raised. Default: ``None`` .
         hash_args (Union[Object, List or Tuple of Objects]): The local free variables used inside `fn`,
             like functions or objects of class defined outside `fn`. Calling `fn` again with change of `hash_args`
@@ -909,7 +966,7 @@ def ms_class(cls):
     This allows MindSpore to identify user-defined classes and thus obtain their attributes and methods.
 
     Note:
-        `ms_class` will be deprecated and removed in a future version. Please use `jit_class` instead.
+        `ms_class` will be deprecated and removed in a future version. Please use :func:`mindspore.jit_class` instead.
 
     Args:
         cls (Class): User-defined class.
@@ -1037,6 +1094,8 @@ def set_adapter_config(config):
             ms_adapter_registry.register_parameter(value)
         elif key == "convert_object_map":
             ms_adapter_registry.register_convert_map(value)
+        elif key == "convert_adapter_tensor_map":
+            ms_adapter_registry.register_convert_adapter_tensor_map(value)
         else:
             raise ValueError(f"Unsupported key in adapter config: {key}")
 
@@ -1135,16 +1194,6 @@ class _PyNativeExecutor:
         self._executor = PyNativeExecutor_.get_instance()
         self._executor.set_py_exe_path(sys.executable)
         self._executor.set_kernel_build_server_dir(os.path.split(kernel_build_server.__file__)[0] + os.sep)
-        self._top_cell = None
-
-    def __call__(self):
-        """
-        PyNative executor run grad graph.
-
-        Return:
-            The return object after running grad graph.
-        """
-        return self._executor()
 
     @staticmethod
     def parameter_broadcast(obj, phase):
@@ -1246,7 +1295,7 @@ class _PyNativeExecutor:
         Return:
             None.
         """
-        self._executor.grad_net(grad, obj, weights, grad_position, *args, *(kwargs.values()))
+        return self._executor.grad(grad, obj, weights, grad_position, *args, *(kwargs.values()))
 
     def clear_res(self):
         """
@@ -1380,15 +1429,6 @@ class _PyNativeExecutor:
         """
         self._executor.set_hook_changed(cell)
 
-    def get_top_cell(self):
-        """
-        Get the top cell object.
-
-        Return:
-            The top cell object.
-        """
-        return self._top_cell
-
     def constant_folding(self, *args):
         """
         Get value by infer value.
@@ -1522,7 +1562,7 @@ class _CellGraphExecutor:
         self.enable_tuple_broaden = False
         if hasattr(obj, "enable_tuple_broaden"):
             self.enable_tuple_broaden = obj.enable_tuple_broaden
-        logger.debug("Convert the network.", do_convert)
+        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)
@@ -1531,6 +1571,9 @@ class _CellGraphExecutor:
 
         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_
+            # generated in generate_arguments_key.
+            self._graph_executor.clear_compile_arguments_resource()
             return phase, False
 
         obj.check_names()

mindspore/common/auto_dynamic_shape.py

@@ -182,15 +182,15 @@ class _AutoDynamicShapeManager:
 
     def _compare_input_args_and_cache_args(self, input_args, cache_args):
         """compare input args and cache args"""
-        for (input, cache) in zip(input_args, cache_args):
-            if isinstance(input, Tensor) and isinstance(cache, Tensor):
-                if not self.is_tensor_equal(input, cache):
+        for (arg, cache) in zip(input_args, cache_args):
+            if isinstance(arg, Tensor) and isinstance(cache, Tensor):
+                if not self.is_tensor_equal(arg, cache):
                     return False
-            elif isinstance(input, int) and isinstance(cache, int):
-                if input != cache:
+            elif isinstance(arg, int) and isinstance(cache, int):
+                if arg != cache:
                     return False
-            elif isinstance(input, (tuple, list)) and isinstance(cache, (tuple, list)):
-                if not self._compare_input_args_and_cache_args(input, cache):
+            elif isinstance(arg, (tuple, list)) and isinstance(cache, (tuple, list)):
+                if not self._compare_input_args_and_cache_args(arg, cache):
                     return False
         return True
 
@@ -287,21 +287,21 @@ class _AutoIdentifyDynamicShape:
 
 
     @staticmethod
-    def _do_generalize_in_sink(arg, cache, input_index, cache_index, cache_type):
+    def _do_generalize_in_sink(input_arg, cache, input_index, cache_index, cache_type):
         """do generalize in sink, input rank must be 2"""
-        if not arg:
+        if not input_arg:
             raise ValueError("In sink mode, cell input can not be scalar.")
 
-        if arg == cache:
+        if input_arg == cache:
             return cache
 
         shape_value = []
-        if len(arg) != len(cache):
+        if len(input_arg) != len(cache):
             shape_value.append(SHAPE_RANK_ANY)
         else:
-            for _ in arg:
+            for _ in input_arg:
                 shape_value.append(SHAPE_DIM_ANY)
-        logger.info((f'In the {cache_type} cache[{cache_index}], the {input_index}th input tensor shape is {arg},'
+        logger.info((f'In the {cache_type} cache[{cache_index}], the {input_index}th input tensor shape is {input_arg},'
                      f'cache shape is {cache}, not equal, need generalize to {shape_value}.'))
         return shape_value
 
@@ -312,6 +312,20 @@ class _AutoIdentifyDynamicShape:
         self.auto_dynamic_shape_manager.update_phase_and_compile_args(args, phase, self.save_cache_number,
                                                                       is_sink_mode, aux)
 
+    def _check_real_shape_cache(self, res_shape, args_list):
+        """find cache in real_shape_cache"""
+        real_cache_number = self.auto_dynamic_shape_manager.get_real_shape_cache_number()
+        if real_cache_number < 2:
+            logger.info((f'real shape cache cap is {real_cache_number}, smaller than 2, '
+                         f'compile args shape={res_shape}.'))
+            return True
+
+        is_real_shape_exist = self.auto_dynamic_shape_manager.find_compile_args_in_shape_cache(args_list, "real")
+        if is_real_shape_exist:
+            logger.debug((f'find compile args in real shape cache, compile args shape={res_shape}'))
+            return True
+
+        return False
 
     def _generate_with_generalize_shape(self, generalize_shape_args, is_sink_mode, args_list):
         """generate with generalize_shape """
@@ -440,7 +454,6 @@ class _AutoIdentifyDynamicShape:
         return generalize_one_shape, True
 
 
-
     def _do_generalize_shape(self, cache_type, input_args, is_sink_mode):
         """do generalize shape by cache"""
         shape_cache = self.auto_dynamic_shape_manager.get_cache_by_type(cache_type)