mindspore 1.10.0__cp38-cp38-win_amd64.whl → 2.0.0rc1__cp38-cp38-win_amd64.whl

mindspore/nn/cell.py

@@ -29,18 +29,42 @@ from mindspore import log as logger
 from mindspore.common.parameter import PARAMETER_NAME_DEFAULT
 from mindspore.common.hook_handle import HookHandle
 from mindspore.context import ParallelMode
-from mindspore.ops.composite import Shard
 from mindspore import context
 from mindspore._c_expression import init_pipeline, update_func_graph_hyper_params, Cell_, FuncGraph, MixedPrecisionType
-from mindspore._checkparam import Validator
+from mindspore import _checkparam as Validator
 from mindspore.common import dtype as mstype
 from mindspore.common.api import _cell_graph_executor, _pynative_executor, _get_args_for_run, cells_compile_cache
+from mindspore.common.api import _generate_branch_control_input
 from mindspore.common.parameter import Parameter, ParameterTuple
 from mindspore.common.tensor import Tensor
 from mindspore.ops.operations import Cast
 from mindspore.ops.primitive import Primitive
 from mindspore.ops.operations import _inner_ops as inner
-from mindspore.parallel._tensor import _load_tensor_by_layout
+from mindspore.parallel.shard import Shard
+from mindspore._check_jit_forbidden_api import jit_forbidden_register
+
+
+def _check_args(args):
+    """Check the input args's type"""
+    index = 1
+    for item in args:
+        if isinstance(item, Tensor) and item.has_init:
+            item.init_data()
+        elif isinstance(item, numpy.ndarray):
+            suffix = "th"
+            if index == 1:
+                suffix = "st"
+            elif index == 2:
+                suffix = "nd"
+            elif index == 3:
+                suffix = "rd"
+
+            input_index = str(index) + suffix
+            raise TypeError(f"For 'Cell', inputs should not be numpy array. Only support bool, int, float, None, "
+                            f"Tensor, Parameter, mstype.Number(mstype.bool, mstype.int, mstype.float, mstype.uint"
+                            f"), and tuple or list containing only these types, and dict whose values are these "
+                            f"types, but the {input_index} arg type is {type(item)}.")
+        index += 1
 
 
 class Cell(Cell_):
@@ -54,11 +78,14 @@ class Cell(Cell_):
     PYNATIVE_MODE (dynamic graph mode).
 
     Args:
-        auto_prefix (bool): Whether to automatically generate NameSpace for Cell and its subcells. It will affect the
-                      name of the parameter in the network. If set to True, the network parameter
-                      name will be prefixed, otherwise it will not. Default: True.
-        flags (dict): Network configuration information, currently it is used for the binding of network and dataset.
-                      Users can also customize network attributes by this parameter. Default: None.
+        auto_prefix (bool, optional): Whether to automatically generate NameSpace for Cell and its child cells. It also
+                      affects the names of parameters in the `Cell`. If set to True, the parameter name will be
+                      automatically prefixed, otherwise not. In general, the backbone network should be set to True,
+                      otherwise the duplicate name problem will appear. The cell to train the backbone network, such as
+                      optimizer and :class:`mindspore.nn.TrainOneStepCell`, should be set to False, otherwise the
+                      parameter name in backbone will be changed by mistake. Default: True.
+        flags (dict, optional): Network configuration information, currently it is used for the binding of network
+                      and dataset. Users can also customize network attributes by this parameter. Default: None.
 
     Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
@@ -84,12 +111,11 @@ class Cell(Cell_):
         [Parameter (name=weight, shape=(240, 120, 4, 4), dtype=Float32, requires_grad=True)]
     """
 
-    IGNORE_LIST = ['_scope', '_cell_init_args', '_auto_prefix', '_cells', '_params', '_construct_inputs_names',
-                   '_construct_inputs_num', '_create_time', '_func_graph_flags', '_parallel_inputs_run',
-                   '_parameter_layout_dict', '_params_list', '_tensor_list', '_phase', '_auto_parallel_mode',
+    IGNORE_LIST = ['_scope', '_cell_init_args', '_auto_prefix', '_cells', '_params', '_create_time',
+                   '_func_graph_flags', '_parameter_layout_dict', '_params_list', '_tensor_list', '_phase',
                    '_forward_pre_hook', '_forward_hook', '_enable_forward_pre_hook', '_enable_forward_hook',
                    '_bprop_debug', '_enable_backward_hook', '_cell_backward_hook', '_is_run', '_param_prefix',
-                   '_attr_synced', 'pynative', 'requires_grad', '_auto_parallel_compile_and_run', 'cell_type']
+                   '_attr_synced', 'pynative', 'requires_grad', 'cell_type']
 
     def __init__(self, auto_prefix=True, flags=None):
         Cell_.__init__(self, self._cell_tag)
@@ -123,10 +149,6 @@ class Cell(Cell_):
         if os.getenv('GC_COLLECT_IN_CELL') == '1':
             gc.collect()
 
-        self._construct_inputs_num = 0
-        self._construct_inputs_names = []
-        self._auto_parallel_mode = False
-        self._parallel_inputs_run = None
         if flags:
             self.add_flags(**flags)
         self._bprop_debug = False
@@ -136,8 +158,8 @@ class Cell(Cell_):
         self._enable_forward_hook = False
         self._enable_backward_hook = False
         self._cell_backward_hook = None
+        self._is_recursion_hook = False
         self.cell_type = None
-        self._auto_parallel_compile_and_run = False
         self.cast = Cast()
         self._has_config_recompute = False
         self._user_parameters = []
@@ -145,6 +167,7 @@ class Cell(Cell_):
         self.saved_dynamic_shape = None
         self._jit_config_dict = dict()
         self.grad_ops_label = False
+        self.to_float_fp16 = False
 
     def __getstate__(self):
         base = Cell_.__getstate__(self)
@@ -156,6 +179,9 @@ class Cell(Cell_):
         self.__dict__ = dict_
         self._attr_synced = False
 
+    def __bool__(self):
+        return True
+
     @property
     def _cell_tag(self):
         # `<class 'xxxxxxx'>` to `xxxxxxx`
@@ -310,8 +336,6 @@ class Cell(Cell_):
         if '_params' in self.__dict__:
             params = self.__dict__['_params']
             if name in params:
-                if context._get_mode() == context.PYNATIVE_MODE:
-                    return self.cast_param(params[name])
                 return params[name]
         if '_cells' in self.__dict__:
             cells = self.__dict__['_cells']
@@ -320,27 +344,23 @@ class Cell(Cell_):
         if '_tensor_list' in self.__dict__:
             tensor_list = self.__dict__['_tensor_list']
             if name in tensor_list:
-                return self.cast_param(tensor_list[name])
+                return tensor_list[name]
         if '_params_list' in self.__dict__:
             params_list = self.__dict__['_params_list']
             if name in params_list:
-                para_list = params_list[name]
-                cast_list = list()
-                for para in para_list:
-                    cast_list.append(self.cast_param(para))
-                para_list = ParameterTuple(cast_list)
-                return para_list
+                return ParameterTuple(params_list[name])
         raise AttributeError("The '{}' object has no attribute '{}'.".format(type(self).__name__, name))
 
     def __del__(self):
-        if context.get_context is not None and context._get_mode() == context.PYNATIVE_MODE:
-            _pynative_executor.del_cell(self)
-
         # while deepcopy a cell instance, the copied cell instance can't be added to cells_compile_cache
         # here using pop(id(self), None) to avoid KeyError exception
         cells_compile_cache.pop(id(self), None)
-        if self.compile_cache:
-            _cell_graph_executor.del_net_res(self.compile_cache)
+        try:
+            if self.compile_cache:
+                _cell_graph_executor.del_net_res(self, self.compile_cache)
+        except AttributeError as e:
+            raise AttributeError(f"The '{type(self).__name__}' object does not inherit attribute from 'cell'. "
+                                 f"Please use 'super().__init__()'.") from e
 
     def __delattr__(self, name):
         if name in self._params:
@@ -391,7 +411,7 @@ class Cell(Cell_):
     def _do_parameter_broadcast(self):
         if context.get_auto_parallel_context("parallel_mode") == ParallelMode.DATA_PARALLEL:
             if not self.parameter_broadcast_done:
-                _pynative_executor.parameter_broadcast(self, self.phase, self._auto_parallel_mode)
+                _pynative_executor.parameter_broadcast(self, self.phase)
                 self.parameter_broadcast_done = True
 
     def run_construct(self, cast_inputs, kwargs):
@@ -427,39 +447,51 @@ class Cell(Cell_):
             output = self._run_forward_hook(cast_inputs, output)
         return output
 
-    def _check_construct_args(self, *inputs, **kwargs):
+    def _check_construct_args(self, *args):
         """Check the args needed by the function construct"""
-        if kwargs:
-            raise ValueError(f"For 'Cell', expect no kwargs here, maybe you pass wrong arguments, "
-                             f"or there is a key in kwargs that is not used as a function argument. "
-                             f"args: {inputs}, kwargs: {kwargs}")
         positional_args = 0
         default_args = 0
+        has_var = False
         for value in inspect.signature(self.construct).parameters.values():
             if value.kind is inspect.Parameter.VAR_POSITIONAL or value.kind is inspect.Parameter.VAR_KEYWORD:
-                return
+                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 len(inputs) < positional_args:
+        if has_var:
+            return
+
+        if len(args) < positional_args:
             raise TypeError(f"For 'Cell', the function construct requires {positional_args} positional argument, "
-                            f"but got {len(inputs)}. When using set_inputs, please make sure that all networks "
+                            f"but got {len(args)}. When using set_inputs, please make sure that all networks "
                             f"and loss functions are configured with set_inputs.")
 
-        if len(inputs) > positional_args + default_args:
+        if len(args) > positional_args + default_args:
+            construct_inputs_names = self.construct.__code__.co_varnames
+            if 'self' not in construct_inputs_names:
+                raise TypeError(f"For 'Cell', the method 'construct' must have parameter 'self'. ")
+
             raise TypeError(f"For 'Cell', the function construct requires {positional_args} positional argument and "
                             f"{default_args} default argument, total {positional_args + default_args}, "
-                            f"but got {len(inputs)}.")
+                            f"but got {len(args)}.")
 
     def _hook_fn_registered(self):
-        if self._enable_forward_pre_hook or self._enable_forward_hook or self._enable_backward_hook:
-            return True
-        for cell in self.cells():
-            if cell._hook_fn_registered():
+        '''Hook function in graph mode'''
+        # Check super().__init__() in graph mode.
+        try:
+            if self._enable_forward_pre_hook or self._enable_forward_hook or self._enable_backward_hook:
                 return True
+        except AttributeError as e:
+            raise AttributeError(f"The '{type(self).__name__}' object does not inherit attribute from 'cell'. "
+                                 f"Please use 'super().__init__()'.") from e
+        if not self._is_recursion_hook:
+            self._is_recursion_hook = True
+            for cell in self.cells():
+                if cell._hook_fn_registered():
+                    return True
         return False
 
     def _get_prims_recursively(self):
@@ -494,7 +526,7 @@ class Cell(Cell_):
         for prim in all_prims:
             prim.add_prim_attr("strategy_gen_mode", "data_parallel")
 
-    def shard(self, in_strategy, out_strategy, parameter_plan=None, device="Ascend", level=0):
+    def shard(self, in_strategy, out_strategy=None, parameter_plan=None, device="Ascend", level=0):
         """
         Defining the input and output layouts of this cell and the parallel strategies of remaining ops will be
         generated by sharding propagation. In PyNative mode, use this method
@@ -508,11 +540,13 @@ class Cell(Cell_):
         Note:
             Only effective in PYNATIVE_MODE and in either ParallelMode.AUTO_PARALLEL with
             search_mode in auto_parallel_context set as sharding_propagation.
+            If the input contain Parameter, its strategy should be set in `in_strategy`.
 
         Args:
             in_strategy (tuple): Define the layout of inputs, each element of the tuple should be a tuple or None. Tuple
                              defines the layout of the corresponding input and None represents a data parallel strategy.
-            out_strategy (tuple): Define the layout of outputs similar with in_strategy.
+            out_strategy (Union[None, tuple]): Define the layout of outputs similar with in_strategy.
+                                               It is not in use right now. Default: None.
             parameter_plan (Union[dict, None]): Define the layout for the specified parameters. Each element in dict
                                                 defines the layout of the parameter like "param_name: layout".
                                                 The key is a parameter name of type 'str'.
@@ -552,7 +586,11 @@ class Cell(Cell_):
             ...     x = self.block2(x)
             ...     return x
         """
-        # Transfer parameter_plan from dict to tuple
+        if context.get_context("mode") != context.PYNATIVE_MODE or \
+                context.get_auto_parallel_context("parallel_mode") not in ["auto_parallel"]:
+            raise AssertionError(f"Cell shard only supports auto parallel under PyNative mode. "
+                                 f"Please check if you call Cell.shard in the script.")
+
         shard_fn = Shard()
         fn = shard_fn(self, in_strategy, out_strategy, parameter_plan, device, level)
         object.__setattr__(self, "_shard_fn", fn)
@@ -568,6 +606,8 @@ class Cell(Cell_):
         Returns:
             Tuple, the inputs after data type cast.
         """
+        msg = f"'auto_cast_inputs' is deprecated from version 2.0 and will be removed in a future version."
+        logger.warning(msg)
         cast_inputs = inputs
         mixed_type = self.get_mixed_precision_type()
         if mixed_type == MixedPrecisionType.FP16:
@@ -577,32 +617,10 @@ class Cell(Cell_):
 
         return cast_inputs
 
-    def _check_args(self, args):
-        """Check the input args's type"""
-        index = 1
-        for item in args:
-            if isinstance(item, Tensor) and item.has_init:
-                item.init_data()
-            elif isinstance(item, numpy.ndarray):
-                suffix = "th"
-                if index == 1:
-                    suffix = "st"
-                elif index == 2:
-                    suffix = "nd"
-                elif index == 3:
-                    suffix = "rd"
-
-                input_index = str(index) + suffix
-                raise TypeError(f"For 'Cell', inputs should not be numpy array. Only support bool, int, float, None, "
-                                f"Tensor, Parameter, mstype.Number(mstype.bool, mstype.int, mstype.float, mstype.uint"
-                                f"), and tuple or list containing only these types, and dict whose values are these "
-                                f"types, but the {input_index} arg type is {type(item)}.")
-            index += 1
-
     def __call__(self, *args, **kwargs):
         if self.__class__.construct is Cell.construct:
-            logger.warning(f"The '{self.__class__}' does not override the method 'construct', "
-                           f"it will call the super class(Cell) 'construct'.")
+            raise AttributeError("For 'Cell', the method 'construct' is not defined.")
+
         if kwargs:
             bound_arguments = inspect.signature(self.construct).bind(*args, **kwargs)
             bound_arguments.apply_defaults()
@@ -610,34 +628,33 @@ class Cell(Cell_):
             kwargs = bound_arguments.kwargs
 
         # Run in Graph mode.
-        if context._get_mode() == context.GRAPH_MODE:
-            self._check_construct_args(*args, **kwargs)
+        if os.getenv("MS_JIT") != '0' and context._get_mode() == context.GRAPH_MODE:
+            self._check_construct_args(*args)
             if self._hook_fn_registered():
                 logger.warning(f"For 'Cell', it's not support hook function in graph mode. If you want to use hook "
                                f"function, please use context.set_context to set pynative mode.")
-            out = self.compile_and_run(*args)
+            out = self.compile_and_run(*args, **kwargs)
             return out
 
         # Run in PyNative mode.
         if _pynative_executor.is_first_cell():
-            _pynative_executor.set_lazy_build(True)
             _pynative_executor._optimizer = getattr(self, "optimizer", None)
             _pynative_executor._top_cell = self
-            # There many Casts in parameter_broadcast. Enable lazy_build and build faster.
+            # There many Casts in parameter_broadcast. Enable build faster.
             self._do_parameter_broadcast()
 
-        self._check_args(args)
+        _check_args(args)
+        self._check_cell_flags_in_pynative()
 
         if self.requires_grad:
             _pynative_executor.set_grad_flag(True)
 
         if self._dynamic_shape_inputs is not None:
-            self._check_compile_dynamic_shape(*args)
+            self._check_compile_dynamic_shape(self._dynamic_shape_inputs, args)
 
         try:
             _pynative_executor.new_graph(self, *args, **kwargs)
-            cast_inputs = self.auto_cast_inputs(args)
-            output = self._run_construct(cast_inputs, kwargs)
+            output = self._run_construct(args, kwargs)
             _pynative_executor.end_graph(self, output, *args, **kwargs)
         except Exception as err:
             _pynative_executor.clear_res()
@@ -647,6 +664,12 @@ class Cell(Cell_):
             output = output.data
         return output
 
+    def _check_cell_flags_in_pynative(self):
+        """Check the flags added to cell in pynative mode"""
+        if hasattr(self, "_func_graph_flags") and self._func_graph_flags.get("output_no_recompute"):
+            raise TypeError("Recompute is not supported in PyNative mode currently, you can use "
+                            "'context.set_context(mode=context.GRAPH_MODE)' or @jit to set graph mode.")
+
     def _add_attr(self, name, value):
         if name and name[:2] != '__' and name not in Cell.IGNORE_LIST:
             super(Cell, self)._add_attr(name, value)
@@ -829,84 +852,19 @@ class Cell(Cell_):
         """
         Replace parameters with sliced tensors by parallel strategies.
 
-        Please refer to the usage in source code of `mindspore.common._CellGraphExecutor.compile`.
-
-        Args:
-            params (dict): The parameters dictionary used for initializing the data graph.
-        """
-        if params is None:
-            params = self.parameters_dict()
-        if isinstance(params, OrderedDict):
-            for key in params:
-                tensor = params[key].data
-                if key not in self.parameter_layout_dict:
-                    logger.info("The layout dict does not contain the key %s.", key)
-                    continue
-                if params[key].sliced:
-                    logger.debug("The param %s is already sliced.", key)
-                    continue
-                layout = self.parameter_layout_dict[key]
-                new_tensor = _load_tensor_by_layout(tensor, layout)
-                params[key].set_data(new_tensor, True)
-        else:
-            raise TypeError("For 'load_parameter_slice', the argument 'params' must be OrderedDict type, "
-                            "but got {}.".format(type(params)))
-
-    def _load_inputs(self, *inputs):
+        Note:
+            This interface is deprecated.
         """
-        Slice inputs tensors by parallel strategies.
-
-        Args:
-            inputs (Function or Cell): inputs of construct method.
-        """
-        parallel_inputs_run = []
-        # judge if *args exists in input
-        if self.argspec[1] is not None:
-            prefix = self.argspec[1]
-            for i in range(len(inputs)):
-                key = prefix + str(i)
-                self._construct_inputs_names = self._construct_inputs_names + (key,)
-                self._construct_inputs_num = self._construct_inputs_num + 1
-        for i, tensor in enumerate(inputs):
-            key = self._construct_inputs_names[i]
-            # if input is not used, self.parameter_layout_dict may not contain the key
-            if key not in self.parameter_layout_dict:
-                logger.warning("Layout dict does not contain the key %s.", key)
-                parallel_inputs_run.append(tensor)
-            else:
-                layout = self.parameter_layout_dict[key]
-                new_tensor = _load_tensor_by_layout(tensor, layout)
-                parallel_inputs_run.append(new_tensor)
-        return tuple(parallel_inputs_run)
+        logger.warning("'load_parameter_slice' function is deprecated.")
 
     def set_parallel_input_with_inputs(self, *inputs):
         """
         Slice inputs tensors by parallel strategies.
 
-        Args:
-            inputs (tuple): inputs of construct method.
-        """
-        self._parallel_inputs_run = self._load_inputs(*inputs)
-
-    def _get_construct_inputs_number_and_name(self):
-        """Compute self._construct_inputs_names and self._construct_inputs_num"""
-        from mindspore._extends.parse.parser import get_parse_method_of_class
-
-        fn = get_parse_method_of_class(self)
-        self.argspec = inspect.getfullargspec(fn)
-        self._construct_inputs_num = fn.__code__.co_argcount
-        self._construct_inputs_names = fn.__code__.co_varnames
-
-        if self._construct_inputs_num <= 0:
-            raise ValueError(f"For 'set_auto_parallel', the number of inputs must be greater than 0,"
-                             f"but got {self._construct_inputs_num}.")
-        if self._construct_inputs_names[0] != 'self':
-            raise ValueError(f"First member of fn function must be self, but got {self._construct_inputs_names[0]}")
-        if self._construct_inputs_num - 1 > len(self._construct_inputs_names):
-            raise ValueError(f"Num of inputs must be greater than num of fn function members, num of inputs is \
-                {self._construct_inputs_names - 1}, num of fn function members is {len(self._construct_inputs_names)}")
-        self._construct_inputs_names = self._construct_inputs_names[1:self._construct_inputs_num]
-        self._construct_inputs_num = self._construct_inputs_num - 1
+        Note:
+            This interface is deprecated.
+        """
+        logger.warning("'set_parallel_input_with_inputs' function is deprecated.")
 
     def set_inputs(self, *inputs):
         """
@@ -917,8 +875,8 @@ class Cell(Cell_):
         Args:
             inputs (tuple): Inputs of the Cell object.
 
-        Note:
-            This is an experimental interface that is subject to change or deletion.
+        .. warning::
+            This is an experimental API that is subject to change or deletion.
 
         Examples:
             >>> import numpy as np
@@ -949,7 +907,7 @@ class Cell(Cell_):
         if self._dynamic_shape_inputs:
             ds.config.set_dynamic_shape(True)
         if context._get_mode() == context.PYNATIVE_MODE:
-            _pynative_executor.set_dynamic_input(self, *self._dynamic_shape_inputs)
+            _pynative_executor.set_dynamic_input(self)
 
     def get_inputs(self):
         """
@@ -958,36 +916,31 @@ class Cell(Cell_):
         Returns:
             inputs (tuple), Inputs of the Cell object.
 
-        Note:
-            This is an experimental interface that is subject to change or deletion.
+        .. warning::
+            This is an experimental API that is subject to change or deletion.
         """
 
         return self._dynamic_shape_inputs
 
-    def compile(self, *inputs):
+    def compile(self, *args, **kwargs):
         """
         Compile Cell as a computation graph, the input must be consistent with the input defined in construct.
 
         Args:
-            inputs (tuple): Inputs of the Cell object.
+            args (tuple): Args of the Cell object.
+            kwargs (dict): Kwargs of the Cell object.
         """
-        if self._dynamic_shape_inputs is None or self._dynamic_shape_inputs[0] is None:
-            _cell_graph_executor.compile(self, *inputs, phase=self.phase, auto_parallel_mode=self._auto_parallel_mode,
-                                         jit_config_dict=self._jit_config_dict)
+        if self._dynamic_shape_inputs is None:
+            _cell_graph_executor.compile(self, phase=self.phase,
+                                         jit_config_dict=self._jit_config_dict, *args, **kwargs)
         else:
-            self._check_compile_dynamic_shape(*inputs)
-            if self.saved_dynamic_shape:
-                for i in range(len(self.saved_dynamic_shape)):
-                    if self.saved_dynamic_shape[i].shape != self._dynamic_shape_inputs[i].shape:
-                        return
-
+            self._check_compile_dynamic_shape(self._dynamic_shape_inputs, args)
             self.saved_dynamic_shape = self._dynamic_shape_inputs
             _cell_graph_executor.compile(self, *self._dynamic_shape_inputs, phase=self.phase,
-                                         auto_parallel_mode=self._auto_parallel_mode,
-                                         jit_config_dict=self._jit_config_dict)
+                                         jit_config_dict=self._jit_config_dict, **kwargs)
             logger.debug("Compiled Graph with dynamic shape")
 
-    def compile_and_run(self, *inputs):
+    def compile_and_run(self, *args, **kwargs):
         """
         Compile and run Cell, the input must be consistent with the input defined in construct.
 
@@ -995,25 +948,25 @@ class Cell(Cell_):
             It is not recommended to call directly.
 
         Args:
-            inputs (tuple): Inputs of the Cell object.
+            args (tuple): Args of the Cell object.
+            kwargs (dict): Kwargs of the Cell object.
 
         Returns:
             Object, the result of executing.
         """
-        self._auto_parallel_compile_and_run = True
-        self.compile(*inputs)
+        self.compile(*args, **kwargs)
 
-        new_inputs = _get_args_for_run(self, inputs)
-        return _cell_graph_executor(self, *new_inputs, phase=self.phase)
+        new_args = _get_args_for_run(self, args, kwargs)
+        return _cell_graph_executor(self, *new_args, phase=self.phase)
 
     def auto_parallel_compile_and_run(self):
         """
         Whether or not to execute compile and run in 'AUTO_PARALLEL' or 'SEMI_AUTO_PARALLEL' mode.
 
-        Returns:
-            bool, `_auto_parallel_compile_and_run` value.
+        Note:
+            This interface is deprecated.
         """
-        return self._auto_parallel_compile_and_run
+        logger.warning("'auto_parallel_compile_and_run' function is deprecated.")
 
     def exec_checkpoint_graph(self):
         """Executes saving checkpoint graph operation."""
@@ -1063,6 +1016,8 @@ class Cell(Cell_):
         Returns:
             Parameter, the input parameter with type automatically cast.
         """
+        msg = f"'cast_param' is deprecated from version 2.0 and will be removed in a future version."
+        logger.warning(msg)
         mixed_type = self.get_mixed_precision_type()
         if mixed_type != MixedPrecisionType.NOTSET:
             if mixed_type == MixedPrecisionType.FP32:
@@ -1084,8 +1039,12 @@ class Cell(Cell_):
 
         Raises:
             KeyError: Child Cell's name is incorrect or duplicated with the other child name.
+            TypeError: If type of `child_name` is not str.
             TypeError: Child Cell's type is incorrect.
         """
+        if not isinstance(child_name, str):
+            raise TypeError(f"For 'insert_child_to_cell', the type of parameter 'child_name' must be str, "
+                            f"but got {type(child_name)}.")
         if not child_name or '.' in child_name:
             raise KeyError("For 'insert_child_to_cell', the parameter 'child_name' can not be None and "
                            "can not contain '.'")
@@ -1097,7 +1056,7 @@ class Cell(Cell_):
                             f"but got type {type(child_cell)}.")
         self._cells[child_name] = child_cell
 
-    def construct(self, *inputs, **kwargs):
+    def construct(self, *args, **kwargs):
         """
         Defines the computation to be performed. This method must be overridden by all subclasses.
 
@@ -1105,7 +1064,7 @@ class Cell(Cell_):
             It is not supported currently that inputs contain both tuple and non-tuple types at same time.
 
         Args:
-            inputs (tuple): Tuple of variable parameters.
+            args (tuple): Tuple of variable parameters.
             kwargs (dict): Dictionary of variable keyword parameters.
 
         Returns:
@@ -1158,15 +1117,7 @@ class Cell(Cell_):
         def _updata(param):
             if param in replace:
                 return replace.get(param)
-            layout = None
-            set_sliced = False
-            if auto_parallel_mode:
-                set_sliced = True
-                if param.name not in self.parameter_layout_dict:
-                    logger.debug("Layout dict does not contain the key %s.", param.name)
-                else:
-                    layout = self.parameter_layout_dict[param.name]
-            new_p = param.init_data(layout, set_sliced=set_sliced)
+            new_p = param.init_data(None, set_sliced=False)
             replace[param] = new_p
             return new_p
 
@@ -1265,6 +1216,7 @@ class Cell(Cell_):
                 param.is_init = False
             param.name = prefix + name
 
+    @jit_forbidden_register
     def trainable_params(self, recurse=True):
         """
         Returns all trainable parameters.
@@ -1279,6 +1231,7 @@ class Cell(Cell_):
         """
         return list(filter(lambda x: x.requires_grad, self.get_parameters(expand=recurse)))
 
+    @jit_forbidden_register
     def untrainable_params(self, recurse=True):
         """
         Returns all untrainable parameters.
@@ -1293,6 +1246,7 @@ class Cell(Cell_):
         """
         return list(filter(lambda x: not x.requires_grad, self.get_parameters(expand=recurse)))
 
+    @jit_forbidden_register
     def get_parameters(self, expand=True):
         """
         Returns an iterator over cell parameters.
@@ -1484,6 +1438,38 @@ class Cell(Cell_):
         if "fp32" in flags and flags.get("fp32", False):
             self._set_mixed_precision_type_recursive(MixedPrecisionType.FP32)
 
+    def apply(self, fn):
+        """
+        Applies fn recursively to every subcell (as returned by .cells()) as well as self.
+        Typical use includes initializing the parameters of a model.
+
+        Args:
+            fn (function): function to be applied to each subcell.
+
+        Returns:
+            Cell, self.
+
+        Examples:
+            >>> import mindspore.nn as nn
+            >>> from mindspore.common.initializer import initializer, One
+            >>> net = nn.SequentialCell(nn.Dense(2, 2), nn.Dense(2, 2))
+            >>> def func(cell):
+            ...     if isinstance(cell, nn.Dense):
+            ...         cell.weight.set_data(initializer(One(), cell.weight.shape, cell.weight.dtype))
+            >>> net.apply(func)
+            SequentialCell<
+              (0): Dense<input_channels=2, output_channels=2, has_bias=True>
+              (1): Dense<input_channels=2, output_channels=2, has_bias=True>
+              >
+            >>> print(net[0].weight.asnumpy())
+            [[1. 1.]
+             [1. 1.]]
+        """
+        for cell in self.cells():
+            cell.apply(fn)
+        fn(self)
+        return self
+
     def add_flags(self, **flags):
         """
         Add customized attributes for cell.
@@ -1538,7 +1524,7 @@ class Cell(Cell_):
         Add cast on all inputs of cell and child cells to run with certain float type.
 
         If `dst_type` is `mindspore.dtype.float16`, all the inputs of Cell, including input, Parameter and Tensor, will
-        be cast to float16. Please refer to the usage in source code of :func:`mindspore.build_train_network`.
+        be cast to float16. Please refer to the usage in source code of :func:`mindspore.amp.build_train_network`.
 
         Note:
             Multiple calls will overwrite.
@@ -1554,7 +1540,7 @@ class Cell(Cell_):
             ValueError: If dst_type is not mstype.float32 or mstype.float16.
 
         Supported Platforms:
-        ``Ascend`` ``GPU`` ``CPU``
+            ``Ascend`` ``GPU`` ``CPU``
 
         Examples:
             >>> import mindspore.nn as nn
@@ -1570,8 +1556,10 @@ class Cell(Cell_):
                              "but got {}.".format(dst_type))
         if dst_type == mstype.float16:
             self._set_mixed_precision_type_recursive(MixedPrecisionType.FP16)
+            self.to_float_fp16 = True
         else:
             self._set_mixed_precision_type_recursive(MixedPrecisionType.FP32)
+            self.to_float_fp16 = False
         flags = {'fp16': dst_type == mstype.float16, 'fp32': dst_type == mstype.float32}
         self._add_init_args(**flags)
         return self
@@ -1582,7 +1570,7 @@ class Cell(Cell_):
         accelerate the algorithm in the algorithm library.
 
         If `boost_type` is not in the algorithm library, please view the algorithm in the algorithm library through
-        `algorithm library <https://gitee.com/mindspore/mindspore/tree/r1.10/mindspore/python/mindspore/boost>`_.
+        `algorithm library <https://gitee.com/mindspore/mindspore/tree/r2.0/mindspore/python/mindspore/boost>`_.
 
         Note:
             Some acceleration algorithms may affect the accuracy of the network, please choose carefully.
@@ -1627,6 +1615,10 @@ class Cell(Cell_):
         for training and predicting, such as `BatchNorm`, will distinguish between the branches by this attribute. If
         set to true, the training branch will be executed, otherwise another branch.
 
+        Note:
+            When execute function Model.train(), framework will call Cell.set_train(True).
+            When execute function Model.eval(), framework will call Cell.set_train(False).
+
         Args:
             mode (bool): Specifies whether the model is training. Default: True.
 
@@ -1655,11 +1647,9 @@ class Cell(Cell_):
         Set the cell to auto parallel mode.
 
         Note:
-            If a cell needs to use the auto parallel or semi auto parallel mode for training, evaluation or prediction,
-            this interface needs to be called by the cell.
+            This interface is deprecated.
         """
-        self._auto_parallel_mode = True
-        self._get_construct_inputs_number_and_name()
+        logger.warning("'set_auto_parallel' function is deprecated.")
 
     def set_jit_config(self, jit_config):
         """
@@ -1672,6 +1662,11 @@ class Cell(Cell_):
             logger.warning("For Cell, jit config can only be set once, ignore this setting.")
         else:
             self._jit_config_dict = jit_config.jit_config_dict
+            enable_ge = os.getenv("MS_ENABLE_GE") == '1'
+            enable_jit_level_o3 = self._jit_config_dict.get('jit_level') == "O3"
+            if (not enable_ge and enable_jit_level_o3) or (enable_ge and not enable_jit_level_o3):
+                raise RuntimeError("GE and jit_level=O3 should be used together, but got MS_ENABLE_GE={}, jie_level={}".
+                                   format(os.getenv("MS_ENABLE_GE"), self.jit_config_dict.get('jit_level')))
 
     def flatten_weights(self, fusion_size=0):
         """
@@ -1695,7 +1690,7 @@ class Cell(Cell_):
         Register forward pre hook function for Cell object.
 
         Note:
-            - The `register_forward_pre_hook(hook_fn)` does not work in graph mode or ms_function.
+            - The `register_forward_pre_hook(hook_fn)` does not work in graph mode or functions decorated with 'jit'.
             - 'hook_fn' must be defined as the following code.
               `cell_id` is the information of registered Cell object, including name and ID. `inputs` is the forward
               input objects passed to the Cell. The 'hook_fn' can modify the forward input objects by returning new
@@ -1758,7 +1753,7 @@ class Cell(Cell_):
             raise TypeError(f"When using 'register_forward_pre_hook(hook_fn)', the type of 'hook_fn' must be python "
                             f"function, but got {type(hook_fn)}.")
         if hook_fn.__code__.co_name == "staging_specialize":
-            raise TypeError(f"Decorating hook function {hook_fn.__name__} with '@ms_function' is not supported.")
+            raise TypeError(f"Decorating hook function {hook_fn.__name__} with '@jit' is not supported.")
 
         self._enable_forward_pre_hook = True
         _pynative_executor.set_hook_changed(self)
@@ -1797,7 +1792,7 @@ class Cell(Cell_):
         Set the Cell forward hook function.
 
         Note:
-            - The `register_forward_hook(hook_fn)` does not work in graph mode or ms_function.
+            - The `register_forward_hook(hook_fn)` does not work in graph mode or functions decorated with 'jit'.
             - 'hook_fn' must be defined as the following code.
               `cell_id` is the information of registered Cell object, including name and ID. `inputs` is the forward
               input objects passed to the Cell. `output` is the forward output object of the Cell. The 'hook_fn' can
@@ -1862,7 +1857,7 @@ class Cell(Cell_):
             raise TypeError(f"When using 'register_forward_hook(hook_fn)', the type of 'hook_fn' must be python "
                             f"function, but got {type(hook_fn)}.")
         if hook_fn.__code__.co_name == "staging_specialize":
-            raise TypeError(f"Decorating hook function {hook_fn.__name__} with '@ms_function' is not supported.")
+            raise TypeError(f"Decorating hook function {hook_fn.__name__} with '@jit' is not supported.")
 
         self._enable_forward_hook = True
         _pynative_executor.set_hook_changed(self)
@@ -1899,7 +1894,7 @@ class Cell(Cell_):
         Register the backward hook function.
 
         Note:
-            - The `register_backward_hook(hook_fn)` does not work in graph mode or ms_function.
+            - The `register_backward_hook(hook_fn)` does not work in graph mode or functions decorated with 'jit'.
             - The 'hook_fn' must be defined as the following code.
               `cell_id` is the information of registered Cell object, including name and ID. `grad_input` is the
               gradient passed to the Cell. `grad_output` is the gradient computed and passed to the next Cell or
@@ -2002,6 +1997,7 @@ class Cell(Cell_):
 
         Note:
             It only works when a running task is in the parameter server mode.
+            It is only supported in graph mode.
 
         Args:
             recurse (bool): Whether sets the trainable parameters of subcells. Default: True.
@@ -2083,9 +2079,6 @@ class Cell(Cell_):
         """
         Set the cell recomputed.
         """
-        if context._get_mode() == context.PYNATIVE_MODE:
-            raise TypeError("Recompute is not supported in pynative mode currently, you can use "
-                            "'context.set_context(mode=context.GRAPH_MODE)' to set graph mode.")
         Validator.check_bool(mode)
         Validator.check_bool(output_recompute)
         if not self._has_config_recompute:
@@ -2184,35 +2177,86 @@ class Cell(Cell_):
                 params.append(param)
         return params
 
-    def _check_compile_dynamic_shape(self, *inputs):
+    def place(self, role, rank_id):
         """
-        Check if graph has been compiled with dynamic shape.
+        Set the label for all operators in this cell.
+        This label tells MindSpore compiler on which process this cell should be launched.
+        And each process's identical label consists of input `role` and `rank_id`.
+        So by setting different cells with different labels, which will be launched on different processes,
+        users can launch a distributed training or predicting job.
+
+        Note:
+            - This method is effective only after
+              `mindspore.communication.init()` is called for dynamic cluster building.
 
         Args:
-            inputs (tuple): Inputs of the Cell object.
+            role (str): The role of the process on which this cell will be launched.
+                        Only 'MS_WORKER' is supported for now.
+            rank_id (int): The rank id of the process on which this cell will be launched.
+                           The rank is unique in processes with the same role.
+
+        Examples:
+            >>> from mindspore import context
+            >>> import mindspore.nn as nn
+            >>> context.set_context(mode=context.GRAPH_MODE)
+            >>> fc = nn.Dense(2, 3)
+            >>> fc.place('MS_WORKER', 0)
+        """
+        all_ops = self._get_prims_recursively()
+        for op in all_ops:
+            op.place(role, rank_id)
+
+    def _check_dynamic_tensor(self, set_input, net_input, index):
         """
-        set_inputs_len = len(self._dynamic_shape_inputs)
-        inputs_len = len(inputs)
-        if set_inputs_len != inputs_len:
-            raise ValueError("The number of 'set_input' Tensor must be equal to network's inputs."
-                             f"but got 'set_inputs': {set_inputs_len} and network's input: {inputs_len}.")
-        for index, (net_input, set_input) in enumerate(zip(inputs, self._dynamic_shape_inputs)):
+        Check if tensor is correctly set for dynamic shape.
+
+        Args:
+            set_input (Tensor): Tensor set for dynamic shape.
+            net_input (Tensor): Input tensor of the Cell object.
+            index (int): Tensor index for set inputs.
+        """
+        if not isinstance(net_input, Tensor):
+            raise TypeError(
+                f"The {index + 1}th input type of 'set_inputs' must be Tensor, but got {type(net_input)}.")
+        if set_input.dtype != net_input.dtype:
+            raise ValueError(
+                f"The {index + 1}th input type of 'set_inputs' must be the same as network's input, "
+                f"but got 'set_inputs': {set_input.dtype} and network's input: {net_input.dtype}.")
+        if net_input.dim() != 0 and set_input.dim() != net_input.dim():
+            raise ValueError(
+                f"The {index + 1}th input dims of 'set_inputs' must be the same as network's input, "
+                f"but got 'set_inputs': {set_input.dim()} and network's input: {net_input.dim()}.")
+        if not all([ele1 in (-1, ele2) for ele1, ele2 in zip(set_input.shape, net_input.shape)]):
+            raise ValueError(
+                f"The {index + 1}th input shape of 'set_inputs' must be the same as network's input, "
+                f"but got 'set_inputs': {set_input.shape} and network's input: {net_input.shape}.")
+
+    def _check_compile_dynamic_shape(self, set_inputs, net_inputs):
+        """
+        Check if graph has been compiled with dynamic shape.
+
+        Args:
+            net_inputs (tuple): Inputs of the Cell object.
+        """
+        set_inputs_len = len(set_inputs)
+        net_inputs_len = len(net_inputs)
+        if set_inputs_len != net_inputs_len:
+            raise ValueError("The length of 'set_inputs' must be equal to network's inputs, "
+                             f"but got 'set_inputs': {set_inputs_len} and network's input: {net_inputs_len}.")
+        for index, (set_input, net_input) in enumerate(zip(set_inputs, net_inputs)):
             if isinstance(set_input, Tensor):
-                if not isinstance(net_input, Tensor):
+                self._check_dynamic_tensor(set_input, net_input, index)
+            elif isinstance(set_input, (tuple, list)):
+                if not isinstance(net_input, (tuple, list)):
                     raise TypeError(
-                        f"The {index + 1}th input type of 'set_inputs' must be Tensor, but got {type(net_input)}.")
-                if set_input.dtype is not net_input.dtype:
-                    raise ValueError(
-                        f"The {index + 1}th input type of 'set_inputs' must be the same as network's input, "
-                        f"but got 'set_inputs': {set_input.dtype} and network's input: {net_input.dtype}.")
-                if net_input.dim() != 0 and set_input.dim() != net_input.dim():
-                    raise ValueError(
-                        f"The {index + 1}th input dims of 'set_inputs' must be the same as network's input, "
-                        f"but got 'set_inputs': {set_input.dim()} and network's input: {net_input.dim()}.")
-                if not all([ele1 in (-1, ele2) for ele1, ele2 in zip(set_input.shape, net_input.shape)]):
+                        f"The {index + 1}th input type of 'set_inputs' must be tuple or list, "
+                        f"but got {type(net_input)}.")
+                self._check_compile_dynamic_shape(set_input, net_input)
+            else:
+                if net_input != set_input:
                     raise ValueError(
-                        f"The {index + 1}th input shape of 'set_inputs' must be the same as network's input, "
-                        f"but got 'set_inputs': {set_input.shape} and network's input: {net_input.shape}.")
+                        f"The {index + 1}th input of 'set_inputs' must be the same with network's input, but got "
+                        f"set_inputs: {set_input} and network's input: {net_input}.")
 
 
 class GraphCell(Cell):
@@ -2228,6 +2272,11 @@ class GraphCell(Cell):
             The key is the parameter name whose type is str, and the value is a Tensor or Parameter.
             If the parameter exists in the graph according to the name, update it's value.
             If the parameter does not exist, ignore it. Default: None.
+        obf_random_seed (Union[int, None]): The random seed used for dynamic obfuscation. "dynamic obfuscation" is
+            used for model protection, which can refer to :func:`mindspore.obfuscate_model`. If the input `graph` is
+            a func_graph loaded from a mindir file obfuscated with `obf_random_seed` , then `obf_random_seed` should be
+            provided. `obf_random_seed` should be in (0, 9223372036854775807]. default: None.
+
     Raises:
         TypeError: If the `graph` is not a FuncGraph.
         TypeError: If the `params_init` is not a dict.
@@ -2242,7 +2291,8 @@ class GraphCell(Cell):
         >>> import mindspore as ms
         >>> import mindspore.nn as nn
         >>> from mindspore import Tensor
-        >>>
+        >>> from mindspore import context
+        >>> context.set_context(mode=context.GRAPH_MODE)
         >>> net = nn.Conv2d(1, 1, kernel_size=3, weight_init="ones")
         >>> input = Tensor(np.ones([1, 1, 3, 3]).astype(np.float32))
         >>> ms.export(net, input, file_name="net", file_format="MINDIR")
@@ -2254,13 +2304,23 @@ class GraphCell(Cell):
            [6. 9. 6.]
            [4. 6. 4.]]]]
     """
-    def __init__(self, graph, params_init=None):
+
+    def __init__(self, graph, params_init=None, obf_random_seed=None):
         super(GraphCell, self).__init__(auto_prefix=True)
         if not isinstance(graph, FuncGraph):
             raise TypeError(f"For 'GraphCell', the argument 'graph' must be a FuncGraph loaded from MindIR, "
                             f"but got type {type(graph)}.")
         self.graph = graph
-
+        self.obf_random_seed = obf_random_seed
+        if obf_random_seed is not None:
+            if not isinstance(obf_random_seed, int):
+                raise TypeError("'obf_random_seed' must be int, but got {}.".format(type(obf_random_seed)))
+            int_64_max = 9223372036854775807
+            if obf_random_seed <= 0 or obf_random_seed > int_64_max:
+                raise ValueError(
+                    "'obf_random_seed' must be larger than 0, and less or equal than int64 ({}),"
+                    "but got {}.".format(int_64_max, obf_random_seed))
+            self._branch_control_input = _generate_branch_control_input(self.obf_random_seed)
         params_init = {} if params_init is None else params_init
         if not isinstance(params_init, dict):
             raise TypeError(f"For 'GraphCell', the argument 'params_init' must be a dict, but got {type(params_init)}.")
@@ -2277,10 +2337,13 @@ class GraphCell(Cell):
     def construct(self, *inputs):
         return self.graph(*inputs)
 
-    def __call__(self, *inputs):
+    def __call__(self, *args, **kwargs):
         self.phase = "graph_load_from_mindir"
         self._add_attr("graph_load_from_mindir", self.graph)
-        return self.compile_and_run(*inputs)
+        if not self.obf_random_seed:
+            return self.compile_and_run(*args, **kwargs)
+        append_input = Tensor((numpy.ones((1, 1)) * self._branch_control_input).astype(numpy.int32))
+        return self.compile_and_run(*args, append_input, **kwargs)
 
 
 def _check_param_list_tuple(value):