mindspore 2.3.0__cp39-none-any.whl → 2.3.0rc2__cp39-none-any.whl

mindspore/nn/cell.py

@@ -34,7 +34,6 @@ 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, _convert_python_data, _get_args_for_run_predict
-from mindspore.common.api import _process_dyn_args, _generate_dyn_compile_args
 from mindspore.common.parameter import Parameter, ParameterTuple
 from mindspore.common.tensor import Tensor
 from mindspore.ops.operations import Cast
@@ -81,7 +80,7 @@ class Cell(Cell_):
 
     Examples:
         >>> import mindspore.nn as nn
-        >>> from mindspore import ops
+        >>> import mindspore.ops as ops
         >>> class MyCell(nn.Cell):
         ...     def __init__(self, forward_net):
         ...         super(MyCell, self).__init__(auto_prefix=False)
@@ -105,12 +104,9 @@ class Cell(Cell_):
                    '_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', 'cell_type']
-    total_instance_count = 0
 
     def __init__(self, auto_prefix=True, flags=None):
         Cell_.__init__(self, self._cell_tag)
-        Cell.total_instance_count += 1
-        self.instance_count = Cell.total_instance_count
         self._params = OrderedDict()
         self._cells = OrderedDict()
         self._params_list = OrderedDict()
@@ -136,7 +132,6 @@ class Cell(Cell_):
         self.exist_names = set("")
         self.exist_objs = set()
         self.recompute_cell = None
-        self.sig = inspect.signature(self.construct)
         init_pipeline()
 
         # call gc to release GE session resources used by non-used cell objects
@@ -401,9 +396,6 @@ class Cell(Cell_):
             cells_compile_cache.pop(id(self), None)
         if hasattr(self, "compile_cache") and self.compile_cache:
             _cell_graph_executor.del_net_res(self, self.compile_cache)
-        if isinstance(self, GraphCell):
-            _cell_graph_executor.dec_graph_cell_count()
-        Cell.total_instance_count -= 1
 
     def __delattr__(self, name):
         if name in self._params:
@@ -574,9 +566,8 @@ class Cell(Cell_):
     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 to specify a Cell for distributed
-        execution in graph mode. In Graph mode, use this method to specify distribution strategy for a Cell,
-        strategy for others will be set by sharding propagation.
+        generated by sharding propagation. In PyNative mode, use this method
+        to specify a Cell for distributed execution in graph mode.
         in_strategy and out_strategy define the input and output layout respectively.
         in_strategy/out_strategy should be a tuple, each element of which corresponds to the desired layout of
         this input/output, and None represents data_parallel,
@@ -584,8 +575,8 @@ class Cell(Cell_):
         The parallel strategies of remaining operators are derived from the strategy specified by the input and output.
 
         Note:
-            If Cell.shard is called, the parallel mode in `set_auto_parallel_context` (parallel_mode) will be set to
-            "auto_parallel" and the search mode (search_mode) to "sharding_propagation".
+            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:
@@ -607,7 +598,7 @@ class Cell(Cell_):
                          use right now. Support [ ``"0"`` , ``"1"`` , ``"2"`` ]. Default: ``0`` .
 
         Returns:
-            Function, return the cell construct function that will be executed under auto parallel process.
+            Cell, the cell itself.
 
         Examples:
             >>> import mindspore.nn as nn
@@ -625,21 +616,22 @@ class Cell(Cell_):
             ...   def __init__(self):
             ...     self.block1 = Block()
             ...     self.block2 = Block()
-            ...     self.block2_shard = self.block2.shard(in_strategy=((2, 1),), out_strategy=(None,),
-            ...                                           parameter_plan={'self.block2.shard.dense1.weight': (4, 1)})
+            ...     self.block2.shard(in_strategy=((2, 1),), out_strategy=(None,),
+            ...                       parameter_plan={'self.block2.shard.dense1.weight': (4, 1)})
             ...   def construct(self, x):
             ...     x = self.block1(x)
-            ...     x = self.block2_shard(x)
+            ...     x = self.block2(x)
             ...     return x
         """
-        if context.get_auto_parallel_context("parallel_mode") not in ["auto_parallel", "semi_auto_parallel"]:
-            raise AssertionError(f"Cell shard only supports auto parallel or semi_auto_parallel "
-                                 f"Please check the parallel mode in parallel context.")
+        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)
-        return fn
+        return self
 
     def auto_cast_inputs(self, inputs):
         """
@@ -686,7 +678,7 @@ class Cell(Cell_):
         # Run in Graph mode.
         if os.getenv("MS_JIT") != '0' and context._get_mode() == context.GRAPH_MODE:
             if kwargs:
-                bound_arguments = self.sig.bind(*args, **kwargs)
+                bound_arguments = inspect.signature(self.construct).bind(*args, **kwargs)
                 bound_arguments.apply_defaults()
                 args = bound_arguments.args
                 kwargs = bound_arguments.kwargs
@@ -907,25 +899,14 @@ class Cell(Cell_):
         """
         logger.warning("'set_parallel_input_with_inputs' function is deprecated.")
 
-    def set_inputs(self, *inputs, **kwargs):
+    def set_inputs(self, *inputs):
         """
         Save set inputs for computation graph. The number of inputs should be the same with that of the datasets. When
         using Model for dynamic shape, please make sure that all networks and loss functions passed to the Model are
-        configured with set_inputs. The shape of input Tensor can be either dynamic or static.
-
-        .. note::
-            There are two mode:
-
-            - Full mode: arguments will be used as all compile inputs for graph-compiling.
-            - Incremental mode: arguments will set to some of the Cell inputs, which will be substituted into the input
-              at the corresponding position for graph-compiling.
-
-            Only one of inputs or kwargs can be set. Inputs for full mode and kwargs for incremental mode.
+        configured with set_inputs. The inputs can be Tensor of either dynamic or static shape.
 
         Args:
-            inputs (tuple): Full mode arguments.
-            kwargs (dict): Incremental mode arguments. The acceptable key is the name of parameter defined
-                in `self.construct`.
+            inputs (tuple): Inputs of the Cell object.
 
         .. warning::
             This is an experimental API that is subject to change or deletion.
@@ -945,27 +926,16 @@ class Cell(Cell_):
             >>> net = ReluNet()
             >>> input_dyn = Tensor(shape=[3, None], dtype=ms.float32)
             >>> net.set_inputs(input_dyn)
-            >>> input = Tensor(np.random.random([3, 10]), dtype=ms.float32)
-            >>> output = net(input)
-            >>>
-            >>> net2 = ReluNet()
-            >>> net2.set_inputs(x=input_dyn)
-            >>> output = net2(input)
+            >>> input1 = Tensor(np.random.random([3, 10]), dtype=ms.float32)
+            >>> output = net(input1)
         """
         if self.grad_ops_label:
             logger.warning(f'For Cell, set_inputs must be set before the gradient function of the network is '
                            f'generated.')
-        if kwargs and inputs:
-            raise ValueError('For Cell, set_inputs should only set inputs or kwargs(inputs: %s, kwargs: %s)!'
-                             % (inputs, kwargs))
-
-        if not kwargs:
-            self._dynamic_shape_inputs = inputs
-            self._check_construct_args(*inputs)
-            if context._get_mode() == context.PYNATIVE_MODE:
-                _pynative_executor.set_dynamic_input(self, *self._dynamic_shape_inputs)
-        else:
-            self._dynamic_shape_inputs = _process_dyn_args(self.construct, kwargs)
+        self._dynamic_shape_inputs = inputs
+        self._check_construct_args(*inputs)
+        if context._get_mode() == context.PYNATIVE_MODE:
+            _pynative_executor.set_dynamic_input(self, *self._dynamic_shape_inputs)
 
     def get_inputs(self):
         """
@@ -1000,46 +970,18 @@ class Cell(Cell_):
 
         return self._dynamic_shape_inputs
 
-    def _check_parameter_consistency(self, set_inputs, net_inputs):
-        """Check consistency for parameter."""
-        for index, (set_input, net_input) in enumerate(zip(set_inputs, net_inputs)):
-            if isinstance(set_input, Tensor):
-                if not isinstance(net_input, Tensor):
-                    raise TypeError(
-                        f"For 'set_inputs' and tuple(list) in 'set_inputs',the type of {index + 1}th input must "
-                        f"be Tensor, but got {type(net_input)}.")
-                if isinstance(set_input, Parameter) != isinstance(net_input, Parameter):
-                    raise TypeError(
-                        f"For 'set_inputs' and tuple(list) in 'set_inputs', the {index + 1}th input must be the same "
-                        f"as expected, but got expected: {type(set_input)} and input: {type(net_input)}.")
-            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' or tuple(list) in "
-                        f"'set_inputs' must be tuple or list, but got {type(net_input)}.")
-                self._check_parameter_consistency(set_input, net_input)
-
     def _get_compile_args(self, args):
         """Get compile arguments."""
         # this is used only for test
-        set_by_auto_dynamic = False
-        if is_auto_dynamic():
-            if self._dynamic_shape_inputs is None:
-                set_by_auto_dynamic = True
-            else:
-                if isinstance(self._dynamic_shape_inputs, (list, tuple)) and self._dynamic_shape_inputs[0] is None:
-                    set_by_auto_dynamic = True
-        if set_by_auto_dynamic:
+        if is_auto_dynamic() and (self._dynamic_shape_inputs is None or self._dynamic_shape_inputs[0] is None):
             self._dynamic_shape_inputs = convert_inputs_to_dynamic(*args)
 
         if self._dynamic_shape_inputs is not None:
             logger.debug("Compiled Graph with dynamic shape")
-            compile_args = _generate_dyn_compile_args(args, self._dynamic_shape_inputs)
-            _cell_graph_executor._graph_executor.check_argument_consistency(compile_args, args, "set_inputs")
-            self._check_parameter_consistency(compile_args, args)
-            Validator.check_symbolic_shape(compile_args, args)
-            self.saved_dynamic_shape = compile_args
-            return compile_args
+            self._check_compile_dynamic_shape(self._dynamic_shape_inputs, args)
+            Validator.check_symbolic_shape(self._dynamic_shape_inputs, args)
+            self.saved_dynamic_shape = self._dynamic_shape_inputs
+            return self._dynamic_shape_inputs
         return args
 
     def compile(self, *args, **kwargs):
@@ -1084,7 +1026,6 @@ class Cell(Cell_):
 
     def exec_checkpoint_graph(self):
         """Executes GE saving checkpoint graph operation."""
-        logger.warning("'exec_checkpoint_graph' function is deprecated.")
         self.add_flags(ge_sync_data=True)
         _cell_graph_executor(self, phase='save')
 
@@ -2000,11 +1941,11 @@ class Cell(Cell_):
         Note:
             - 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` is the object of registered Cell. `inputs` is the forward
+              `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
               forward input objects.
             - It should have the following signature:
-              hook_fn(cell, inputs) -> new input objects or none.
+              hook_fn(cell_id, inputs) -> new input objects or none.
             - In order to prevent running failed when switching to graph mode, it is not recommended to write it in the
               `construct` function of Cell object. In the pynative mode, if the `register_forward_pre_hook` function is
               called in the `construct` function of the Cell object, a hook function will be added at each run time of
@@ -2028,7 +1969,7 @@ class Cell(Cell_):
             >>> import mindspore as ms
             >>> from mindspore import Tensor, nn, ops
             >>> ms.set_context(mode=ms.PYNATIVE_MODE)
-            >>> def forward_pre_hook_fn(cell, inputs):
+            >>> def forward_pre_hook_fn(cell_id, inputs):
             ...     print("forward inputs: ", inputs)
             ...
             >>> class Net(nn.Cell):
@@ -2074,8 +2015,9 @@ class Cell(Cell_):
         Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
         """
+        cell_id = self.cls_name + "(" + str(id(self)) + ")"
         for fn in self._forward_pre_hook.values():
-            ret = fn(self, inputs)
+            ret = fn(cell_id, inputs)
             if ret is not None:
                 if not isinstance(ret, tuple):
                     inputs = (ret,)
@@ -2090,11 +2032,11 @@ class Cell(Cell_):
         Note:
             - 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` is the object of registered Cell. `inputs` is the forward
+              `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
               modify the forward output object by returning new forward output object.
             - It should have the following signature:
-              hook_fn(cell, inputs, output) -> new output object or none.
+              hook_fn(cell_id, inputs, output) -> new output object or none.
             - In order to prevent running failed when switching to graph mode, it is not recommended to write it in the
               `construct` function of Cell object. In the pynative mode, if the `register_forward_hook` function is
               called in the `construct` function of the Cell object, a hook function will be added at each run time of
@@ -2118,7 +2060,7 @@ class Cell(Cell_):
             >>> import mindspore as ms
             >>> from mindspore import Tensor, nn, ops
             >>> ms.set_context(mode=ms.PYNATIVE_MODE)
-            >>> def forward_hook_fn(cell, inputs, output):
+            >>> def forward_hook_fn(cell_id, inputs, output):
             ...     print("forward inputs: ", inputs)
             ...     print("forward output: ", output)
             ...
@@ -2167,8 +2109,9 @@ class Cell(Cell_):
         Supported Platforms:
         ``Ascend`` ``GPU`` ``CPU``
         """
+        cell_id = self.cls_name + "(" + str(id(self)) + ")"
         for fn in self._forward_hook.values():
-            ret = fn(self, inputs, output)
+            ret = fn(cell_id, inputs, output)
             if ret is not None:
                 output = ret
         return output
@@ -2483,6 +2426,65 @@ class Cell(Cell_):
         for op in all_ops:
             op.place(role, rank_id)
 
+    def _check_dynamic_tensor(self, set_input, net_input, index):
+        """
+        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"For 'set_inputs' and tuple(list) in 'set_inputs',the type of {index + 1}th input must be Tensor, "
+                f"but got {type(net_input)}.")
+        is_param_set_input = isinstance(set_input, Parameter)
+        is_param_net_input = isinstance(net_input, Parameter)
+        if (is_param_set_input and not is_param_net_input) or (is_param_net_input and not is_param_set_input):
+            raise TypeError(
+                f"For 'set_inputs' and tuple(list) in 'set_inputs', the {index + 1}th input must be the same "
+                f"as network's input, but got 'set_inputs': {type(set_input)} and network's input: {type(net_input)}.")
+        if set_input.dtype != net_input.dtype:
+            raise TypeError(
+                f"For 'set_inputs' and tuple(list) in 'set_inputs',the dtype of {index + 1}th input must be the same "
+                f"as network's input, but got 'set_inputs': {set_input.dtype} and network's input: {net_input.dtype}.")
+        if -2 not in set_input.shape:
+            if net_input.dim() != 0 and set_input.dim() != net_input.dim():
+                raise ValueError(
+                    f"For 'set_inputs' and tuple(list) in 'set_inputs',the dims of {index + 1}th input must be the "
+                    f"same as network's input, but got 'set_inputs': {set_input.dim()} and network's input: "
+                    f"{net_input.dim()}.")
+            if not all([ele1 in (-1, ele2) for ele1, ele2 in zip(set_input.shape, net_input.shape)]):
+                raise ValueError(
+                    f"For 'set_inputs' and tuple(list) in 'set_inputs',the shape of {index + 1}th input must be the "
+                    f"same as network's input, but got 'set_inputs': {set_input.shape} and network's input: "
+                    f"{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.
+        """
+        if not getattr(set_inputs, '__ms_dynamic_len__', False):
+            set_inputs_len = len(set_inputs)
+            net_inputs_len = len(net_inputs)
+            if set_inputs_len != net_inputs_len:
+                raise ValueError(f"The length of 'set_inputs' or tuple(list) in 'set_inputs' "
+                                 f"must be equal to network's inputs, but got 'set_inputs': "
+                                 f"{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):
+                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' or tuple(list) in "
+                        f"'set_inputs' must be tuple or list, but got {type(net_input)}.")
+                self._check_compile_dynamic_shape(set_input, net_input)
+
     def _mixed_precision_cast(self, inputs):
         mixed_type = self.get_mixed_precision_type()
         if mixed_type == MixedPrecisionType.NOTSET:
@@ -2579,7 +2581,6 @@ class GraphCell(Cell):
         params_dict = update_func_graph_hyper_params(self.graph, params_init)
         for name, param in params_dict.items():
             self._params[name] = param
-        _cell_graph_executor.inc_graph_cell_count()
 
     def construct(self, *inputs):
         return self.graph(*inputs)

mindspore/nn/extend/basic.py

@@ -76,10 +76,10 @@ class Linear(Cell):
     Examples:
         >>> import mindspore
         >>> from mindspore import Tensor
-        >>> from mindspore import nn
+        >>> from mindspore.nn.extend import Linear
         >>> import numpy as np
         >>> x = Tensor(np.array([[180, 234, 154], [244, 48, 247]]), mindspore.float32)
-        >>> net = nn.extend.Linear(3, 4)
+        >>> net = Linear(3, 4)
         >>> output = net(x)
         >>> print(output.shape)
         (2, 4)

mindspore/nn/extend/embedding.py

@@ -57,7 +57,7 @@ class Embedding(Cell):
           mindspore.int32 or mindspore.int64, and the value should be in range `[0, num_embeddings)`.
 
     Outputs:
-        Tensor, has the same data type as weight, the shape is :math:`(*input.shape, embedding\_dim)`.
+        Tensor, has the same data type as weight, the shape is :math:`(*input.shape, embedding_dim)`.
 
     Raises:
         TypeError: If `num_embeddings` is not an int.

mindspore/nn/extend/layer/normalization.py

@@ -48,8 +48,7 @@ class LayerNorm(Cell):
         beta_init (Union[Tensor, str, Initializer, numbers.Number]): Initializer for the :math:`\beta` weight.
             The values of str refer to the function `initializer` including ``'zeros'`` , ``'ones'`` ,
             ``'xavier_uniform'`` , ``'he_uniform'`` , etc. Default: ``'zeros'`` .
-        eps (float): A value added to the denominator for numerical stability(:math:`\epsilon`). Default: ``1e-5`` .
-        elementwise_affine (bool): A bool value, When set to True, gamma and beta can be learned. Default: True.
+        epsilon (float): A value added to the denominator for numerical stability(:math:`\epsilon`). Default: ``1e-5`` .
         dtype (:class:`mindspore.dtype`): Dtype of Parameters. Default: ``mstype.float32`` .
 
     Inputs:
@@ -79,8 +78,7 @@ class LayerNorm(Cell):
                  normalized_shape,
                  gamma_init='ones',
                  beta_init='zeros',
-                 eps=1e-5,
-                 elementwise_affine=True,
+                 epsilon=1e-5,
                  dtype=mstype.float32
                  ):
         """Initialize LayerNorm."""
@@ -94,11 +92,11 @@ class LayerNorm(Cell):
                 f"least one element, but got normalized_shape = {normalized_shape}"
             )
         self.normalized_shape = normalized_shape
-        self.epsilon = eps
+        self.epsilon = epsilon
         self.gamma = Parameter(initializer(
-            gamma_init, normalized_shape, dtype=dtype), name="gamma", requires_grad=elementwise_affine)
+            gamma_init, normalized_shape, dtype=dtype), name="gamma")
         self.beta = Parameter(initializer(
-            beta_init, normalized_shape, dtype=dtype), name="beta", requires_grad=elementwise_affine)
+            beta_init, normalized_shape, dtype=dtype), name="beta")
 
     def construct(self, input_x):
         y = F.layer_norm(input_x, self.normalized_shape, self.gamma.astype(input_x.dtype),