mindspore 2.0.0a0__cp39-cp39-win_amd64.whl → 2.0.0rc1__cp39-cp39-win_amd64.whl

mindspore/common/api.py

@@ -1,6 +1,6 @@
 # This is the Python adaptation and derivative work of Myia (https://github.com/mila-iqia/myia/).
 #
-# Copyright 2020-2021 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.
@@ -24,6 +24,7 @@ import time
 import ast
 import inspect
 import importlib
+import hashlib
 from collections import OrderedDict
 from functools import wraps
 import numpy as np
@@ -35,15 +36,17 @@ from mindspore.common.tensor import Tensor as PythonTensor
 from mindspore.common.sparse_tensor import CSRTensor as PythonCSRTensor
 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, MetaTensor, CSRTensor, RowTensor, COOTensor, \
+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
+    _ms_memory_recycle, _bind_device_ctx
 from mindspore.parallel._ps_context import _is_role_sched
 from mindspore.parallel._utils import _check_full_batch, _get_parameter_broadcast, _is_pynative_parallel, \
     _get_pipeline_stages, _is_in_auto_parallel_mode
-from mindspore._checkparam import Validator
+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._register_for_adapter import ms_adapter_registry
 
 # store ms_function class compiled pipeline cache
 ms_compile_cache = set()
@@ -64,6 +67,8 @@ def _convert_python_data(data):
     Returns:
         data, a data convert C++ to python
     """
+    if isinstance(data, Tensor) and data.adapter_flag:
+        return ms_adapter_registry.tensor(data)
     if isinstance(data, Tensor) and not isinstance(data, PythonTensor):
         return PythonTensor(data, internal=True)
     if isinstance(data, CSRTensor) and not isinstance(data, PythonCSRTensor):
@@ -102,7 +107,8 @@ def _wrap_func(fn):
 
 def _check_all_tensor(sequence):
     for element in sequence:
-        if not isinstance(element, Tensor) and not (isinstance(element, tuple) and _check_all_tensor(element)):
+        if not isinstance(element, Tensor) and not is_stub_tensor(element) and not (isinstance(element, tuple)
+                                                                                    and _check_all_tensor(element)):
             return False
     return True
 
@@ -116,28 +122,28 @@ def _handle_func_args(func, *args, **kwargs):
         bound_arguments.apply_defaults()
         args = bound_arguments.args
         kwargs = bound_arguments.kwargs
-        # After apply_defaults, kwargs should be empty here.
-        if kwargs:
-            raise ValueError(f"Failed to handle kwargs of {func.__name__}. Maybe you pass wrong arguments, "
-                             f"or there is a key in kwargs that is not used as a function argument, "
-                             f"args: {args}, kwargs: {kwargs}")
 
     positional_args = 0
     default_args = 0
+    has_var = False
     for value in inspect.signature(func).parameters.values():
         if value.kind is inspect.Parameter.VAR_POSITIONAL or value.kind is inspect.Parameter.VAR_KEYWORD:
-            return args
+            has_var = True
         if value.kind is inspect.Parameter.POSITIONAL_OR_KEYWORD:
             if value.default is inspect.Parameter.empty:
                 positional_args += 1
             else:
                 default_args += 1
+
+    if has_var:
+        return args, kwargs
+
     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
+    return args, kwargs
 
 
 sys_path = list(sys.path)
@@ -163,7 +169,8 @@ def __get_compile_cache_dep_files(file_path, compile_cache_dep_files, pkg):
     for node in ast.iter_child_nodes(root):
         module_name = ""
         if isinstance(node, ast.ImportFrom):
-            module_name = node.module
+            if node.module is not None:
+                module_name = node.module
             if node.level == 1:
                 module_name = "." + module_name
         elif not isinstance(node, ast.Import):
@@ -235,25 +242,42 @@ def _get_parameter_layout():
     return layout
 
 
-def _get_args_for_run(obj, args_list):
-    """Get the actual input args for runtime."""
-    inputs = []
-    for i in args_list:
-        if isinstance(i, PythonTensor):
-            if i.has_init:
-                i.init_data()
-            if not i.const_arg:
-                inputs.append(i)
-        elif isinstance(i, (Tensor, CSRTensor, COOTensor)):
-            inputs.append(i)
-        elif hasattr(i, "__ms_mutable__") and getattr(i, "__ms_mutable__"):
-            inputs.append(i)
-        elif context.get_context("grad_for_scalar") and isinstance(i, (int, float)):
-            inputs.append(i)
-        elif hasattr(obj, "enable_tuple_broaden") and obj.enable_tuple_broaden and isinstance(i, tuple) and \
-                _check_all_tensor(i):
-            inputs.append(i)
-    return inputs
+def _handle_arg(obj, arg):
+    """Handle arg for runtime .If need handle the arg, return True"""
+    if isinstance(arg, PythonTensor):
+        if arg.has_init:
+            arg.init_data()
+        if not arg.const_arg:
+            return arg
+    elif isinstance(arg, (Tensor, CSRTensor, COOTensor)):
+        return arg
+    elif hasattr(arg, "__ms_mutable__") and getattr(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
+        return arg
+    elif context.get_context("grad_for_scalar") 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):
+        return arg
+    return None
+
+
+def _get_args_for_run(obj, args, kwargs):
+    """Get the actual input args and kwargs for runtime."""
+    new_args = []
+    for arg in args:
+        new_arg = _handle_arg(obj, arg)
+        if new_arg is not None:
+            new_args.append(new_arg)
+
+    for _, value in kwargs.items():
+        new_value = _handle_arg(obj, value)
+        if new_value is not None:
+            new_args.append(new_value)
+
+    return new_args
 
 
 class _MindsporeFunctionExecutor:
@@ -291,24 +315,42 @@ class _MindsporeFunctionExecutor:
         self.jit_config_dict = jit_config.jit_config_dict if jit_config else None
 
     @_wrap_func
-    def __call__(self, *args):
+    def __call__(self, *args, **kwargs):
         args_list = args
         if self.obj is not None:
             args_list = args_list[1:]
-        _pynative_executor.set_ms_function_compile_status(True)
-        phase = self.compile(args_list, self.fn.__name__)
-        _pynative_executor.set_ms_function_compile_status(False)
+        phase = ""
+        try:
+            if context.get_context("mode") == context.PYNATIVE_MODE:
+                _pynative_executor.set_ms_function_compile_status(True, phase)
+                phase = self.compile(self.fn.__name__, *args_list, **kwargs)
+                _pynative_executor.set_ms_function_compile_status(False, phase)
+            else:
+                phase = self.compile(self.fn.__name__, *args_list, **kwargs)
+        except Exception as err:
+            _pynative_executor.clear_res()
+            raise err
+
         if context.get_context("precompile_only"):
             return None
-        new_inputs = self._generate_run_args(args_list)
+
+        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:
-            _pynative_executor.set_graph_phase(phase)
             output = _pynative_executor.grad_ms_function(output, *new_inputs)
 
+        enable_ge = os.getenv("MS_ENABLE_GE") == "1"
+        if enable_ge and self.jit_config_dict is None:
+            raise RuntimeError("GE and jit_level=O3 should be used together, but jit_config is None.")
+        if self.jit_config_dict:
+            enable_jit_level_o3 = self.jit_config_dict.get('jit_level') == "O3"
+            if (enable_ge and not enable_jit_level_o3) or (not enable_ge and enable_jit_level_o3):
+                raise RuntimeError("GE and jit_level=O3 should be used together, but got MS_ENABLE_GE={}, jit_level={}".
+                                   format(os.getenv("MS_ENABLE_GE"), self.jit_config_dict.get('jit_level')))
+
         return output
 
-    def compile(self, args_list, method_name):
+    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"):
@@ -317,12 +359,12 @@ class _MindsporeFunctionExecutor:
                                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_list)
+        compile_args = self._generate_compile_args(args)
         # Restore the mutable attr for every arg.
-        compile_args = _restore_mutable_attr(args_list, compile_args)
+        compile_args = _restore_mutable_attr(args, compile_args)
 
         generate_name = self.fn.__module__ + "." + self.fn.__name__ + "." + self.fn.__code__.co_filename + "." + \
-                        str(self.fn.__code__.co_firstlineno) + '.' + str(id(self.fn))
+            str(self.fn.__code__.co_firstlineno)
         if _pynative_executor.grad_flag():
             generate_name = generate_name + ".grad"
         if _is_pynative_parallel():
@@ -348,7 +390,7 @@ class _MindsporeFunctionExecutor:
             self.enable_tuple_broaden = self.obj.enable_tuple_broaden
 
         self._graph_executor.set_enable_tuple_broaden(self.enable_tuple_broaden)
-        key = self._graph_executor.generate_arguments_key(compile_args, self.enable_tuple_broaden)
+        key = self._graph_executor.generate_arguments_key(self.fn, compile_args, kwargs, self.enable_tuple_broaden)
         phase = generate_name + '.' + str(key)
         if phase in ms_compile_cache:
             return phase
@@ -359,11 +401,11 @@ class _MindsporeFunctionExecutor:
             self._graph_executor.set_jit_config(self.jit_config_dict)
 
         if self.obj is None:
-            is_compile = self._graph_executor.compile(self.fn, compile_args, phase, True)
+            is_compile = self._graph_executor.compile(self.fn, compile_args, kwargs, phase, True)
         else:
             if isinstance(self.obj, ms.nn.Cell):
                 self._graph_executor.set_weights_values(self.obj.parameters_dict())
-            is_compile = self._graph_executor.compile(self.obj, compile_args, phase, True)
+            is_compile = self._graph_executor.compile(self.obj, compile_args, kwargs, phase, True)
 
         if not is_compile:
             raise RuntimeError("Executor compile failed.")
@@ -393,47 +435,51 @@ class _MindsporeFunctionExecutor:
         # Case: If the shape of input args is dynamic, get dynamic shape tensor from context and use it to compile.
         compile_args = args_list
         # Case: The `set_inputs()` of Cell object has been set, using these dynamic shape args as compile args.
-        if isinstance(self.obj, ms.nn.Cell) and self.obj.get_inputs():
+        if self.fn.__name__ == 'construct' and isinstance(self.obj, ms.nn.Cell) and self.obj.get_inputs():
             compile_args = self.obj.get_inputs()
-            for args in compile_args:
-                Validator.check_isinstance("args set in `set_inputs()` of Cell", args, PythonTensor)
-            Validator.check_dynamic_shape(compile_args, args_list)
+            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)}.")
+            for i, elem in enumerate(compile_args):
+                if isinstance(elem, PythonTensor):
+                    Validator.check_dynamic_shape(compile_args[i], args_list[i], i)
+
         # Case: If dynamic shape tensors have been assigned to `input_signature`, they are preferred as compile args.
         if self.input_signature is not None:
             if not isinstance(self.input_signature, (tuple, list)):
                 self.input_signature = (self.input_signature,)
             self.input_signature = list(self.input_signature)
             dyn_shape = False
-            for sig_args in self.input_signature:
-                Validator.check_isinstance("args in `input_signature` of `jit` decorator", sig_args, MetaTensor)
-                if is_shape_unknown(sig_args.shape):
+            for i, elem in enumerate(self.input_signature):
+                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
-            if not dyn_shape:
-                if not verify_inputs_signature(self.input_signature, args_list):
-                    raise ValueError("The input args is incompatible with the args in `input_signature`!")
-            else:
+            if dyn_shape:
                 # Checkout whether the `sens` has been added to args_list.
                 if len(self.input_signature) == 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(self.input_signature)}`. The last actual args may "
-                                   f"be `sens` and added it to compile args.")
+                    logger.warning(f"The number of actual input args '{len(args_list)}' is one more than the number "
+                                   f"of input_signature args '{len(self.input_signature)}'. The last actual args may "
+                                   f"be 'sens' and added it to compile args.")
                     self.input_signature.append(args_list[-1])
-                Validator.check_dynamic_shape(self.input_signature, args_list)
                 compile_args = tuple(self.input_signature)
-                _pynative_executor.set_dynamic_input(self.obj, *compile_args)
+                _pynative_executor.set_dynamic_input(self.obj)
+            else:
+                if not verify_inputs_signature(self.input_signature, 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):
+    def _generate_run_args(self, args_list, kwargs):
         """
         Generate input args, which are required for running.
 
         Args:
             args_list (Tuple): Actual input args.
+            kwargs (Dict): Actual input kwargs.
 
         Returns:
             new_inputs, new input args, which are required for running.
         """
-        return _get_args_for_run(self, args_list)
+        return _get_args_for_run(self, args_list, kwargs)
 
 
 # The attributes used to identify a given object.
@@ -551,14 +597,15 @@ def jit(fn=None, input_signature=None, hash_args=None, jit_config=None):
             if os.getenv("MS_JIT") == '0':
                 return func(*args, **kwargs)
 
-            args = _handle_func_args(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]
             # only the function or cell instance wrapped by shard will fall into this branch
             if _is_pynative_parallel() and func.__name__ == _PYNATIVE_PARALLEL_FUNC_NAME:
                 process_obj = hash_args
-            out = _MindsporeFunctionExecutor(func, hash_obj, input_signature, process_obj, jit_config)(*args)
+            out = _MindsporeFunctionExecutor(func, hash_obj, input_signature, process_obj, jit_config)(*args, **kwargs)
             return out
 
         return staging_specialize
@@ -648,7 +695,7 @@ def ms_function(fn=None, input_signature=None, hash_args=None, jit_config=None):
         ...     closure_fn(inputs, func)
     """
 
-    logger.warning("'mindspore.ms_function' will be deprecated and removed in a future version. " \
+    logger.warning("'mindspore.ms_function' will be deprecated and removed in a future version. "
                    "Please use 'mindspore.jit' instead.")
     return jit(fn=fn, input_signature=input_signature, hash_args=hash_args, jit_config=jit_config)
 
@@ -719,7 +766,7 @@ def _add_flags(fn=None, **flags):
     return ret
 
 
-def no_recursive(callable_obj):
+def _no_recursive(callable_obj):
     """
     Method or function decorator for ignoring recursive check.
 
@@ -794,7 +841,7 @@ def ms_class(cls):
         20
     """
 
-    logger.warning("'mindspore.ms_class' will be deprecated and removed in a future version. " \
+    logger.warning("'mindspore.ms_class' will be deprecated and removed in a future version. "
                    "Please use 'mindspore.jit_class' instead.")
 
     # Check if cls is of type class.
@@ -821,8 +868,8 @@ def jit_class(cls):
         Class.
 
     Raises:
-        TypeError: If jit_class is used for non-class types or nn.Cell.
-        AttributeError: If the private attributes or magic methods of the class decorated with jit_class is called.
+        TypeError: If `jit_class` is used for non-class types or nn.Cell.
+        AttributeError: If the private attributes or magic methods of the class decorated with `jit_class` is called.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -864,6 +911,25 @@ def jit_class(cls):
     return cls
 
 
+def set_adapter_config(config):
+    """
+    Register configuration information for MSAdapter.
+
+    Args:
+        config (dict): Configuration information.
+    """
+    if not isinstance(config, dict):
+        raise TypeError(f"The input argument of 'set_adapter_config' should be a dict, but got {config}.")
+    for key, value in config.items():
+        if key == "Tensor":
+            setattr(value, "__adapter_tensor__", True)
+            ms_adapter_registry.register_tensor(value)
+        elif key == "convert_object_map":
+            ms_adapter_registry.register_convert_map(value)
+        else:
+            raise ValueError(f"Unsupported key in adapter config: {key}")
+
+
 def _function_forbid_reuse(func):
     if not inspect.isfunction(func):
         raise TypeError(f'Decorator _function_forbid_reuse can only be used for function type, but got {func}.')
@@ -937,7 +1003,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._optimizer = None
         self._top_cell = None
 
     def __call__(self):
@@ -976,6 +1041,19 @@ class _PyNativeExecutor:
         """
         return self._executor.real_run_op(*args)
 
+    def run_op_async(self, prim, args):
+        """
+        Run single op async.
+
+        Args:
+            prim (Primitive): Op primitive
+            args (tuple): input arguments.
+
+        Return:
+            StubNode, result of run op.
+        """
+        return self._executor.run_op_async(prim, args)
+
     def new_graph(self, obj, *args, **kwargs):
         """
         Initialize resources for building forward and backward graph.
@@ -1005,7 +1083,7 @@ class _PyNativeExecutor:
         """
         self._executor.end_graph(obj, output, *args, *(kwargs.values()))
 
-    def check_run(self, grad, obj, grad_hash_id, *args, **kwargs):
+    def check_run(self, grad, obj, weights, grad_hash_id, *args, **kwargs):
         """
         Whether the forward graph need to construct.
 
@@ -1019,7 +1097,7 @@ class _PyNativeExecutor:
         Return:
             bool, specifies whether the forward graph need to construct.
         """
-        return self._executor.check_run(grad, obj, grad_hash_id, *args, *(kwargs.values()))
+        return self._executor.check_run(grad, obj, weights, grad_hash_id, *args, *(kwargs.values()))
 
     def grad(self, obj, grad, weights, grad_position, *args, **kwargs):
         """
@@ -1082,18 +1160,6 @@ class _PyNativeExecutor:
         """
         return self._executor.grad_ms_function(output, *args)
 
-    def set_graph_phase(self, phase):
-        """
-        Set the phase of cell/function instance.
-
-        Args:
-            phase (str): The phase of cell/function instance.
-
-        Return:
-            None.
-        """
-        self._executor.set_graph_phase(phase)
-
     def grad_flag(self):
         """
         The flag of building grad graph.
@@ -1115,29 +1181,29 @@ class _PyNativeExecutor:
         """
         self._executor.set_grad_flag(flag)
 
-    def set_ms_function_compile_status(self, status):
+    def set_ms_function_compile_status(self, status, phase):
         """
         Set ms_function is compiling
 
         Args:
             status(bool): ms_function compile status
+            phase (str): The phase of cell/function instance.
         Return:
             None.
         """
-        self._executor.set_ms_function_compile_status(status)
+        self._executor.set_ms_function_compile_status(status, phase)
 
-    def set_dynamic_input(self, obj, *args):
+    def set_dynamic_input(self, obj):
         """
         Set dynamic shape tensor of input arguments.
 
         Args:
             obj (Function/Cell): The function or cell instance.
-            args (tuple): Function or cell dynamic input arguments.
 
         Return:
             None.
         """
-        self._executor.set_dynamic_input(obj, *args)
+        self._executor.set_dynamic_input(obj)
 
     def is_first_cell(self):
         """
@@ -1161,14 +1227,6 @@ class _PyNativeExecutor:
         """
         self._executor.set_hook_changed(cell)
 
-    def get_optimizer(self):
-        """
-        Get the optimizer.
-
-        Return:
-            The optimizer.
-        """
-        return self._optimizer
 
     def get_top_cell(self):
         """
@@ -1179,17 +1237,6 @@ class _PyNativeExecutor:
         """
         return self._top_cell
 
-    def get_shape(self, *args):
-        """
-        Get shape of input arguments.
-
-        Args:
-            args (Tensor/tuple(Tensor)): Input arguments.
-
-        Return:
-            tuple(int), the shape of input arguments.
-        """
-        return self._executor.get_shape(*args)
 
     def constant_folding(self, *args):
         """
@@ -1291,16 +1338,17 @@ class _CellGraphExecutor:
         if "train" in phase and (enable_compile_cache is True or enable_compile_cache == "1"):
             self._graph_executor.set_compile_cache_dep_files(_get_compile_cache_dep_files())
 
-    def compile(self, obj, *args, phase='predict', do_convert=True, jit_config_dict=None):
+    def compile(self, obj, *args, phase='predict', do_convert=True, jit_config_dict=None, **kwargs):
         """
         Compiles graph.
 
         Args:
             obj (Function/Cell): The function or cell instance need compile.
-            args (tuple): Function or cell input arguments.
             phase (str): The name of compile phase. Default: 'predict'.
             do_convert (bool): When set to True, convert ME graph to GE graph after compiling graph.
             jit_config_dict (dict): Jit config for compile. Default: None.
+            args (tuple): Args of the Cell object.
+            kwargs (dict): Kwargs of the Cell object.
 
         Return:
             Str, the full phase of the cell.
@@ -1310,14 +1358,13 @@ class _CellGraphExecutor:
         if not hasattr(obj, obj.__parse_method__):
             raise AttributeError(
                 'The class {} dose not have method {}'.format(obj.__class__.__name__, obj.__parse_method__))
-        args_list = args
 
         self.enable_tuple_broaden = False
         if hasattr(obj, "enable_tuple_broaden"):
             self.enable_tuple_broaden = obj.enable_tuple_broaden
 
         self._graph_executor.set_enable_tuple_broaden(self.enable_tuple_broaden)
-        key = self._graph_executor.generate_arguments_key(args_list, self.enable_tuple_broaden)
+        key = self._graph_executor.generate_arguments_key(obj, args, kwargs, self.enable_tuple_broaden)
         obj.arguments_key = str(key)
         phase = phase + '.' + str(obj.create_time) + '.' + str(id(obj)) + '.' + obj.arguments_key
 
@@ -1327,14 +1374,14 @@ class _CellGraphExecutor:
 
         obj.check_names()
         _check_full_batch()
-        self._set_dataset_mode(args_list)
+        self._set_dataset_mode(args)
         self._set_compile_cache_dep_files(phase)
 
         enable_ge = context.get_context("enable_ge")
         self._graph_executor.set_weights_values(obj.parameters_dict())
         if jit_config_dict:
             self._graph_executor.set_jit_config(jit_config_dict)
-        result = self._graph_executor.compile(obj, args_list, phase, self._use_vm_mode())
+        result = self._graph_executor.compile(obj, args, kwargs, phase, self._use_vm_mode())
         obj.compile_cache.add(phase)
         if not result:
             raise RuntimeError("Executor compile failed.")
@@ -1411,6 +1458,8 @@ class _CellGraphExecutor:
         Run the specific graph.
 
         Args:
+            obj (Cell): The cell object.
+            args (tuple): Args of the Cell object.
             phase (str): The phase name. Default: 'predict'.
 
         Returns:
@@ -1425,31 +1474,33 @@ class _CellGraphExecutor:
             return self._exec_pip(obj, *args, phase=phase_real)
         raise KeyError('{} graph is not exist.'.format(phase_real))
 
-    def del_net_res(self, net_id):
-        self._graph_executor.del_net_res(net_id)
+    def del_net_res(self, obj, net_id):
+        """Clear the memory resource of a network."""
+        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 (
+                'obf_random_seed' not in self.obfuscate_config.keys()):
+            raise ValueError("'obf_ratio' and 'obf_random_seed' must be in obfuscate_config.")
+        obf_random_seed = self.obfuscate_config.get('obf_random_seed')
+        if obf_random_seed == 0:
+            branch_control_input = 0
+        else:
+            branch_control_input = _generate_branch_control_input(obf_random_seed)
+        return branch_control_input
 
-    def _get_func_graph_proto(self, obj, exec_id, ir_type="onnx_ir", use_prefix=False):
+    def _get_func_graph_proto(self, obj, exec_id, ir_type="onnx_ir", use_prefix=False, incremental=False):
         """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
         if self.obfuscate_config is not None:
-            if ('obf_ratio' not in self.obfuscate_config.keys()) or (
-                    'obf_password' not in self.obfuscate_config.keys()):
-                raise ValueError("'obf_ratio' and 'obf_password' must be in obfuscate_config.")
-            obf_password = self.obfuscate_config.get('obf_password')
-            if obf_password == 0:
-                append_password = 0
-            else:
-                seed_max = 2 ** 32 - 1
-                int_max = 2 ** 31 - 1
-                np.random.seed(obf_password % seed_max)
-                append_password = np.random.randint(int_max)
-                obf_password %= int_max
-            return self._graph_executor.get_obfuscate_func_graph_proto(exec_id, self.obfuscate_config['obf_ratio'],
-                                                                       obf_password, append_password)
-        return self._graph_executor.get_func_graph_proto(exec_id, ir_type)
+            branch_control_input = self._get_branch_control_input()
+            return self._graph_executor.get_obfuscate_func_graph_proto(exec_id, incremental,
+                                                                       self.obfuscate_config['obf_ratio'],
+                                                                       branch_control_input)
+        return self._graph_executor.get_func_graph_proto(exec_id, ir_type, incremental)
 
     def get_optimize_graph_proto(self, obj):
         """Return optimize graph binary proto."""
@@ -1472,12 +1523,6 @@ class _CellGraphExecutor:
         """
         self._graph_executor.export_graph(file_name, graph_id, encrypt_func, enc_key)
 
-    def fetch_info_for_quant_export(self, exec_id):
-        """Get graph proto from pipeline."""
-        if self._graph_executor.has_compiled(exec_id) is False:
-            return None
-        return self._graph_executor.fetch_info_for_quant_export(exec_id)
-
 
 def ms_memory_recycle():
     """
@@ -1487,15 +1532,44 @@ def ms_memory_recycle():
     To recycle these cached memory, users can call this function after training of one model.
     """
     if ms_compile_cache:
-        _cell_graph_executor.del_net_res(ms_compile_cache)
+        _cell_graph_executor.del_net_res(None, ms_compile_cache)
         ms_compile_cache.clear()
     for cell_cache in cells_compile_cache.values():
         if cell_cache:
-            _cell_graph_executor.del_net_res(cell_cache)
+            _cell_graph_executor.del_net_res(None, cell_cache)
             cell_cache.clear()
     _ms_memory_recycle()
 
 
+def _generate_branch_control_input(obf_random_seed):
+    """Generate append network input for dynamic obfuscation in random seed mode."""
+    seed_max = 2 ** 32 - 1
+    int_max = 2 ** 31 - 1
+    np.random.seed(obf_random_seed % seed_max)
+    # generate a string as hash function inputs
+    word_repo = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" + "abcdefghigklmnopqrstuvwxyz" + "0123456789"
+    repo_len = len(word_repo)
+    sha_string = ''
+    string_len = 1024 * 1024
+    for _ in range(string_len):
+        rand_index = np.random.randint(0, repo_len)
+        sha_string += word_repo[rand_index]
+    # get hash result
+    sha_result = hashlib.sha256(sha_string.encode('utf-8')).hexdigest()  # len is 64
+    branch_control_input = 1
+    hex_base = 16
+    for item in sha_result:
+        if int(item, hex_base) > 0:
+            branch_control_input *= int(item, hex_base)
+    branch_control_input %= int_max
+    return branch_control_input
+
+
+def _bind_device_context():
+    """Bind device context to current thread"""
+    _bind_device_ctx()
+
+
 _cell_graph_executor = _CellGraphExecutor()
 _pynative_executor = _PyNativeExecutor()