mindspore 2.0.0rc1__cp38-cp38-manylinux1_x86_64.whl → 2.2.0__cp38-cp38-manylinux1_x86_64.whl

mindspore/rewrite/api/node.py

@@ -14,12 +14,13 @@
 # ============================================================================
 """Rewrite module api: Node."""
 
-from typing import Union, Optional
+from typing import Union, Optional, List, Dict
+from types import FunctionType
 
 from mindspore.nn import Cell
 from mindspore.ops.primitive import Primitive
 from mindspore import _checkparam as Validator
-from ..node import Node as NodeImpl
+from ..node.node import Node as NodeImpl
 from ..symbol_tree import SymbolTree as SymbolTreeImpl
 from .node_type import NodeType
 from .scoped_value import ScopedValue
@@ -27,16 +28,17 @@ from .scoped_value import ScopedValue
 
 class Node:
     """
-    Node is a data structure represents a source code line in network.
+    A node is a data structure that expresses source code statements in a network.
 
-    For the most part, Node represents an operator invoking in forward which could be an instance of `Cell`, an instance
-    of `Primitive` or a callable method.
+    Each node usually corresponds to a statement in expanded forward evaluation process.
+
+    Nodes can express a ``Cell`` call statement, a ``Primitive`` call statement, an arithmetic operation statement, a
+    return statements, etc. of the forward calculation process.
 
     Args:
-        node (NodeImpl): A handler of `NodeImpl`. `NodeImpl` mentioned below is implementation of `Node` which is not
-            an interface of Rewrite. Rewrite recommend invoking specific create method of `Node`
-            to instantiate an instance of Node such as `create_call_cell` rather than invoking constructor of `Node`
-            directly, so don't care about what is `NodeImpl` and use its instance just as a handler.
+        node (NodeImpl): A handler of `NodeImpl`. It is recommended to call the specific methods in Node to create
+            a Node, such as 'create_call_cell', rather than calling the Node's constructor directly.
+            Don't care what `NodeImpl` is, just treat it as a handle.
     """
 
     def __init__(self, node: NodeImpl):
@@ -49,8 +51,8 @@ class Node:
         return self._node == other._node
 
     @staticmethod
-    def create_call_cell(cell: Cell, targets: [Union[ScopedValue, str]], args: [ScopedValue] = None,
-                         kwargs: {str: ScopedValue}=None, name: str = "", is_sub_net: bool = False) -> 'Node':
+    def create_call_cell(cell: Cell, targets: List[Union[ScopedValue, str]], args: List[ScopedValue] = None,
+                         kwargs: Dict[str, ScopedValue] = None, name: str = "", is_sub_net: bool = False) -> 'Node':
         """
         Create a node. Only support create from a `Cell` now.
 
@@ -62,20 +64,18 @@ class Node:
 
         Args:
             cell (Cell): Cell-operator of this forward-layer.
-            targets (list[ScopedValue]): Indicate output names. Used as targets of an assign statement in source code.
-                Rewrite will check and ensure the uniqueness of each target while node being inserted.
-            args (list[ScopedValue]): Indicate input names. Used as args of a call expression of an assign statement in
-                source code. Default is None indicate the `cell` has no args inputs. Rewrite will check and ensure the
-                uniqueness of each arg while node being inserted.
-            kwargs (dict): Type of key must be `str` and type of value must be `ScopedValue`.
-                Indicate keyword input names. Used as kwargs of a call expression of an assign statement in source code.
-                Default is None indicate the `cell` has no kwargs inputs. Rewrite will check and ensure the uniqueness
-                of each kwarg while node being inserted.
+            targets (List[Union[ScopedValue, str]]): Indicate output names. Used as targets of an assign statement in
+                source code.
+            args (List[ScopedValue]): Indicate input names. Used as args of a call expression of an assign statement in
+                source code. Default: ``None`` , which indicates the `cell` has no args inputs.
+            kwargs (Dict[str, ScopedValue]): Type of key must be `str` and type of value must be `ScopedValue`.
+                Indicate keyword input names. Used as kwargs of a call expression of an assign statement in source
+                code. Default: ``None`` , which indicates the `cell` has no kwargs inputs.
             name (str): Indicate the name of node. Used as field name in source code. Default is None. Rewrite will
-                generate name from `targets` when name is None. Rewrite will check and ensure the uniqueness of `name`
-                while node being inserted.
-            is_sub_net (bool): Indicate that is `cell` a network. If `is_sub_net` is true, Rewrite will try to parse the
-                `cell` to a TreeNode, else a CallCell Node. Default is a False.
+                generate name from `cell` when name is None. Rewrite will check and ensure the uniqueness of `name`
+                while node being inserted. Default: ``""`` .
+            is_sub_net (bool): Indicate that is `cell` a network. If `is_sub_net` is true, Rewrite will try to parse
+                the `cell` to a TreeNode, otherwise the `cell` is parsed to a CallCell node. Default: ``False`` .
 
         Returns:
             An instance of `Node`.
@@ -86,6 +86,21 @@ class Node:
             TypeError: If the type of `targets` is not in `[ScopedValue, str]`.
             TypeError: If arg in `args` is not a `ScopedValue`.
             TypeError: If key of `kwarg` is not a str or value of kwarg in `kwargs` is not a `ScopedValue`.
+
+        Examples:
+            >>> from mindspore.rewrite import SymbolTree, ScopedValue
+            >>> import mindspore.nn as nn
+            >>> # Define the network structure of LeNet5. Refer to
+            >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
+            >>> net = LeNet5()
+            >>> stree = SymbolTree.create(net)
+            >>> node = stree.get_node("conv1")
+            >>> position = stree.after(node)
+            >>> new_node = node.create_call_cell(cell=nn.ReLU(), targets=['x'],
+            ...                                  args=[ScopedValue.create_naming_value('x')], name='new_relu')
+            >>> stree.insert(position, new_node)
+            >>> print(type(new_node))
+            <class 'mindspore.rewrite.api.node.Node'>
         """
         Validator.check_value_type("cell", cell, [Cell, Primitive], "Node")
         Validator.check_element_type_of_iterable("targets", targets, [ScopedValue, str], "Node")
@@ -95,35 +110,107 @@ class Node:
             Validator.check_element_type_of_iterable("args", args, [ScopedValue], "Node")
         if kwargs is not None:
             Validator.check_element_type_of_dict("kwargs", kwargs, [str], [ScopedValue], "Node")
-        return Node(NodeImpl.create_call_op(cell, None, targets, ScopedValue.create_naming_value(name, "self"),
-                                            args, kwargs, name, is_sub_net))
+        return Node(NodeImpl.create_call_op(cell, None, targets, args, kwargs, name, is_sub_net))
+
+    @staticmethod
+    def create_call_function(function: FunctionType, targets: List[Union[ScopedValue, str]],
+                             args: List[ScopedValue] = None, kwargs: Dict[str, ScopedValue] = None) -> 'Node':
+        """
+        Create a node that corresponds to a function call. The `function` object is saved into network, and used via
+        getting object from `self.` .
+
+        Args:
+            function (FunctionType): The function to be called.
+            targets (List[Union[ScopedValue, str]]): indicates output names. Used as targets of an assign statement in
+                source code.
+            args (List[ScopedValue]): Indicate input names. Used as args of a call expression of an assign statement in
+                source code. Default: ``None`` , which indicates the `function` has no args inputs.
+            kwargs (Dict[str, ScopedValue]): Type of key must be `str` and type of value must be `ScopedValue`.
+                Indicate keyword input names. Used as kwargs of a call expression of an assign statement in source
+                code. Default: ``None`` , which indicates the `function` has no kwargs inputs.
+
+        Returns:
+            An instance of `Node`.
+
+        Raises:
+            TypeError: If `function` is not a `FunctionType`.
+            TypeError: If `targets` is not `list`.
+            TypeError: If the type of `targets` is not in `[ScopedValue, str]`.
+            TypeError: If arg in `args` is not a `ScopedValue`.
+            TypeError: If key of `kwarg` is not a str or value of kwarg in `kwargs` is not a `ScopedValue`.
+
+        Examples:
+            >>> from mindspore.rewrite import SymbolTree, ScopedValue
+            >>> import mindspore.nn as nn
+            >>> import mindspore.ops as ops
+            >>> # Define the network structure of LeNet5. Refer to
+            >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
+            >>> net = LeNet5()
+            >>> stree = SymbolTree.create(net)
+            >>> node = stree.get_node("conv1")
+            >>> position = stree.after(node)
+            >>> new_node = node.create_call_function(function=ops.abs, targets=['x'],
+            ...                                      args=[ScopedValue.create_naming_value('x')])
+            >>> stree.insert(position, new_node)
+            >>> print(new_node.get_node_type())
+            NodeType.CallFunction
+        """
+        Validator.check_value_type("function", function, [FunctionType, type], "create_call_function")
+        Validator.check_element_type_of_iterable("targets", targets, [ScopedValue, str], "create_call_function")
+        if args is not None:
+            Validator.check_element_type_of_iterable("args", args, [ScopedValue], "create_call_function")
+        if kwargs is not None:
+            Validator.check_element_type_of_dict("kwargs", kwargs, [str], [ScopedValue], "create_call_function")
+        return Node(NodeImpl._create_call_function(function, targets, args, kwargs))
+
+    @staticmethod
+    def create_input(param_name: str, default: Optional[ScopedValue] = None) -> 'Node':
+    # pylint: disable=missing-function-docstring
+        Validator.check_value_type("param_name", param_name, [str], "Node")
+        if default is not None:
+            Validator.check_value_type("default", default, [ScopedValue], "Node")
+        return Node(NodeImpl.create_input_node(None, param_name, default, name=f"input_{param_name}"))
 
     def get_handler(self) -> NodeImpl:
         return self._node
 
     def get_inputs(self) -> ['Node']:
         """
-        Get input nodes of current node in topological order.
+        Gets a list of nodes whose output values are used as input values for the current node.
 
         Returns:
-            A list of instances of `Node` as input nodes.
+            A list of nodes.
+
+        Examples:
+            >>> from mindspore.rewrite import SymbolTree
+            >>> # Define the network structure of LeNet5. Refer to
+            >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
+            >>> net = LeNet5()
+            >>> stree = SymbolTree.create(net)
+            >>> node = stree.get_node("conv2")
+            >>> inputs = node.get_inputs()
+            >>> print([input.get_name() for input in inputs])
+            ['max_pool2d']
         """
         return [Node(node_impl) for node_impl in self._node.get_inputs()]
 
     def get_users(self) -> ['Node']:
         """
-        Get output nodes of current node in topological order.
+        Get a list of nodes that use the output of the current node as input.
 
         Returns:
-            A list of nodes represents users.
+            A list of nodes.
 
         Examples:
             >>> from mindspore.rewrite import SymbolTree
-            >>> from lenet import Lenet
-            >>> net = Lenet()
+            >>> # Define the network structure of LeNet5. Refer to
+            >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
+            >>> net = LeNet5()
             >>> stree = SymbolTree.create(net)
             >>> node = stree.get_node("conv1")
             >>> users = node.get_users()
+            >>> print([user.get_name() for user in users])
+            ['relu']
         """
         belong_symbol_tree: SymbolTreeImpl = self._node.get_belong_symbol_tree()
         if belong_symbol_tree is None:
@@ -149,11 +236,14 @@ class Node:
 
         Examples:
             >>> from mindspore.rewrite import SymbolTree
-            >>> from lenet import Lenet
-            >>> net = Lenet()
+            >>> # Define the network structure of LeNet5. Refer to
+            >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
+            >>> net = LeNet5()
             >>> stree = SymbolTree.create(net)
-            >>> node = stree.get_node("conv1")
-            >>> node.set_arg(0, "x")
+            >>> node = stree.get_node("relu_3")
+            >>> node.set_arg(0, "fc1")
+            >>> print(node.get_args())
+            [fc1]
         """
         Validator.check_value_type("index", index, [int], "Node")
         Validator.check_value_type("arg", arg, [ScopedValue, str], "Node")
@@ -170,7 +260,8 @@ class Node:
         Args:
             arg_idx (int): Indicate which input being modified.
             src_node (Node): A `Node` as new input. Can be a node or name of node.
-            out_idx (int, optional): Indicate which output of `src_node` as new input of current node. Default is None
+            out_idx (int, optional): Indicate which output of `src_node` as new input of current node.
+                Default: ``None`` ,
                 which means use first output of `src_node` as new input.
 
         Raises:
@@ -184,12 +275,15 @@ class Node:
 
         Examples:
             >>> from mindspore.rewrite import SymbolTree
-            >>> from lenet import Lenet
-            >>> net = Lenet()
+            >>> # Define the network structure of LeNet5. Refer to
+            >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
+            >>> net = LeNet5()
             >>> stree = SymbolTree.create(net)
-            >>> src_node = stree.get_node("conv1")
-            >>> dst_node = stree.get_node("conv2")
-            >>> dst_node.set_arg_by_node(0, src_node)
+            >>> src_node = stree.get_node("fc1")
+            >>> dst_node = stree.get_node("relu_3")
+            >>> dst_node.set_arg_by_node(0, src_node, 0)
+            >>> print(dst_node.get_args())
+            [fc1]
         """
         Validator.check_value_type("arg_idx", arg_idx, [int], "Node")
         Validator.check_value_type("src_node", src_node, [Node], "Node")
@@ -202,6 +296,12 @@ class Node:
             belong_symbol_tree.set_node_arg_by_node(self._node, arg_idx, src_node.get_handler(), out_idx)
 
     def get_targets(self) -> [ScopedValue]:
+        """
+        Gets a list of output values for the current node.
+
+        Returns:
+            A list of outputs of type ``ScopedValue`` .
+        """
         return self._node.get_targets()
 
     def get_name(self) -> str:
@@ -215,43 +315,61 @@ class Node:
 
         Examples:
             >>> from mindspore.rewrite import SymbolTree
-            >>> from lenet import Lenet
-            >>> net = Lenet()
+            >>> # Define the network structure of LeNet5. Refer to
+            >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
+            >>> net = LeNet5()
             >>> stree = SymbolTree.create(net)
             >>> node = stree.get_node("conv1")
             >>> name = node.get_name()
+            >>> print(name)
+            conv1
         """
         return self._node.get_name()
 
     def get_node_type(self) -> NodeType:
         """
-        Get the node_type of current node.
+        Get the node_type of current node. See :class:`mindspore.rewrite.NodeType` for details on node types.
 
         Returns:
             A NodeType as node_type of node.
 
         Examples:
             >>> from mindspore.rewrite import SymbolTree
-            >>> from lenet import Lenet
-            >>> net = Lenet()
+            >>> # Define the network structure of LeNet5. Refer to
+            >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
+            >>> net = LeNet5()
             >>> stree = SymbolTree.create(net)
             >>> node = stree.get_node("conv1")
             >>> node_type = node.get_node_type()
+            >>> print(node_type)
+            NodeType.CallCell
         """
         return self._node.get_node_type()
 
     def get_instance_type(self) -> type:
         """
-        Get the instance_type of current node.
+        Gets the instance type called in the code corresponding to the current node.
 
-        - When node_type of current node is `CallCell`, instance_type is type of cell-op.
-        - When node_type of current node is `CallPrimitive`, instance_type is type of primitive-op.
-        - When node_type of current node is `Tree`, instance_type is type of network-cell.
-        - When node_type of current node is `Python`, `Input`, `Output` or `CallMethod`, instance_type should be
-          NoneType.
+        - When `node_type` of current node is `CallCell`, the code for that node calls an instance of type ``Cell`` .
+        - When `node_type` of current node is `CallPrimitive`, the code for that node calls an instance of
+          type ``Primitive`` .
+        - When `node_type` of current node is `Tree`, the code for that node calls an instance of network type.
+        - When `node_type` of current node is `Python`, `Input`, `Output` or `CallMethod`, the instance type
+          is ``NoneType`` .
 
         Returns:
-            A type object represents corresponding instance type of current node.
+            The type of instance called in the statement corresponding to the current node.
+
+        Examples:
+            >>> from mindspore.rewrite import SymbolTree
+            >>> # Define the network structure of LeNet5. Refer to
+            >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
+            >>> net = LeNet5()
+            >>> stree = SymbolTree.create(net)
+            >>> node = stree.get_node("conv1")
+            >>> instance_type = node.get_instance_type()
+            >>> print(instance_type)
+            <class 'mindspore.nn.layer.conv.Conv2d'>
         """
         return self._node.get_instance_type()
 
@@ -259,8 +377,47 @@ class Node:
         return self._node.get_instance()
 
     def get_args(self) -> [ScopedValue]:
+        """
+        Get arguments of current node.
+
+        Returns:
+            A list of arguments of type ``ScopedValue`` .
+
+        Examples:
+            >>> from mindspore.rewrite import SymbolTree
+            >>> # Define the network structure of LeNet5. Refer to
+            >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
+            >>> net = LeNet5()
+            >>> stree = SymbolTree.create(net)
+            >>> node = stree.get_node("conv1")
+            >>> print(node.get_args())
+            [x]
+        """
         return self._node.get_args()
 
+    def get_symbol_tree(self) -> 'SymbolTree':
+        """
+        Get the symbol tree which current node belongs to.
+
+        Returns:
+            SymbolTree, None if current node does not belong to any SymbolTree.
+
+        Examples:
+        >>> from mindspore.rewrite import SymbolTree
+        >>> # Define the network structure of LeNet5. Refer to
+        >>> # https://gitee.com/mindspore/docs/blob/r2.2/docs/mindspore/code/lenet.py
+        >>> net = LeNet5()
+        >>> stree = SymbolTree.create(net)
+        >>> node = stree.get_node("conv1")
+        >>> print(type(node.get_symbol_tree()))
+        <class 'mindspore.rewrite.api.symbol_tree.SymbolTree'>
+        """
+        from .symbol_tree import SymbolTree
+        stree_impl = self._node.get_belong_symbol_tree()
+        if not stree_impl:
+            return None
+        return SymbolTree(stree_impl)
+
     def get_kwargs(self) -> {str: ScopedValue}:
         return self._node.get_kwargs()
 

mindspore/rewrite/api/node_type.py

@@ -23,13 +23,17 @@ class NodeType(Enum):
     - Unknown: Not inited NodeType.
     - CallCell: `CallCell` node represents invoking cell-op in forward method.
     - CallPrimitive: `CallPrimitive` node represents invoking primitive-op in forward method.
+    - CallFunction: `CallFunction` node represents invoking a function in forward method.
     - CallMethod: `CallMethod` node represents invoking of method in forward method which can not be mapped to
       cell-op or primitive-op in MindSpore.
     - Python: `Python` node holds unsupported-ast-node or unnecessary-to-parse-ast-node.
     - Input: `Input` node represents input of `SymbolTree` corresponding to arguments of forward method.
     - Output: `Output` node represents output of SymbolTree corresponding to return statement of forward method.
     - Tree: `Tree` node represents sub-network invoking in forward method.
+    - CellContainer: `CellContainer` node represents invoking method :class:`mindspore.nn.SequentialCell` in
+      forward method.
     - MathOps: `MathOps` node represents a mathematical operation, such as adding or comparing in forward method.
+    - ControlFlow: `ControlFlow` node represents a control flow statement, such as if statement.
 
     """
     Unknown = 0
@@ -46,3 +50,4 @@ class NodeType(Enum):
     Tree = 9
     CellContainer = 10
     MathOps = 11
+    ControlFlow = 12

mindspore/rewrite/api/pattern_engine.py

@@ -31,10 +31,13 @@ class PatternNode:
     """
     `PatternNode` is defined as a node while defining pattern.
 
+    .. warning::
+        This is a set of experimental APIs that is subject to change or deletion.
+
     Args:
         pattern_node_name (str): Name of current node.
-        match_type (Type): A type represents what type would be matched of current node. Default: None.
-        inputs (list[PatternNode]): Input nodes of current node. Default: None.
+        match_type (Type): A type represents what type would be matched of current node. Default: ``Type[None]`` .
+        inputs (list[PatternNode]): Input nodes of current node. Default: ``None`` .
     """
 
     def __init__(self, pattern_node_name: str, match_type: Type = Type[None], inputs: ['PatternNode'] = None):
@@ -180,6 +183,9 @@ class PatternNode:
 class VarNode(PatternNode):
     """
     VarNode is a subclass of `PatternNode` whose `match` method is always return True.
+
+    .. warning::
+        This is a set of experimental APIs that is subject to change or deletion.
     """
 
     def __init__(self):
@@ -193,9 +199,12 @@ class Replacement(abc.ABC):
     """
     Interface of replacement function.
 
+    .. warning::
+        This is a set of experimental APIs that is subject to change or deletion.
+
     Examples:
         >>> from mindspore.rewrite import Replacement, Node
-        >>> from mindspore.nn import nn
+        >>> import mindspore.nn as nn
         >>> class BnReplacement(Replacement):
         ...     def build(self, pattern, is_chain_pattern: bool, matched):
         ...         bn_node: Node = matched.get(pattern.name())
@@ -232,10 +241,13 @@ class PatternEngine:
     """
     `PatternEngine` is defined how to transform a `SymbolTree` by `PattenNode`.
 
+    .. warning::
+        This is a set of experimental APIs that is subject to change or deletion.
+
     Args:
         pattern (Union[PatternNode, List]): An instance of `PatternNode` or a cell-type-list to construct `PatternNode`
             as root of a pattern.
-        replacement (callable): A callable define how to generate new_node.
+        replacement (callable): A callable define how to generate new_node. Default: ``None`` .
     """
 
     def __init__(self, pattern: Union[PatternNode, List], replacement: Replacement = None):
@@ -285,27 +297,14 @@ class PatternEngine:
                 is the matched node.
             new_nodes (list[Node]): A list of instance of Node as replacement.
         """
-        to_erase_list = matched_dict.values()
-        # keep all old nodes' inputs
-        inputs_dict = {}
-        for node in to_erase_list:
-            inputs_dict[node.get_name()] = (node.get_inputs())
         # call replace of SymbolTree
         new_root = stree.replace(old_root, new_nodes)
         # replace only support one-to-one replace or one-to-multi replace, we need to erase nodes except
         # cur_node manually
-        queue: [Node] = [old_root]
-        while queue:
-            cur_node: Node = queue.pop(0)
-            if cur_node in to_erase_list:
-                if cur_node.get_users():
-                    # if cur_node is depended on by other node, skip now.
-                    # cur_node will be push into queue and be erased later
-                    continue
-                if stree.get_node(cur_node.get_name()) is not None:
-                    # cur_node is not erased before
-                    stree.erase_node(cur_node)
-                queue.extend(inputs_dict.get(cur_node.get_name()))
+        to_erase_list = matched_dict.values()
+        for node in reversed(to_erase_list):
+            if node != old_root:
+                stree.erase(node)
         return new_root
 
     @staticmethod
@@ -316,7 +315,7 @@ class PatternEngine:
         for n in reversed(to_erase_list):
             if n.get_handler() is node:
                 continue
-            stree.erase_node(n)
+            stree.erase(n)
 
     def apply(self, stree: SymbolTree) -> bool:
         """
@@ -354,7 +353,7 @@ class PatternEngine:
         #  2. Visit b, b does not match pattern, add a to queue.
         #  3. Visit d, d does not match pattern, add c to queue.
         #  4. Visit a, a matches pattern and erased from SymbolTree, add xx to queue.
-        #  5. Visit c, d does not match pattern, add a to queue.
+        #  5. Visit c, c does not match pattern, add a to queue.
         #  At step 5, a is visited at second time but a is erased from SymbolTree at step 4.
         visited: [Node] = []
         while queue:

mindspore/rewrite/api/scoped_value.py

@@ -14,7 +14,7 @@
 # ============================================================================
 """Rewrite module api: ValueType and ScopedValue."""
 from enum import Enum
-from typing import Optional, Union
+from typing import Optional, Union, List, Tuple
 from mindspore import _checkparam as Validator
 
 
@@ -28,9 +28,7 @@ class ValueType(Enum):
     """
 
     # base type
-    StringValue = 0
-    IntValue = 1
-    FloatValue = 2
+    ConstantValue = 0
     # container type
     TupleValue = 20
     ListValue = 21
@@ -50,8 +48,9 @@ class ScopedValue:
     Args:
         arg_type (ValueType): A `ValueType` represents type of current value.
         scope (str): A string represents scope of current value. Take "self.var1" as an example, `scope` of this
-            var1 is "self".
+            var1 is "self". Default: ``""`` .
         value: A handler represents value of current value. The type of value is corresponding to `arg_type`.
+            Default: ``None`` .
     """
 
     def __init__(self, arg_type: ValueType, scope: str = "", value=None):
@@ -77,13 +76,11 @@ class ScopedValue:
         Examples:
             >>> from mindspore.rewrite import ScopedValue
             >>> variable = ScopedValue.create_variable_value(2)
+            >>> print(variable)
+            2
         """
-        if isinstance(value, int):
-            return cls(ValueType.IntValue, "", value)
-        if isinstance(value, float):
-            return cls(ValueType.FloatValue, "", value)
-        if isinstance(value, str):
-            return cls(ValueType.StringValue, "", value)
+        if isinstance(value, (type(None), int, float, str, bool)):
+            return cls(ValueType.ConstantValue, "", value)
         if isinstance(value, tuple):
             return cls(ValueType.TupleValue, "",
                        tuple(cls.create_variable_value(single_value) for single_value in value))
@@ -104,7 +101,7 @@ class ScopedValue:
 
         Args:
             name: (str): A string represents the identifier of another variable.
-            scope: (str): A string represents the scope of another variable.
+            scope: (str): A string represents the scope of another variable. Default: ``""`` .
 
         Returns:
             An instance of `ScopedValue`.
@@ -116,19 +113,23 @@ class ScopedValue:
         Examples:
             >>> from mindspore.rewrite import ScopedValue
             >>> variable = ScopedValue.create_naming_value("conv", "self")
+            >>> print(variable)
+            self.conv
         """
         Validator.check_value_type("name", name, [str], "ScopedValue")
         Validator.check_value_type("scope", scope, [str], "ScopedValue")
         return cls(ValueType.NamingValue, scope, name)
 
     @staticmethod
-    def create_name_values(names: Union[list, tuple], scopes: Union[list, tuple] = None) -> ['ScopedValue']:
+    def create_name_values(names: Union[List[str], Tuple[str]],
+                           scopes: Union[List[str], Tuple[str]] = None) -> List['ScopedValue']:
         """
         Create a list of naming `ScopedValue`.
 
         Args:
-            names (list[str] or tuple[str]): List or tuple of `str` represents names of referenced variables.
-            scopes (list[str] or tuple[str]): List or tuple of `str` represents scopes of referenced variables.
+            names (List[str] or Tuple[str]): List or tuple of `str` represents names of referenced variables.
+            scopes (List[str] or Tuple[str]): List or tuple of `str` represents scopes of referenced variables.
+                Default: ``None`` .
 
         Returns:
             An list of instance of `ScopedValue`.
@@ -140,7 +141,9 @@ class ScopedValue:
 
         Examples:
             >>> from mindspore.rewrite import ScopedValue
-            >>> variables = ScopedValue.create_name_values(["z", "z_1"], name="subnet")
+            >>> variables = ScopedValue.create_name_values(names=["z", "z_1"], scopes=["self", "self"])
+            >>> print(variables)
+            [self.z, self.z_1]
         """
         Validator.check_element_type_of_iterable("names", names, [str], "ScopedValue")
         if scopes is not None:
@@ -157,7 +160,7 @@ class ScopedValue:
         return result
 
     def __str__(self):
-        if self.type in (ValueType.IntValue, ValueType.FloatValue, ValueType.StringValue):
+        if self.type == ValueType.ConstantValue:
             return str(self.value)
         if self.type == ValueType.NamingValue:
             return f"{self.scope}.{self.value}" if self.scope else str(self.value)