mindspore 2.0.0a0__cp38-cp38-win_amd64.whl → 2.0.0rc1__cp38-cp38-win_amd64.whl

mindspore/common/dtype.py

@@ -20,7 +20,6 @@ from __future__ import absolute_import
 import enum
 from inspect import isfunction
 import numpy as np
-from mindspore import log as logger
 from mindspore._c_expression import typing
 from mindspore._c_expression.typing import Type
 
@@ -146,6 +145,7 @@ float_type = (float16, float32, float64,)
 signed_type = (int8, byte, int16, short, int32, intc, int64,
                intp, float16, half, float32, single, float64,
                double, complex64, complex128)
+complex_type = (complex64, complex128,)
 all_types = (bool_, int8, uint8, int16, int32, int64, float16, float32, float64, complex64, complex128)
 implicit_conversion_seq = {t: idx for idx, t in enumerate(all_types)}
 
@@ -320,6 +320,13 @@ def type_size_in_bytes(dtype):
 class QuantDtype(enum.Enum):
     """
     An enum for quant datatype, contains `INT1` ~ `INT16`, `UINT1` ~ `UINT16`.
+
+    `QuantDtype` is defined in `mindspore/common/dtype.py`, use command below to import:
+
+    .. code-block::
+
+        from mindspore import QuantDtype
+
     """
     INT1 = 0
     INT2 = 1

mindspore/common/dump.py

@@ -27,11 +27,11 @@ def set_dump(target, enabled=True):
     `target` should be an instance of :class:`mindspore.nn.Cell` or :class:`mindspore.ops.Primitive` .
     Please note that this API takes effect only when Asynchronous Dump is enabled and the `dump_mode`
     field in dump config file is "2". See the `dump document <https://www.mindspore.cn/tutorials/
-    experts/en/r2.0.0-alpha/debug/dump.html>`_ for details. The default enabled status for
+    experts/en/r2.0/debug/dump.html>`_ for details. The default enabled status for
     a :class:`mindspore.nn.Cell` or :class:`mindspore.ops.Primitive` is False.
 
     .. warning::
-        This is an experimental prototype that is subject to change or deletion.
+        This is an experimental API that is subject to change or deletion.
 
     Note:
         1. This API is only effective for GRAPH_MODE with Ascend backend.

mindspore/common/initializer.py

@@ -262,7 +262,7 @@ def _calculate_in_and_out(arr):
 class XavierNormal(Initializer):
     r"""
     Generates an array with values sampled from Xavier normal distribution
-    :math:`\mathcal{N}(0, \text{sigma}^2)` in order to initialize a tensor, where
+    :math:`{N}(0, \text{sigma}^2)` in order to initialize a tensor, where
 
     .. math::
         sigma = gain * \sqrt{\frac{2}{n_{in} + n_{out}}}
@@ -610,7 +610,9 @@ class VarianceScaling(Initializer):
     When `distribution` is 'truncated_normal' or 'untruncated_normal', the value will be sampled from truncated or
     untruncated normal distribution with a mean of 0 and a scaled standard deviation
     :math:`stddev = \sqrt{\frac{scale}{n}}`. :math:`n` will be the number of input units if `mode` is 'fan_in',
-    the number of output units if `mode` is 'fan_out', the average of 'fan_in' and 'fan_out' if `mode` is 'fan_avg'.
+    while :math:`n` will be
+    the number of output units if `mode` is 'fan_out'. :math:`n` will be the average of 'fan_in' and 'fan_out'
+    if `mode` is 'fan_avg'.
     When `distribution` is 'uniform', the value will be sampled from a uniform distribution within the limit of
     :math:`[-\sqrt{\frac{3*scale}{n}}, \sqrt{\frac{3*scale}{n}}]`.
 

mindspore/common/jit_config.py

@@ -19,18 +19,24 @@ class JitConfig:
     """
     Jit config for compile.
 
-    Note:
-        This is an experimental function that is subject to change or deletion.
+    .. warning::
+        This is an experimental API that is subject to change or deletion.
 
     Args:
         jit_level (str): Option for argument `level` for Optimization of lift graph.
-            Supports ["O0", "O1", "O2"]. Default: "O1".
+            Supports ["O0", "O1", "O2", "O3"]. Default: "O1".
 
             - "O0": Basic optimization.
             - "O1": Manual optimization.
             - "O2": Manual optimization and graph computation fusion.
+            - "O3": Performance optimization, no generalization guaranteed.
+
+        exc_mode (str): Mode for execute the network. Supports ["auto", "sink", "no_sink"]. Default: "auto".
+
+            - "auto": Automatic Policies.
+            - "sink": Build computational graphs with the sink mode.
+            - "no_sink": Build computational graphs with no sink mode.
 
-        task_sink (bool): Determines whether to pass the data through dataset channel. Default: True.
         **kwargs (dict): A dictionary of keyword arguments that the class needs.
 
     Examples:
@@ -41,13 +47,11 @@ class JitConfig:
         >>>
         >>> net.set_jit_config(jitconfig)
     """
-    def __init__(self, jit_level="O1", task_sink=True, **kwargs):
-        if jit_level not in ["O0", "O1", "O2"]:
-            raise ValueError("For 'jit_level' must be one of ['O0', 'O1', 'O2'].")
-        if not isinstance(task_sink, bool):
-            raise TypeError("For 'task_sink' must be bool.")
-        self.jit_config_dict = dict()
+    def __init__(self, jit_level="O1", exc_mode="auto", **kwargs):
+        if jit_level not in ["O0", "O1", "O2", "O3"]:
+            raise ValueError("For 'jit_level' must be one of ['O0', 'O1', 'O2', 'O3'].")
+        if exc_mode not in ['auto', 'sink', 'no_sink']:
+            raise ValueError("For 'exc_mode' must be one of '['auto', 'sink', 'no_sink']'.")
+        self.jit_config_dict = kwargs
         self.jit_config_dict["jit_level"] = jit_level
-        self.jit_config_dict["task_sink"] = str(int(task_sink))
-        for key, value in kwargs.items():
-            self.jit_config_dict[key] = value
+        self.jit_config_dict["exc_mode"] = exc_mode

mindspore/common/mutable.py

@@ -19,6 +19,14 @@ from mindspore.common.tensor import Tensor
 from mindspore._c_expression import Tensor as Tensor_
 
 
+class _Int(int):
+    pass
+
+
+class _Float(float):
+    pass
+
+
 class _Tuple(tuple):
     pass
 
@@ -43,7 +51,7 @@ def _check_element_type(value):
             if not _check_element_type(element):
                 return False
         return True
-    return isinstance(value, Tensor_)
+    return isinstance(value, (Tensor, Tensor_, int, float)) and not isinstance(value, bool)
 
 
 def mutable(input_data, dynamic_len=False):
@@ -68,15 +76,17 @@ def mutable(input_data, dynamic_len=False):
     the length of the tuple or list is different for each run, it does not need to be re-compiled.
 
     Args:
-        input_data (Union[int, float, Tensor, tuple, list, dict): The input data to be made mutable. If
+        input_data (Union[int, float, Tensor, tuple, list, dict]): The input data to be made mutable. If
             'input_data' is list/tuple/dict, the type of each element should also in the valid types.
         dynamic_len (bool): Whether to set the whole sequence to be dynamic length. In graph compilation, if
             `dynamic_len` is True, the `input_data` must be list or tuple and the elements of `input_data` must have
             the same type and shape. Default: False.
 
     .. warning::
-        - This is an experimental prototype that is subject to change or deletion.
-        - Currently this api only works in GRAPH mode.
+        This is an experimental API that is subject to change or deletion.
+
+    Note:
+        Currently this api only works in GRAPH mode.
 
     Returns:
         The origin input data which has been set mutable.
@@ -96,6 +106,8 @@ def mutable(input_data, dynamic_len=False):
         >>> from mindspore.common import mutable
         >>> from mindspore.common import dtype as mstype
         >>> from mindspore import Tensor
+        >>> from mindspore import context
+        >>> context.set_context(mode=context.GRAPH_MODE)
         >>> class Net(nn.Cell):
         ...     def __init__(self):
         ...         super(Net, self).__init__()
@@ -122,20 +134,28 @@ def mutable(input_data, dynamic_len=False):
         >>> output = GradNetWrtX(Net())(z)
         >>> print(output)
         (Tensor(shape=[2, 3], dtype=Float32, value=
-        [[ 1.41000009e+00, 1.60000002e+00, 6.59999943e+00],
-         [ 1.41000009e+00, 1.60000002e+00, 6.59999943e+00]]), Tensor(shape=[3, 3], dtype=Float32, value=
-        [[ 1.70000005e+00, 1.70000005e+00, 1.70000005e+00],
-         [ 1.89999998e+00, 1.89999998e+00, 1.89999998e+00],
-         [ 1.50000000e+00, 1.50000000e+00, 1.50000000e+00]]))
+        [[ 1.41000009e+00,  1.60000002e+00,  6.59999943e+00],
+         [ 1.41000009e+00,  1.60000002e+00,  6.59999943e+00]]), Tensor(shape=[3, 3], dtype=Float32, value=
+        [[ 1.70000005e+00,  1.70000005e+00,  1.70000005e+00],
+         [ 1.89999998e+00,  1.89999998e+00,  1.89999998e+00],
+         [ 1.50000000e+00,  1.50000000e+00,  1.50000000e+00]]))
     """
-
-    if not dynamic_len and not _check_element_type(input_data):
+    if not _check_element_type(input_data):
         raise TypeError(
-            f"For 'mutable', the 'input_data' should be one of (Tensor, tuple[Tensor], list[Tensor], dict[Tensor]) "
+            f"For 'mutable', the 'input_data' should be one of (int, float, bool, Tensor, tuple, list, dict) "
             f"or their nested structures, but got {input_data}.")
 
+    if dynamic_len and not isinstance(input_data, (tuple, list)):
+        raise TypeError(
+            f"For mutable, when the variable_len is True, the first input should be list or tuple,"
+            f" but got {input_data}")
+
     ret = input_data
-    if isinstance(input_data, list):
+    if isinstance(input_data, int):
+        ret = _Int(input_data)
+    elif isinstance(input_data, float):
+        ret = _Float(input_data)
+    elif isinstance(input_data, list):
         ret = _List(input_data)
     elif isinstance(input_data, tuple):
         ret = _Tuple(input_data)

mindspore/common/parameter.py

@@ -27,18 +27,17 @@ from mindspore._c_expression import ParamInfo
 from mindspore.common import dtype as mstype
 from mindspore import context
 from mindspore.parallel._utils import _get_parallel_mode
-from mindspore.common._utils import split_to_slice_if_need
+from mindspore.common._utils import get_slice_num, get_slice_shape
 from mindspore.common.initializer import initializer
 from mindspore.common.tensor import Tensor
-from mindspore._checkparam import Validator
+from mindspore import _checkparam as Validator
+from mindspore._check_jit_forbidden_api import jit_forbidden_register
 from mindspore._c_expression import Tensor as Tensor_
 from mindspore.parallel._tensor import _get_slice_index
 from mindspore.parallel._auto_parallel_context import auto_parallel_context
 from mindspore.parallel._ps_context import _is_role_worker, _is_role_pserver, _is_role_sched, _clone_hash_table, \
                                            _is_ps_mode
-from mindspore.parallel._ps_context import _reinsert_hash_table_size
-from mindspore.parallel._ps_context import _insert_weight_init_info, _insert_accumu_init_info
-from mindspore.common.seed import _get_global_and_op_seed
+from mindspore.parallel._ps_context import _reinsert_hash_table_size, _insert_accumu_init_info, _cache_enable
 import mindspore.common._monad as monad
 
 __all__ = ['Parameter', 'ParameterTuple']
@@ -222,20 +221,23 @@ class Parameter(Tensor_):
         self.is_in_parallel = _is_in_parallel_mode()
         self.is_in_shard = False
         self._pipeline_stage_list = []
+        self.slice_num = 1
         if -1 in self.shape:
             raise ValueError(f"All shape elements of the Parameter must be positive. But got None.")
         if isinstance(default_input, (Tensor_, Tensor)):
-            Tensor_.__init__(self, default_input.dtype, default_input.shape)
-
             # At embedding cache scenes, we need limit the size of memory for parameter.
             # And save out range data to persistent storage to support TB-Level size parameter.
-            slice_num_of_persistent_data = split_to_slice_if_need(default_input.dtype, default_input.shape)
+            slice_num_of_persistent_data = get_slice_num(default_input.dtype, default_input.shape)
             if slice_num_of_persistent_data > 1:
                 data_shape = list(default_input.shape)
                 slice_first_dim = math.ceil(data_shape[0] / slice_num_of_persistent_data)
                 data_shape[0] = slice_first_dim
-                self.param_info.parameter_persistent_slice_shape = data_shape
                 self.param_info.use_persistent_storage = True
+                self.param_info.origin_shape = default_input.shape
+                self.slice_num = slice_num_of_persistent_data
+                Tensor_.__init__(self, default_input.dtype, tuple(data_shape))
+            else:
+                Tensor_.__init__(self, default_input.dtype, default_input.shape)
 
         elif isinstance(default_input, int):
             Tensor_.__init__(self, mstype.int64, ())
@@ -291,10 +293,10 @@ class Parameter(Tensor_):
                 # make a copy of Tensor to init the parameter.
                 return (Tensor, data.asnumpy())
 
-            not_init_data = _is_role_sched() or _is_in_parallel_mode()
+            not_init_data = _is_role_sched() or (_is_role_pserver() and _cache_enable()) or _is_in_parallel_mode()
             if not_init_data:
                 # do not init data while in auto parallel.
-                return (Tensor, None, data.dtype, data.shape, data.init)
+                return (Tensor, None, data.dtype, get_slice_shape(data.dtype, data.shape), data.init)
             return (Tensor, data.init_data())
         if isinstance(data, int):
             return (Tensor, data, mstype.int32)
@@ -504,7 +506,7 @@ class Parameter(Tensor_):
         if self.cache_shape:
             x.cache_shape = self.cache_shape
         if init != 'same':
-            shape = self.shape
+            shape = self.shape if self.slice_num == 1 else self.param_info.origin_shape
             dtype = self.dtype
             x.set_data(initializer(init, shape=shape, dtype=dtype))
         return x
@@ -631,13 +633,13 @@ class Parameter(Tensor_):
 
     @staticmethod
     def _set_data_check_input_valid(current_shape, data_shape, current_tensor_is_init,
-                                    incoming_tensor_is_init, slice_shape=False):
+                                    incoming_tensor_is_init, slice_shape=False, slice_num=1):
         if incoming_tensor_is_init and not current_tensor_is_init:
             raise TypeError("The original tensor data is initialized, but the argument 'data' is not initialized."
                             "Please initialize 'data' before call this method.")
         if tuple(current_shape) != tuple(data_shape):
             # If Slice create Parameter shape can be change.
-            if not slice_shape:
+            if not slice_shape and slice_num == 1:
                 raise ValueError(f"Can not change the shape of Parameter which has been initialized."
                                  f" Current shape is {current_shape}, and incoming is {data_shape}.")
 
@@ -654,6 +656,7 @@ class Parameter(Tensor_):
         Parameter.__init__(param, tensor, *args, **kwargs)
         return param
 
+    @jit_forbidden_register
     def set_data(self, data, slice_shape=False):
         """
         Set Parameter's data.
@@ -677,7 +680,7 @@ class Parameter(Tensor_):
         incoming_tensor_is_init = isinstance(data, Tensor) and not data.has_init
         current_tensor_is_init = isinstance(self, Tensor) and not self.has_init
         Parameter._set_data_check_input_valid(self.shape, data.shape, current_tensor_is_init, incoming_tensor_is_init,
-                                              slice_shape)
+                                              slice_shape, self.slice_num)
         if self.dtype != data.dtype:
             if mstype.implicit_conversion_seq[self.dtype] < mstype.implicit_conversion_seq[data.dtype]:
                 self._raise_type_error(data.dtype)
@@ -709,7 +712,7 @@ class Parameter(Tensor_):
                 raise TypeError("The argument 'layout' should be tuple, but got {}.".format(type(layout)))
             if len(layout) < 6:
                 raise ValueError("The length of 'layout' must be larger than 5, but got {}.".format(len(layout)))
-            slice_index = int(_get_slice_index(layout[0], layout[1]))
+            slice_index = int(_get_slice_index(layout[0], layout[1], layout[5]))
             init_data_args += (slice_index, layout[2], layout[5])
         return init_data_args
 
@@ -742,19 +745,18 @@ class Parameter(Tensor_):
             TypeError: If `layout` is not tuple.
         """
         if self.is_default_input_init and self.is_in_parallel != _is_in_parallel_mode():
-            raise RuntimeError("Must set or change parallel mode before any Tensor created.")
+            raise RuntimeError("Must set or change parallel mode before any initializer Tensor created.")
         if self.init_mode is None:
             return self
         if self.inited_param is not None:
             return self.inited_param
-        if _is_role_worker() and self.cache_enable:
-            global_seed, op_seed = _get_global_and_op_seed()
-            _insert_weight_init_info(self.name, global_seed, op_seed)
 
         init_data_args = self._get_init_data_args(layout)
 
+        if _is_role_sched():
+            return self
         if self.init_in_server and self.is_param_ps and isinstance(self.init_mode, Tensor) and \
-                self.init_mode.init is not None and (_is_role_worker() or _is_role_sched()):
+                self.init_mode.init is not None and _is_role_worker():
             if self.cache_enable:
                 data = self.init_mode.init_data(*init_data_args)
             else:

mindspore/common/seed.py

@@ -16,7 +16,7 @@
 from __future__ import absolute_import
 
 import numpy as np
-from mindspore._checkparam import Validator
+from mindspore import _checkparam as Validator
 
 # constants
 DEFAULT_GRAPH_SEED = 87654321
@@ -41,11 +41,11 @@ def set_seed(seed):
     Set global seed.
 
     Note:
-        The global seed is used by numpy.random, mindspore.common.Initializer, mindspore.ops.composite.random_ops and
+        The global seed is used by numpy.random, mindspore.common.Initializer, mindspore.ops.function.random_func and
         mindspore.nn.probability.distribution.
 
         If global seed is not set, these packages will use their own default seed independently, numpy.random and
-        mindspore.common.Initializer will choose a random seed, mindspore.ops.composite.random_ops and
+        mindspore.common.Initializer will choose a random seed, mindspore.ops.function.random_func and
         mindspore.nn.probability.distribution will use zero.
 
         Seed set by numpy.random.seed() only used by numpy.random, while seed set by this API will also used by
@@ -98,7 +98,7 @@ def set_seed(seed):
         >>> w1 = Parameter(initializer("uniform", [2, 2], ms.float32), name="w1") # W1
         >>> w1 = Parameter(initializer("uniform", [2, 2], ms.float32), name="w1") # W2
         >>>
-        >>> # 3. If neither global seed nor op seed is set, mindspore.ops.composite.random_ops and
+        >>> # 3. If neither global seed nor op seed is set, mindspore.ops.function.random_func and
         >>> # mindspore.nn.probability.distribution will choose a random seed:
         >>> c1 = ops.uniform((1, 4), minval, maxval) # C1
         >>> c2 = ops.uniform((1, 4), minval, maxval) # C2
@@ -106,7 +106,7 @@ def set_seed(seed):
         >>> c1 = ops.uniform((1, 4), minval, maxval) # C3
         >>> c2 = ops.uniform((1, 4), minval, maxval) # C4
         >>>
-        >>> # 4. If global seed is set, but op seed is not set, mindspore.ops.composite.random_ops and
+        >>> # 4. If global seed is set, but op seed is not set, mindspore.ops.function.random_func and
         >>> # mindspore.nn.probability.distribution will calculate a seed according to global seed and
         >>> # default op seed. Each call will change the default op seed, thus each call get different
         >>> # results.
@@ -118,7 +118,7 @@ def set_seed(seed):
         >>> c1 = ops.uniform((1, 4), minval, maxval) # C1
         >>> c2 = ops.uniform((1, 4), minval, maxval) # C2
         >>>
-        >>> # 5. If both global seed and op seed are set, mindspore.ops.composite.random_ops and
+        >>> # 5. If both global seed and op seed are set, mindspore.ops.function.random_func and
         >>> # mindspore.nn.probability.distribution will calculate a seed according to global seed and
         >>> # op seed counter. Each call will change the op seed counter, thus each call get different
         >>> # results.
@@ -131,7 +131,7 @@ def set_seed(seed):
         >>> c2 = ops.uniform((1, 4), minval, maxval, seed=2) # C2
         >>>
         >>> # 6. If op seed is set but global seed is not set, 0 will be used as global seed. Then
-        >>> # mindspore.ops.composite.random_ops and mindspore.nn.probability.distribution act as in
+        >>> # mindspore.ops.function.random_func and mindspore.nn.probability.distribution act as in
         >>> # condition 5.
         >>> c1 = ops.uniform((1, 4), minval, maxval, seed=2) # C1
         >>> c2 = ops.uniform((1, 4), minval, maxval, seed=2) # C2
@@ -140,7 +140,7 @@ def set_seed(seed):
         >>> c2 = ops.uniform((1, 4), minval, maxval, seed=2) # C2
         >>>
         >>> # 7. Recall set_seed() in the program will reset numpy seed and op seed counter of
-        >>> # mindspore.ops.composite.random_ops and mindspore.nn.probability.distribution.
+        >>> # mindspore.ops.function.random_func and mindspore.nn.probability.distribution.
         >>> set_seed(1234)
         >>> np_1 = np.random.normal(0, 1, [1]).astype(np.float32) # A1
         >>> c1 = ops.uniform((1, 4), minval, maxval, seed=2) # C1
@@ -209,22 +209,6 @@ def _get_op_seed(op_seed, kernel_name):
     return _KERNEL_SEED[(kernel_name, op_seed)]
 
 
-def _get_global_and_op_seed():
-    """Get global_seed and op_seed."""
-    global_seed = get_seed()
-    op_seed = get_seed()
-    if global_seed == 0:
-        global_seed = DEFAULT_GRAPH_SEED
-    elif global_seed is None:
-        global_seed = 0
-    if op_seed is None:
-        op_seed = 0
-    Validator.check_non_negative_int(op_seed, "seed", "init")
-    temp_seed = _get_op_seed(op_seed, "init")
-    seeds = _truncate_seed(global_seed), _truncate_seed(temp_seed)
-    return seeds
-
-
 def _get_graph_seed(op_seed, kernel_name):
     """
     Get the graph-level seed.