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

mindspore/nn/cell.py

@@ -31,15 +31,40 @@ from mindspore.common.hook_handle import HookHandle
 from mindspore.context import ParallelMode
 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.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_):
@@ -53,9 +78,12 @@ class Cell(Cell_):
     PYNATIVE_MODE (dynamic graph mode).
 
     Args:
-        auto_prefix (bool, optional): 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.
+        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.
 
@@ -139,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)
@@ -150,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`
@@ -325,10 +357,10 @@ class Cell(Cell_):
         cells_compile_cache.pop(id(self), None)
         try:
             if self.compile_cache:
-                _cell_graph_executor.del_net_res(self.compile_cache)
-        except AttributeError:
+                _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__()'.")
+                                 f"Please use 'super().__init__()'.") from e
 
     def __delattr__(self, name):
         if name in self._params:
@@ -415,46 +447,46 @@ 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):
         '''Hook function in graph mode'''
-        #Check super().__init__() 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:
+        except AttributeError as e:
             raise AttributeError(f"The '{type(self).__name__}' object does not inherit attribute from 'cell'. "
-                                 f"Please use 'super().__init__()'.")
+                                 f"Please use 'super().__init__()'.") from e
         if not self._is_recursion_hook:
             self._is_recursion_hook = True
             for cell in self.cells():
@@ -585,31 +617,9 @@ 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:
-            raise AttributeError("For 'Cell', the method 'construct' is not defined. ")
+            raise AttributeError("For 'Cell', the method 'construct' is not defined.")
 
         if kwargs:
             bound_arguments = inspect.signature(self.construct).bind(*args, **kwargs)
@@ -619,28 +629,28 @@ class Cell(Cell_):
 
         # Run in Graph mode.
         if os.getenv("MS_JIT") != '0' and context._get_mode() == context.GRAPH_MODE:
-            self._check_construct_args(*args, **kwargs)
+            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)
@@ -654,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)
@@ -841,7 +857,6 @@ class Cell(Cell_):
         """
         logger.warning("'load_parameter_slice' function is deprecated.")
 
-
     def set_parallel_input_with_inputs(self, *inputs):
         """
         Slice inputs tensors by parallel strategies.
@@ -860,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
@@ -892,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):
         """
@@ -901,35 +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,
-                                         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,
-                                         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.
 
@@ -937,15 +948,16 @@ 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.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):
         """
@@ -1027,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 '.'")
@@ -1040,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.
 
@@ -1048,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:
@@ -1200,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.
@@ -1214,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.
@@ -1228,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.
@@ -1419,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.
@@ -1473,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.
@@ -1505,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
@@ -1517,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/r2.0.0-alpha/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.
@@ -1562,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.
 
@@ -1605,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):
         """
@@ -2017,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:
@@ -2122,13 +2181,13 @@ class Cell(Cell_):
         """
         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'.
+        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.
+              `mindspore.communication.init()` is called for dynamic cluster building.
 
         Args:
             role (str): The role of the process on which this cell will be launched.
@@ -2147,35 +2206,57 @@ class Cell(Cell_):
         for op in all_ops:
             op.place(role, rank_id)
 
-    def _check_compile_dynamic_shape(self, *inputs):
+    def _check_dynamic_tensor(self, set_input, net_input, index):
         """
-        Check if graph has been compiled with dynamic shape.
+        Check if tensor is correctly set for dynamic shape.
 
         Args:
-            inputs (tuple): Inputs of the Cell object.
+            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):
         """
-        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 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):
@@ -2191,10 +2272,10 @@ 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_password (int): The password 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 in password mode, then obf_password should be provided.
-            obf_password should be larger than zero and less or equal than int_64 (9223372036854775807). 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.
@@ -2210,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")
@@ -2223,21 +2305,22 @@ class GraphCell(Cell):
            [4. 6. 4.]]]]
     """
 
-    def __init__(self, graph, params_init=None, obf_password=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_password = obf_password
-        if obf_password is not None:
-            if not isinstance(obf_password, int):
-                raise TypeError("'obf_password' must be int, but got {}.".format(type(obf_password)))
+        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_password <= 0 or obf_password > int_64_max:
+            if obf_random_seed <= 0 or obf_random_seed > int_64_max:
                 raise ValueError(
-                    "'obf_password' must be larger than 0, and less or equal than int64 ({}),"
-                    "but got {}.".format(int_64_max, obf_password))
+                    "'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)}.")
@@ -2254,24 +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)
-        if not self.obf_password:
-            return self.compile_and_run(*inputs)
-        append_input_1, append_input_2 = _obf_appended_inputs(self.obf_password)
-        return self.compile_and_run(*inputs, append_input_1, append_input_2)
-
-
-def _obf_appended_inputs(obf_password):
-    seed_max = 2 ** 32 - 1
-    int_max = 2 ** 31 - 1
-    numpy.random.seed(obf_password % seed_max)
-    append_password = numpy.random.randint(int_max)
-    obf_password %= int_max
-    append_input_1 = Tensor((numpy.ones((1, 1)) * obf_password).astype(numpy.int32))
-    append_input_2 = Tensor((numpy.ones((1, 1)) * append_password).astype(numpy.int32))
-    return append_input_1, append_input_2
+        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):

mindspore/nn/dynamic_lr.py

@@ -17,7 +17,7 @@ from __future__ import absolute_import
 
 import math
 
-from mindspore._checkparam import Validator as validator
+from mindspore import _checkparam as validator
 
 
 def piecewise_constant_lr(milestone, learning_rates):