mindspore 2.1.0__cp37-cp37m-manylinux1_x86_64.whl → 2.2.11__cp37-cp37m-manylinux1_x86_64.whl

mindspore/common/initializer.py

@@ -37,7 +37,7 @@ class Initializer:
         Initializers are intended to be used for delayed initialization in parallel mode rather than Tensor
         initialization. If you have to use Initializers to create a Tensor, :func:`mindspore.Tensor.init_data` should be
         followed in most of the cases. For more information, please refer to `mindspore.Tensor.init_data
-        <https://www.mindspore.cn/docs/en/r2.1/api_python/mindspore/Tensor/mindspore.Tensor.init_data.html#
+        <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore/Tensor/mindspore.Tensor.init_data.html#
         mindspore-tensor-init-data>`_ .
 
     Args:
@@ -350,8 +350,8 @@ class HeUniform(Initializer):
     .. math::
         boundary = \text{gain} \times \sqrt{\frac{3}{fan\_mode}}
 
-    where :math:`gain` is an optional scaling factor. If :math:`fan\_mode` is 'fan_in', it is the number of input units
-    of the weight tensor. If :math:`fan\_mode` is 'fan_out',
+    where :math:`gain` is an optional scaling factor. If :math:`fan\_mode` is ``'fan_in'``,
+    it is the number of input units of the weight tensor. If :math:`fan\_mode` is ``'fan_out'``,
     it is the number of output units of the weight tensor.
 
     For details of HeUniform algorithm, please check
@@ -487,7 +487,7 @@ class Identity(Initializer):
 class Sparse(Initializer):
     """
     Generates a 2 dimension sparse matrix array in order to initialize a tensor. The non-zero positions
-    will be filled with the value sampled from the normal distribution :math:`{N}(0, 0.01)`.
+    will be filled with the value sampled from the normal distribution :math:`{N}(0, sigma)`.
 
     Args:
          sparsity (float): The fraction of elements being set to zero in each column.
@@ -525,11 +525,11 @@ class Sparse(Initializer):
 class Dirac(Initializer):
     """
     Generates an array with the Dirac delta function in order to initialize a tensor.
-    It tries to preserves the identity of input for convolution layers.
-    For group convolution, each group of channels will be preserved respectively.
+    It's usually used in convolution layers, preserves as many identities of the inputs as possible.
 
     Args:
-        groups (int): The number of group in convolution layer. Default: ``1`` .
+        groups (int): The number of groups in convolution layer. Each group applies the same initialization.
+            Default: ``1`` .
 
     Raises:
         ValueError: If the dimension of the initialized tensor is not in [3, 4, 5].
@@ -582,7 +582,7 @@ class Orthogonal(Initializer):
     If the dimension is greater than 2, the trailing dimensions will be flattened.
 
     Args:
-         gain (float): An optional scaling factor. Default: ``1.`` .
+         gain (float): An optional scaling factor. Default: ``1.0`` .
 
     Raises:
         ValueError: If the dimension of input tensor is less than 2.
@@ -628,11 +628,11 @@ class VarianceScaling(Initializer):
     Generates an random array with scaling in order to initialize a tensor.
     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',
+    :math:`stddev = \sqrt{\frac{scale}{n}}`. :math:`n` will be the number of input units if `mode` is ``'fan_in'``,
     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
+    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}}]`.
 
     Args:
@@ -643,8 +643,8 @@ class VarianceScaling(Initializer):
 
     Raises:
         ValueError: If `scale` is not greater than 0.
-        ValueError: If `mode` is not 'fan_in', 'fan_out' or 'fan_avg'.
-        ValueError: If `distribution` is not 'uniform', 'truncated_normal' or 'untruncated_normal'.
+        ValueError: If `mode` is not ``'fan_in'``, ``'fan_out'`` or ``'fan_avg'``.
+        ValueError: If `distribution` is not ``'uniform'``, ``'truncated_normal'`` or ``'untruncated_normal'``.
 
     Examples:
         >>> import mindspore

mindspore/common/jit_config.py

@@ -1,4 +1,4 @@
-# Copyright 2022 Huawei Technologies Co., Ltd
+# Copyright 2022-2023 Huawei Technologies Co., Ltd
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -23,19 +23,34 @@ class JitConfig:
         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", "O3"]. Default: ``"O1"`` .
+        jit_level (str, optional): Used to control the compilation optimization level.
+            Supports ["O0", "O1", "O2"]. Default: ``"O1"`` .
 
-            - "O0": Basic optimization.
-            - "O1": Manual optimization.
-            - "O2": Manual optimization and graph computation fusion.
-            - "O3": Performance optimization, no generalization guaranteed.
+            - ``"O0"``: Except for optimizations that may affect functionality, all other optimizations are turned off.
+            - ``"O1"``: Using commonly used optimizations, recommended to set the O1 level.
+            - ``"O2"``: Activate some experimental level optimizations.
 
-        exc_mode (str): Mode for execute the network. Supports ["auto", "sink", "no_sink"]. Default: ``"auto"`` .
+        exc_mode (str, optional): Control the execution mode of the model.
+            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.
+            - ``"auto"``: The framework automatically selects the execution method.
+            - ``"sink"``: Support the network to load and load the entire device at once, and then execute it by
+              input driver, without the need to iterate through each operator to achieve better execution performance.
+              This mode is only supported on the Ascend backend.
+            - ``"no_sink"``: The network model is executed asynchronously one by one using a single operator.
+
+        jit_syntax_level (str, optional): JIT syntax level for graph compiling.
+            The value must be ``"STRICT"`` , ``"LAX"`` or ``""`` . Default to an empty string, which means that this
+            JitConfig configuration will be ignored and the jit_syntax_level of ms.context will be used.
+            For more details about ms.context, refer to
+            `set_context <https://www.mindspore.cn/docs/en/r2.2/api_python/mindspore/mindspore.set_context.html>`_ .
+            Default: ``""`` .
+
+            - ``"STRICT"``: Only basic syntax is supported, and execution performance is optimal. Can be used for MindIR
+              load and export.
+            - ``"LAX"``: Compatible with all Python syntax as much as possible. However, execution performance may be
+              affected and not optimal. Cannot be used for MindIR load and export due to some syntax that may not be
+              able to be exported.
 
         **kwargs (dict): A dictionary of keyword arguments that the class needs.
 
@@ -45,16 +60,19 @@ class JitConfig:
         >>> jitconfig = JitConfig(jit_level="O1")
         >>>
         >>> # Define the network structure of LeNet5. Refer to
-        >>> # https://gitee.com/mindspore/docs/blob/r2.1/docs/mindspore/code/lenet.py
+        >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
         >>> net = LeNet5()
         >>>
         >>> net.set_jit_config(jitconfig)
     """
-    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'].")
+    def __init__(self, jit_level="O1", exc_mode="auto", jit_syntax_level="", **kwargs):
+        if jit_level not in ["O0", "O1", "O2"]:
+            raise ValueError("For 'jit_level' must be one of ['O0', 'O1', 'O2'].")
         if exc_mode not in ['auto', 'sink', 'no_sink']:
             raise ValueError("For 'exc_mode' must be one of '['auto', 'sink', 'no_sink']'.")
+        if jit_syntax_level != "" and jit_syntax_level not in ['STRICT', 'COMPATIBLE', 'LAX']:
+            raise ValueError("For 'jit_syntax_level' must be one of '['STRICT', 'LAX']'.")
         self.jit_config_dict = kwargs
         self.jit_config_dict["jit_level"] = jit_level
         self.jit_config_dict["exc_mode"] = exc_mode
+        self.jit_config_dict["jit_syntax_level"] = jit_syntax_level

mindspore/common/lazy_inline.py

@@ -21,17 +21,136 @@ from functools import wraps
 
 def lazy_inline(fn=None, attrs=None):
     """
-    Make the cell to be reusable. The function graph will not be inline in the front.
+    Make the cell to be reusable. The corresponding sub graph will not be inline at first.
 
-    Registering the decorator of the built-in operator cell __init__
-    function will add save all the parameters of __init__ as operator attributes.
+    Registering the decorator of the built-in function `__init__` of a cell, the decorator
+    will add the parameters of `__init__` according to the `attrs` as the attributes of this cell.
+
+    .. warning::
+        This feature is only supported on Ascend and is not supported on other hardwares.
 
     Args:
-        fn (function): __init__ function of cell.
-        attrs (list(string) | string): attr list.
+        fn (function): `__init__` function of a cell.
+        attrs (Union[list[string], string]): The attributes list to add for the cell.
 
     Returns:
         function, original function.
+
+    Supported Platforms:
+        ``Ascend``
+
+    Examples:
+        >>> import numpy as np
+        >>> from mindspore import Tensor
+        >>> import mindspore.nn as nn
+        >>> from mindspore import lazy_inline
+        >>> from mindspore import context
+        >>> from mindspore import ops
+        >>> def conv3x3(in_channels, out_channels, stride=1, padding=1, pad_mode='pad'):
+        ...     return nn.Conv2d(in_channels, out_channels,
+        ...                      kernel_size=3, stride=stride, padding=padding, pad_mode=pad_mode)
+        ...
+        >>> def conv1x1(in_channels, out_channels, stride=1, padding=0, pad_mode='pad'):
+        ...     return nn.Conv2d(in_channels, out_channels,
+        ...                      kernel_size=1, stride=stride, padding=padding, pad_mode=pad_mode)
+        ...
+        >>> class Block(nn.Cell):
+        ...     expansion = 4
+        ...
+        ...     @lazy_inline
+        ...     def __init__(self,
+        ...                  in_channels,
+        ...                  out_channels,
+        ...                  stride=1,
+        ...                  down_sample=False):
+        ...         super(Block, self).__init__()
+        ...
+        ...         out_chls = out_channels
+        ...         self.conv1 = conv1x1(in_channels, out_chls, stride=1, padding=0)
+        ...         self.bn1 = nn.BatchNorm2d(out_chls)
+        ...
+        ...         self.conv2 = conv3x3(out_chls, out_chls, stride=stride, padding=1)
+        ...         self.bn2 = nn.BatchNorm2d(out_chls)
+        ...
+        ...         self.conv3 = conv1x1(out_chls, out_channels, stride=1, padding=0)
+        ...         self.bn3 = nn.BatchNorm2d(out_channels)
+        ...
+        ...         self.relu = nn.ReLU()
+        ...         self.downsample = down_sample
+        ...
+        ...         self.conv_down_sample = conv1x1(in_channels, out_channels,
+        ...                                         stride=stride, padding=0)
+        ...         self.bn_down_sample = nn.BatchNorm2d(out_channels)
+        ...         self.add = ops.Add()
+        ...
+        ...     def construct(self, x):
+        ...         identity = x
+        ...
+        ...         out = self.conv1(x)
+        ...         out = self.bn1(out)
+        ...         out = self.relu(out)
+        ...
+        ...         out = self.conv2(out)
+        ...         out = self.bn2(out)
+        ...         out = self.relu(out)
+        ...
+        ...         out = self.conv3(out)
+        ...         out = self.bn3(out)
+        ...
+        ...         if self.downsample:
+        ...             identity = self.conv_down_sample(identity)
+        ...             identity = self.bn_down_sample(identity)
+        ...
+        ...         out = self.add(out, identity)
+        ...         out = self.relu(out)
+        ...
+        ...         return out
+        ...
+        >>> class Net(nn.Cell):
+        ...     def __init__(self, block, num_classes=100):
+        ...         super(Net, self).__init__()
+        ...
+        ...         self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3, pad_mode='pad')
+        ...         self.bn1 = nn.BatchNorm2d(64)
+        ...         self.relu = nn.ReLU()
+        ...         self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, pad_mode='valid')
+        ...
+        ...         self.layer = self.MakeLayer(
+        ...             block, 50, in_channels=64, out_channels=2048, stride=2)
+        ...         self.avgpool = nn.AvgPool2d(7, 1)
+        ...         self.flatten = ops.Flatten()
+        ...
+        ...     def MakeLayer(self, block, layer_num, in_channels, out_channels, stride):
+        ...         layers = []
+        ...         resblk = block(in_channels, out_channels,
+        ...                        stride=stride, down_sample=True)
+        ...         layers.append(resblk)
+        ...
+        ...         for _ in range(1, layer_num):
+        ...             resblk = block(out_channels, out_channels, stride=1)
+        ...             layers.append(resblk)
+        ...
+        ...         return nn.SequentialCell(layers)
+        ...
+        ...     def construct(self, x):
+        ...         x = self.conv1(x)
+        ...         x = self.bn1(x)
+        ...         x = self.relu(x)
+        ...         x = self.maxpool(x)
+        ...         x = self.layer(x)
+        ...         x = self.avgpool(x)
+        ...         x = self.flatten(x)
+        ...         return x
+        ...
+        >>> def test_compile():
+        ...     net = Net(Block)
+        ...     inp = Tensor(np.ones([1, 3, 224, 224]).astype(np.float32))
+        ...     net(inp)
+        ...
+        >>> context.set_context(mode=context.GRAPH_MODE,
+        ...                     save_graphs=True, save_graphs_path="./lazy")
+        ...
+        >>> test_compile()
     """
 
     def wrap_cell(fn):
@@ -45,7 +164,7 @@ def lazy_inline(fn=None, attrs=None):
                 arguments = arguments.values()
             fn(self, *args, **kwargs)
             if attrs is None:
-                self.cell_init_args = type(self).__name__ + str(arguments)
+                self.cell_init_args = "lazy_inline_" + type(self).__name__ + str(arguments)
                 return
 
             if isinstance(attrs, list):
@@ -59,7 +178,7 @@ def lazy_inline(fn=None, attrs=None):
                     arguments = getattr(self, attrs)
             else:
                 raise ValueError(f"attrs must be list or string")
-            self.cell_init_args = type(self).__name__ + str(arguments)
+            self.cell_init_args = "lazy_inline_" + type(self).__name__ + str(arguments)
 
         return deco
 

mindspore/common/mindir_util.py

@@ -0,0 +1,101 @@
+# Copyright 2023 Huawei Technologies Co., Ltd
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ============================================================================
+"""mindir utility."""
+from __future__ import absolute_import
+
+import os
+from mindspore import log as logger
+from mindspore import _checkparam as Validator
+from mindspore.train.mind_ir_pb2 import ModelProto as mindir_model
+
+
+def load_mindir(file_name):
+    """
+    load protobuf file.
+
+    Args:
+        file_name (str): File name.
+
+    Returns:
+        ModelProto, mindir proto object.
+
+    Raises:
+        ValueError: The file does not exist or the file name format is incorrect.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> md = ms.load_mindir("test.mindir")
+    """
+
+    Validator.check_file_name_by_regular(file_name)
+    file_name = os.path.realpath(file_name)
+    model = mindir_model()
+
+    try:
+        with open(file_name, "rb") as f:
+            pb_content = f.read()
+            model.ParseFromString(pb_content)
+    except BaseException as e:
+        logger.critical(f"Failed to parse the file: {file_name} "
+                        f" please check the correct file.")
+        raise ValueError(e.__str__()) from e
+    finally:
+        pass
+
+    return model
+
+
+def save_mindir(model, file_name):
+    """
+    save protobuf file.
+
+    Args:
+        model (ModelProto): mindir model
+        file_name (str): File name.
+
+    Raises:
+        TypeError: The argument `model` is not a ModelProto object.
+        ValueError: The file path does not exist or the `file_name` format is incorrect.
+
+    Supported Platforms:
+        ``Ascend`` ``GPU`` ``CPU``
+
+    Examples:
+        >>> import mindspore as ms
+        >>> md = ms.load_mindir("test.mindir")
+        >>> md.user_info["version"]="pangu v100"
+        >>> ms.save_mindir(md,"test_new.mindir")
+        >>> md_new = ms.load_mindir("test_new.mindir")
+        >>> md_new.user_info
+    """
+
+    Validator.check_file_name_by_regular(file_name)
+    file_name = os.path.realpath(file_name)
+
+    if not isinstance(model, mindir_model):
+        raise TypeError("For 'save_mindir', the argument 'model' must be ModelProto, "
+                        "but got {}.".format(type(model)))
+    try:
+        with open(file_name, "wb") as f:
+            f.write(model.SerializeToString())
+    except BaseException as e:
+        logger.critical(f"Failed to save the file: {file_name} ,"
+                        f" please check the correct file.")
+        raise ValueError(e.__str__()) from e
+    finally:
+        pass

mindspore/common/parameter.py

@@ -125,15 +125,22 @@ class Parameter(Tensor_):
     the list of its parameters, and will appear, e.g. in `cell.get_parameters()` iterator.
 
     Note:
-        In auto_parallel mode of  "semi_auto_parallel" and "auto_parallel", if init `Parameter` by
-        a `Tensor`, the type of Parameter will be `Tensor`. `Tensor`
-        will save the shape and type info of a tensor with no memory usage. The shape can be changed while
-        compiling for auto-parallel. Call `init_data` will return a Tensor Parameter with initialized data.
-        If there is an operator in the network that requires part of the inputs to be Parameter,
-        then the Parameters as this part of the inputs are not allowed to be cast.
-        Give each `Parameter` a unique name to facilitate subsequent operations and updates.
-        If there are two or more `Parameter` objects with the same name in a network,
-        will be prompted to set a unique name when defining.
+        - In auto_parallel mode of `SEMI_AUTO_PARALLEL` and `AUTO_PARALLEL`, if init `Parameter` by
+          a `Tensor`, the type of Parameter will be `Tensor`. `Tensor` will save the shape and type info of a tensor
+          with no memory usage.
+
+        - The shape can be changed while
+          compiling for auto-parallel. Call `init_data` will return a Tensor Parameter with initialized data.
+
+        - If there is an operator in the network that requires part of the inputs to be Parameter,
+          then the Parameters as this part of the inputs are not allowed to be cast.
+
+        - Give each `Parameter` a unique name to facilitate subsequent operations and updates.
+          If there are two or more `Parameter` objects with the same name in a network,
+          will be prompted to set a unique name when defining.
+
+        - When directly printing a `Parameter`, you cannot view the actual values contained inside it.
+          You need to use the `Parameter.asnumpy()` method to access the actual values.
 
     Args:
         default_input (Union[Tensor, int, float, numpy.ndarray, list]): Parameter data,
@@ -174,11 +181,11 @@ class Parameter(Tensor_):
                 self.param_tuple = (self.param_a, self.param_a)
 
         requires_grad (bool): True if the parameter requires gradient. Default: ``True`` .
-        layerwise_parallel (bool): When layerwise_parallel is true in data/hybrid parallel mode,
-            broadcast and gradients communication would not be applied to parameters. Default: ``False`` .
-        parallel_optimizer (bool): It is used to filter the weight shard operation in semi auto or auto parallel
-            mode. It works only when enable parallel optimizer in `mindspore.set_auto_parallel_context()`.
-            Default: ``True`` .
+        layerwise_parallel (bool): When `layerwise_parallel` is true in data/hybrid parallel mode,
+            broadcast and gradients communication would not be applied to the `Parameter`. Default: ``False`` .
+        parallel_optimizer (bool): It is used to filter the weight shard operation in `SEMI_AUTO_PARALLEL` or
+            `AUTO_PARALLEL` mode. It works only when enable parallel optimizer in
+            `mindspore.set_auto_parallel_context()`. Default: ``True`` .
 
     Examples:
         >>> import numpy as np
@@ -322,6 +329,8 @@ class Parameter(Tensor_):
                     # in other place, so we can make a Tensor without copy data.
                     return (Tensor, data)
                 # make a copy of Tensor to init the parameter.
+                if data.dtype == mstype.bfloat16:
+                    return (Tensor, data.float().asnumpy(), mstype.bfloat16)
                 return (Tensor, data.asnumpy())
 
             not_init_data = _is_role_sched() or (_is_role_pserver() and _cache_enable()) or _is_in_parallel_mode()
@@ -348,11 +357,9 @@ class Parameter(Tensor_):
             init_in_server (bool): Whether trainable parameter updated by parameter server is
                 initialized on server. Default: ``False``.
 
-        Examples:
-            >>> from mindspore import Tensor, Parameter
-            >>> import numpy as np
-            >>> x = Parameter(Tensor(np.array([1, 2], dtype=np.float32)), name="param")
-            >>> x.set_param_ps(True)
+        Tutorial Examples:
+            - `Parameter Server Mode
+              <https://www.mindspore.cn/tutorials/experts/en/r2.2/parallel/parameter_server_training.html>`_
         """
         if not _is_ps_mode() or not (_is_role_worker() or _is_role_pserver() or _is_role_sched()):
             raise RuntimeError("Must complete following two steps before calling set_param_ps: \n"
@@ -404,7 +411,7 @@ class Parameter(Tensor_):
             >>> from mindspore import Tensor, Parameter
             >>> import numpy as np
             >>> x = Parameter(Tensor(np.array([1, 2], dtype=np.float32)), name="param")
-            >>> x.inited_param()
+            >>> x.inited_param
         """
         return self._inited_param
 
@@ -484,8 +491,9 @@ class Parameter(Tensor_):
         Get the fusion type (int) for communication operators corresponding to this parameter.
 
         In `AUTO_PARALLEL` and `SEMI_AUTO_PARALLEL` mode, some communication operators used for parameters or
-        gradients aggregation are inserted automatically. The value of fusion must be greater than or equal to 0.
-        When the value of fusion is 0, operators will not be fused together.
+        gradients aggregation are inserted automatically.
+        The value of `comm_fusion` must be greater than or equal to 0.
+        When the value of `comm_fusion` is ``0`` , operators will not be fused together.
 
         Examples:
             >>> from mindspore import Tensor, Parameter
@@ -563,8 +571,8 @@ class Parameter(Tensor_):
                 If `init` is a `Tensor` or `numbers.Number`, clone a new parameter with the same shape
                 and dtype, and the data of the new parameter will be set according to `init`. If `init`
                 is a `str`, the `init` should be the alias of the class inheriting from `Initializer`.
-                For example, if `init` is 'same', clone a new parameter with the same data, shape, and
-                dtype. Default: 'same'.
+                For example, if `init` is ``'same'``, clone a new parameter with the same data, shape, and
+                dtype. Default: ``'same'``.
 
         Returns:
             Parameter, a new parameter.
@@ -606,8 +614,8 @@ class Parameter(Tensor_):
         """
         Get the layerwise parallel status(bool) of the parameter.
 
-        When layerwise_parallel is true in `DATA_PARALLEL` and `HYBRID_PARALLEL` parallel mode, broadcast and gradients
-        communication would not be applied to parameters.
+        When `layerwise_parallel` is ``True`` in `DATA_PARALLEL` and `HYBRID_PARALLEL` parallel mode,
+        broadcast and gradients communication would not be applied to parameters.
 
         Examples:
             >>> from mindspore import Tensor, Parameter
@@ -745,7 +753,7 @@ class Parameter(Tensor_):
             >>> import numpy as np
             >>> x = Parameter(Tensor(np.array([[1, 2], [3, 4]], dtype=np.float32)), name="param")
             >>> x.data
-            Parameter (name=Parameter, shape=(2, 2), dtype=float32, requires=True)
+            Parameter (name=param, shape=(2, 2), dtype=Float32, requires_grad=True)
         """
         return self
 
@@ -806,6 +814,7 @@ class Parameter(Tensor_):
         Tensor_.__init__(param, tensor)
         param.init = None
         param.init_mode = None
+        param.has_init = False
         param.is_default_input_init = False
         Parameter.__init__(param, tensor, *args, **kwargs)
         return param
@@ -817,8 +826,9 @@ class Parameter(Tensor_):
 
         Args:
             data (Union[Tensor, int, float]): New data.
-            slice_shape (bool): If slice the parameter is set to true, the shape is not checked for consistency.
-                                Default: ``False``.
+            slice_shape (bool): If slice the parameter is set to ``True``, the shape consistency will not be checked.
+                                Default: ``False``. When `slice_shape` is ``True``, and the shapes are not consistent, a
+                                ValueError will be thrown.
 
         Returns:
             Parameter, the parameter after set data.
@@ -828,7 +838,7 @@ class Parameter(Tensor_):
             >>> import numpy as np
             >>> x = Parameter(Tensor(np.array([[1, 2], [3, 4]], dtype=np.float32)), name="param")
             >>> x.set_data(Tensor(np.array([[6, 6], [6, 6]], dtype=np.float32)))
-            Parameter (name=Parameter, shape=(2, 2), dtype=float32, requires=True)
+            Parameter (name=param, shape=(2, 2), dtype=Float32, requires_grad=True)
         """
         if not isinstance(data, (Tensor, int, float)):
             raise TypeError(f"Parameter data must be [`Tensor`, `int`, `float`] or a kind of `Tensor` "
@@ -843,7 +853,7 @@ class Parameter(Tensor_):
         Parameter._set_data_check_input_valid(self.shape, data.shape, current_tensor_is_init, incoming_tensor_is_init,
                                               slice_shape, self.slice_num)
         if self.dtype != data.dtype:
-            if mstype.implicit_conversion_seq[self.dtype] < mstype.implicit_conversion_seq[data.dtype]:
+            if mstype.implicit_conversion_seq.get(self.dtype) < mstype.implicit_conversion_seq.get(data.dtype):
                 self._raise_type_error(data.dtype)
             else:
                 from mindspore.ops import functional as F
@@ -950,12 +960,12 @@ class ParameterTuple(tuple):
         It is used to store the parameters of the network into the parameter tuple collection.
 
     Examples:
-            >>> from mindspore import Tensor, Parameter, ParameterTuple
-            >>> import numpy as np
-            >>> x = Parameter(Tensor(np.array([[1, 2], [3, 4]], dtype=np.float32)), name="param")
-            >>> y = Parameter(Tensor(np.array([[5, 6], [7, 8]], dtype=np.float32)), name="param1")
-            >>> pt = ParameterTuple([x, y])
-            >>> pt1 = pt.clone(prefix="new")
+        >>> from mindspore import Tensor, Parameter, ParameterTuple
+        >>> import numpy as np
+        >>> x = Parameter(Tensor(np.array([[1, 2], [3, 4]], dtype=np.float32)), name="param")
+        >>> y = Parameter(Tensor(np.array([[5, 6], [7, 8]], dtype=np.float32)), name="param1")
+        >>> pt = ParameterTuple([x, y])
+        >>> pt1 = pt.clone(prefix="new")
     """
 
     def __new__(cls, iterable):
@@ -985,20 +995,20 @@ class ParameterTuple(tuple):
                 in parametertuple.
 
             init (Union[Tensor, str, numbers.Number]): Clone the shape and dtype of Parameters in ParameterTuple and
-                set  data according to `init`. Default: 'same'.
+                set  data according to `init`. Default: ``'same'``.
 
                 - If `init` is a `Tensor` , set the new Parameter data to the input Tensor.
                 - If `init` is `numbers.Number` , set the new Parameter data to the input number.
                 - If `init` is a `str`, data will be set according to the initialization method of the same name in
-                  the `Initializer`.
-                - If `init` is 'same', the new Parameter has the same value with the original Parameter.
+                  the `Initializer`. When it is ``'same'``, the new Parameter will have the same value
+                  with the original Parameter.
 
         Returns:
             Tuple, the new Parameter tuple.
 
         Tutorial Examples:
             - `Cell and Parameter - Parameter Tuple
-              <https://mindspore.cn/tutorials/en/r2.1/advanced/modules/layer.html#parameter-tuple>`_
+              <https://mindspore.cn/tutorials/en/r2.2/advanced/modules/layer.html#parameter-tuple>`_
         """
         Validator.check_str_by_regular(prefix)
         new = []

mindspore/common/seed.py

@@ -41,12 +41,11 @@ def set_seed(seed):
     Set global seed.
 
     Note:
-        The global seed is used by numpy.random, mindspore.common.Initializer, mindspore.ops.function.random_func and
+        The global seed is used by numpy.random, mindspore.common.Initializer 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.function.random_func and
-        mindspore.nn.probability.distribution will use zero.
+        mindspore.common.Initializer will choose a random seed, 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
         numpy.random, so just set all seed by this API is recommended.
@@ -198,7 +197,8 @@ def _update_seeds(op_seed, kernel_name):
     """
     global _KERNEL_SEED
     if op_seed is not None:
-        _KERNEL_SEED[(kernel_name, op_seed)] = _KERNEL_SEED[(kernel_name, op_seed)] + (keyConstant[0] ^ keyConstant[2])
+        _KERNEL_SEED[(kernel_name, op_seed)] = _KERNEL_SEED.get((kernel_name, op_seed)) + \
+                                               (keyConstant[0] ^ keyConstant[2])
 
 
 def _get_op_seed(op_seed, kernel_name):