mindspore 2.1.0__cp39-none-any.whl → 2.2.10__cp39-none-any.whl

mindspore/rewrite/namer.py

@@ -14,9 +14,9 @@
 # ============================================================================
 """Unique name producer for target, name of node, class name, etc."""
 
-from typing import Union
+from typing import Union, Tuple
 
-from .node import Node
+from .node.node import Node
 from .api.node_type import NodeType
 
 
@@ -33,7 +33,7 @@ class Namer:
         self._names: {str: int} = {}
 
     @staticmethod
-    def _real_name(name: str) -> str:
+    def _real_name(name: str) -> Tuple[str, int]:
         """
         Find real name. For example, "name1" is the real name of "name1_10", "name1" is the real name of "name1_10_3".
         If not find real name before find unique name, unique name may be not unique. For example:
@@ -47,21 +47,21 @@ class Namer:
             name (str): Origin name which may have digit prefix.
 
         Returns:
-            A string represents real-name.
+            A string represents real-name and a int represents suffix.
         """
         if name == '_':
-            return name
+            return name, None
         pos = name.rfind("_")
-        if pos == -1:
-            return name
+        if pos == -1 or pos == len(name) - 1:
+            return name, None
         digit = True
         for i in range(pos + 1, len(name)):
             if not name[i].isdigit():
                 digit = False
                 break
         if digit:
-            return Namer._real_name(name[:pos])
-        return name
+            return name[:pos], int(name[pos + 1:])
+        return name, None
 
     def get_name(self, origin_name: str) -> str:
         """
@@ -75,15 +75,28 @@ class Namer:
         """
         if origin_name == '_':
             return origin_name
-        origin_name = Namer._real_name(origin_name)
-        number = self._names.get(origin_name)
+        real_name, suffix_idx = Namer._real_name(origin_name)
+        name = origin_name
+        number = self._names.get(name)
         if number is None:
-            self._names[origin_name] = 1
-            return origin_name
+            self._names[name] = 1
+            if not suffix_idx:
+                # When _names is {x:2} and origin_name is y,
+                # origin_name is not in _names and can be returned.
+                return name
+            if suffix_idx and not self._names.get(real_name, -1) >= suffix_idx:
+                # When _names is {x:2} and origin_name is x_3,
+                # return x_3 and update _names to {x:2, x_3:1}
+                return name
+            # When _names is {x:2} and origin_name is x_1,
+            # set new_name to x_1_1 by set number to 1, and continue to update name.
+            number = 1
         while True:
-            new_name = f"{origin_name}_{number}"
+            new_name = f"{name}_{number}"
             number += 1
-            self._names[origin_name] = number
+            self._names[name] = number
+            # When _names is {x:2, x_3:1}, origin_name is x and number is update to 3,
+            # new_name x_3 is conflict with key x_3, so this new_name need to be skipped.
             if new_name in self._names.keys():
                 continue
             return new_name
@@ -141,16 +154,12 @@ class NodeNamer(Namer):
             if origin_name is None or not origin_name:
                 if node_or_name.get_node_type() in (NodeType.CallCell, NodeType.CallPrimitive, NodeType.CallFunction,
                                                     NodeType.Tree):
-                    if not isinstance(node_or_name, Node):
-                        raise TypeError("node_or_name should be Node, got: ", type(node_or_name))
-                    targets = node_or_name.get_targets()
-                    # return node and head node will not call this method
-                    if not targets:
-                        raise RuntimeError("node should has at lease one target except return-node and head-node: ",
-                                           node_or_name)
-                    origin_name = str(targets[0].value)
+                    origin_name = type(node_or_name.get_instance()).__name__
                 elif node_or_name.get_node_type() == NodeType.Python:
-                    origin_name = node_or_name.get_instance().__name__
+                    if node_or_name.get_instance():
+                        origin_name = type(node_or_name.get_instance()).__name__
+                    else:
+                        origin_name = "python_node"
                 elif node_or_name.get_node_type() == NodeType.Input:
                     origin_name = "parameter"
                 elif node_or_name.get_node_type() == NodeType.Output:

mindspore/rewrite/namespace.py

@@ -21,12 +21,21 @@ _ms_nn_ns = CellNamespace('mindspore.nn')
 _ms_ops_ns = CellNamespace('mindspore.ops.operations')
 _ms_functional_ns = CellNamespace('mindspore.ops.functional')
 
-
-def is_subtree(cls_name):
-    """Determine whether 'cls_name' is a subtree."""
-    if cls_name == "QuantizeWrapperCell":
+# Elements in _subtree_black_list will not be converted to symbol tree.
+# Only str and types are stored in _subtree_black_list.
+_subtree_black_list = ["QuantizeWrapperCell",]
+
+def is_subtree(cls_inst):
+    """Determine whether 'cls_inst' is a subtree."""
+    cls_name = type(cls_inst).__name__
+    black_list_types = tuple([elem for elem in _subtree_black_list if not isinstance(elem, str)])
+    if cls_name in _subtree_black_list or isinstance(cls_inst, black_list_types):
+        return False
+    if cls_name in _ms_common_ns and isinstance(cls_inst, _ms_common_ns[cls_name]):
+        return False
+    if cls_name in _ms_nn_ns and isinstance(cls_inst, _ms_nn_ns[cls_name]):
         return False
-    if cls_name in _ms_common_ns or cls_name in _ms_nn_ns or cls_name in _ms_ops_ns:
+    if cls_name in _ms_ops_ns and isinstance(cls_inst, _ms_ops_ns[cls_name]):
         return False
 
     return True

mindspore/{_extends/graph_kernel/expanders/complex → rewrite/node}/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2021-2022 Huawei Technologies Co., Ltd
+# Copyright 2022 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.
@@ -12,11 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-"""complex expanders init"""
-
-from .abs import CAbs
-from .add import CAdd
-from .div import CDiv
-from .mul import CMul
-from .sub import CSub
-from .real_div import CRealDiv
+"""
+SymbolTree node
+"""
+from mindspore.rewrite.node.node import Node, TreeNode
+from mindspore.rewrite.node.node_manager import NodeManager
+from mindspore.rewrite.node.call_function import CallFunction
+from mindspore.rewrite.node.cell_container import CellContainer
+from mindspore.rewrite.node.control_flow import ControlFlow

mindspore/rewrite/node/call_function.py

@@ -0,0 +1,79 @@
+# Copyright 2022 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.
+# ============================================================================
+"""CallFunction Node."""
+import ast
+from .node import Node
+from .node_manager import NodeManager
+from ..api.scoped_value import ScopedValue
+from ..api.node_type import NodeType
+from ..ast_helpers import AstModifier
+
+
+class CallFunction(Node, NodeManager):
+    """CallFunction is used for class internal function."""
+    def __init__(self, targets: [ScopedValue], func_name: ScopedValue, args: [ScopedValue],
+                 kwargs: {str: ScopedValue}, node_name: str, ast_node: ast.AST, ast_functiondef: ast.FunctionDef,
+                 stree, instance):
+        """
+        Constructor of CallFunction.
+
+        Args:
+            targets (list[ScopedValue]): A list of instance of ScopedValue. See detail in docstring of Node class.
+            args (list[ScopedValue]): A list of instance of ScopedValue. See detail in docstring of Node class.
+            kwargs (dict{str: ScopedValue}): A list of instance of ScopedValue. See detail in docstring of Node class.
+            func_name ([ScopedValue, optional]): An instance of ScopedValue. See detail in docstring of Node class.
+            node_name (str): A string represents name of node. Name of node will be unique when inserted into
+                SymbolTree. Name of node also used as field name in network class.
+            ast_node (ast.AST): An instance of ast.AST represents corresponding node in ast.
+            ast_functiondef (ast.FunctionDef): An instance of ast.FunctionDef represents corresponding function
+                definition in ast.
+            stree (SymbolTree): Symbol tree used to get node_namer.
+            instance: Object in network corresponding to this node.
+        """
+        if isinstance(func_name, str):
+            func_name = ScopedValue.create_naming_value(func_name)
+        Node.__init__(self, NodeType.CallFunction, ast_node, targets, func_name, args, kwargs, node_name, instance)
+        NodeManager.__init__(self, stree.get_node_namer())
+        NodeManager.set_ast_functiondef(self, ast_functiondef)
+        NodeManager.set_manager_name(self, func_name.value)
+
+    def erase_node(self, node):
+        """Erase node from CallFunction."""
+        NodeManager.erase_node(self, node)
+        # erase asts
+        ret = AstModifier.erase_ast_from_function(self.get_ast_functiondef(), node.get_ast())
+        if not ret:
+            raise ValueError(f"erase node failed, node {node.get_name()} not in function ast tree.")
+
+    def insert_node(self, new_node: Node, base_node: Node, before_node: bool, insert_to_ast: bool = True):
+        """
+        Insert a node before or after base_node.
+
+        Args:
+            new_node (Node): Node to be inserted.
+            base_node (Node): New node will be inserted before or after base_node.
+            before_node (bool): Indicate whether new node is inserted before base_node.
+            insert_to_ast (bool): Indicate whether ast nodes need to be updated.
+        """
+        NodeManager.insert_node(self, new_node, base_node, before_node)
+        if insert_to_ast:
+            stree = self.get_belong_symbol_tree()
+            stree.insert_to_ast_while_insert_node(new_node, base_node, before_node, self)
+
+    def set_belong_symbol_tree(self, symbol_tree):
+        """Set the symbol tree to which node belongs."""
+        self._belong_tree = symbol_tree
+        for node in self.nodes():
+            node.set_belong_symbol_tree(symbol_tree)

mindspore/rewrite/node/cell_container.py

@@ -0,0 +1,135 @@
+# Copyright 2022 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.
+# ============================================================================
+"""CellContainer Node."""
+import ast
+from mindspore import log as logger
+from .node import Node
+from .node_manager import NodeManager
+from ..api.scoped_value import ScopedValue
+from ..api.node_type import NodeType
+
+
+class CellContainer(Node, NodeManager):
+    """CellContainer is used for nn.SequencialCell."""
+
+    def __init__(self, ast_node: ast.AST, targets: [ScopedValue], func_name: ScopedValue,
+                 args: [ScopedValue], kwargs: {str: ScopedValue}, node_name: str, stree, instance):
+        """Constructor of CellContainer.
+
+        Args:
+            ast_node (ast.AST): An instance of ast.AST represents corresponding node in ast.
+            targets (list[ScopedValue]): A list of instance of ScopedValue. See detail in docstring of Node class.
+            func_name ([ScopedValue, optional]): An instance of ScopedValue. See detail in docstring of Node class.
+            args (list[ScopedValue]): A list of instance of ScopedValue. See detail in docstring of Node class.
+            kwargs (dict{str: ScopedValue}): A list of instance of ScopedValue. See detail in docstring of Node class.
+            node_name (str): A string represents name of node. Name of node will be unique when inserted into
+                SymbolTree. Name of node also used as field name in network class.
+            stree (SymbolTree): Symbol tree used to get node_namer.
+            instance: Object in network corresponding to this node.
+        """
+        if isinstance(func_name, str):
+            func_name = ScopedValue.create_naming_value(func_name)
+        Node.__init__(self, NodeType.CellContainer, ast_node, targets, func_name, args, kwargs, node_name, instance)
+        NodeManager.__init__(self, stree.get_node_namer())
+        NodeManager.set_manager_name(self, func_name.value)
+
+    def append(self, node, insert_to_ast: bool = True):
+        """ Append new node to node list. """
+        self.append_node(node, insert_to_ast)
+
+    def append_node(self, node, insert_to_ast: bool = True):
+        """ Append new node to node list. """
+        self.insert_node(node, self.get_tail(), False, insert_to_ast)
+
+    def erase(self, node):
+        """Erase node from container."""
+        self.erase_node(node)
+
+    def erase_node(self, node):
+        """Erase node from container."""
+        # add code `del self.container_name[node_index]` into __init__ function
+        _, init_ast_functiondef = self._get_stree_and_init_ast()
+        if not init_ast_functiondef:
+            logger.error(f"Erase node {node.get_name()} failed: get symboltree and __init__ ast failed.")
+            return
+        node_idx = self.nodes().index(node)
+        erase_code = f"del {self.get_func_name()}[{node_idx}]"
+        erase_ast = ast.parse(erase_code).body[0]
+        init_ast_functiondef.body.append(erase_ast)
+        # earse node in NodeManager
+        NodeManager.erase_node(self, node)
+
+    def insert(self, index, node, insert_to_ast: bool = True):
+        """Insert node into container according index"""
+        node_index = index + len(self._inputs)
+        if node_index >= self.node_count:
+            raise IndexError("In MindSpore Rewrite CellContainer, inserting a node raises index error! "
+                             f"node_index: {node_index} >= node_num: {self.node_count}")
+        self.insert_node(node, self.nodes()[node_index], False, insert_to_ast)
+
+    def insert_node(self, new_node: Node, base_node: Node, before_node: bool, insert_to_ast: bool = True):
+        """
+        Insert a node before or after base_node.
+
+        The instance is modified here. The scenario needs to be optimized.
+
+        Args:
+            new_node (Node): Node to be inserted.
+            base_node (Node): New node will be inserted before or after base_node.
+            before_node (bool): Indicate whether new node is inserted before base_node.
+            insert_to_ast (bool): Indicate whether ast nodes need to be updated.
+        """
+        # Insert node to NodeManager firstly to update node_name, which is used during insert ast.
+        # tail_node may be changed after insert node into node_manager, so we record tail node here.
+        tail_node = self.get_tail()
+        NodeManager.insert_node(self, new_node, base_node, before_node)
+        new_node.set_func_name(ScopedValue.create_naming_value(new_node.get_name()))
+        new_node.update_ast_node()
+        # add insert/append code into __init__ function
+        if insert_to_ast:
+            stree, init_ast_functiondef = self._get_stree_and_init_ast()
+            if not init_ast_functiondef:
+                logger.error(f"Insert new_node {new_node.get_name()} failed: get symboltree and __init__ ast failed.")
+                return
+            setattr(stree.get_origin_network(), new_node.get_name(), new_node.get_instance())
+            node_idx = self.nodes().index(base_node)
+            if before_node:
+                insert_code = f"{self.get_func_name()}._insert({node_idx}, self.{new_node.get_name()})"
+            else:
+                if base_node == tail_node:
+                    insert_code = f"{self.get_func_name()}.append(self.{new_node.get_name()})"
+                else:
+                    insert_code = f"{self.get_func_name()}._insert({node_idx + 1}, self.{new_node.get_name()})"
+            insert_ast = ast.parse(insert_code).body[0]
+            init_ast_functiondef.body.append(insert_ast)
+
+    def set_belong_symbol_tree(self, symbol_tree):
+        """Set the symbol tree to which node belongs."""
+        self._belong_tree = symbol_tree
+        for node in self.nodes():
+            node.set_belong_symbol_tree(symbol_tree)
+
+    def _get_stree_and_init_ast(self):
+        """Get symbol tree and ast of __init__ function from container."""
+        # add codes `del self.container_name[node_index]`` into __init__ function
+        stree = self.get_belong_symbol_tree()
+        if stree is None:
+            logger.error(f"Get symboltree of CellContainer {self.get_name()} failed.")
+            return None, None
+        init_ast_functiondef = stree.get_init_func_ast()
+        if init_ast_functiondef is None:
+            logger.error(f"Get ast of __init__ function from class {stree.get_opt_cls_name()} failed.")
+            return None, None
+        return stree, init_ast_functiondef

mindspore/rewrite/node/control_flow.py

@@ -0,0 +1,88 @@
+# Copyright 2022 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.
+# ============================================================================
+"""ControlFlow Node."""
+from typing import List
+import ast
+from .node import Node, TreeNode
+from .node_manager import NodeManager
+from ..api.scoped_value import ScopedValue
+from ..api.node_type import NodeType
+from ..ast_helpers import AstModifier
+
+
+class ControlFlow(Node, NodeManager):
+    """ControlFlow node is used for statements like loops and `if` ."""
+    def __init__(self, node_name: str, ast_body: List[ast.AST], stree):
+        """
+        Constructor of ControlFlow.
+
+        Args:
+            node_name (str): A string represents name of node. Name of node will be unique when inserted into
+                SymbolTree. Name of node also used as field name in network class.
+            ast_node (ast.AST): An instance of ast.AST represents control flow statements, can be one of ast.If,
+                ast.Ifexp, ast.For, ast.While.
+            is_orelse (bool): Whether process else branch of node.
+            stree (SymbolTree): Symbol tree used to get node_namer.
+        """
+        Node.__init__(self, NodeType.ControlFlow, ast_body, None, node_name, [], [], node_name, None)
+        NodeManager.__init__(self, stree.get_node_namer())
+        NodeManager.set_manager_name(self, node_name)
+        self.ast_body = ast_body
+
+    def erase_node(self, node):
+        """Erase node from container."""
+        NodeManager.erase_node(self, node)
+        # erase node's ast
+        ret = AstModifier.erase_ast_from_bodies(self.ast_body, node.get_ast())
+        if not ret:
+            raise ValueError(f"Erase node failed, node {node.get_name()} is not in ControlFlow ast tree.")
+
+    def insert_node(self, new_node: Node, base_node: Node, before_node: bool, insert_to_ast: bool = True):
+        """
+        Insert a node before or after base_node.
+
+        Args:
+            new_node (Node): Node to be inserted.
+            base_node (Node): New node will be inserted before or after base_node.
+            before_node (bool): Indicate whether new node is inserted before base_node.
+            insert_to_ast (bool): Indicate whether ast nodes need to be updated.
+        """
+        NodeManager.insert_node(self, new_node, base_node, before_node)
+        if insert_to_ast:
+            ast_assign = new_node.get_ast()
+            if ast_assign is None:
+                func_name = new_node.get_belong_symbol_tree().unique_func_name(new_node.get_name())
+                new_node.set_func_name(ScopedValue.create_naming_value(func_name, "self"))
+                ast_assign = new_node.update_ast_node()
+            # Save instance into _origin_network.
+            stree = self.get_belong_symbol_tree()
+            setattr(stree.get_origin_network(), new_node.get_name(), new_node.get_instance())
+            # Insert ast_assign to __init__ function
+            if isinstance(new_node, TreeNode):
+                init_code = f"self.{new_node.get_name()} = " \
+                            f"{new_node.symbol_tree.get_opt_cls_name()}(obj.{new_node.get_name()})"
+            else:
+                init_code = f"self.{new_node.get_name()} = obj.{new_node.get_name()}"
+            init_ast = ast.parse(init_code).body[0]
+            AstModifier.insert_assign_ast_to_function(stree.get_init_func_ast(), init_ast)
+            # Insert ast_assign to bodies
+            ast_base_node = base_node.get_ast() if base_node else None
+            AstModifier.insert_assign_ast_to_bodies(self.ast_body, ast_assign, ast_base_node, before_node)
+
+    def set_belong_symbol_tree(self, symbol_tree):
+        """Set the symbol tree to which node belongs."""
+        self._belong_tree = symbol_tree
+        for node in self.nodes():
+            node.set_belong_symbol_tree(symbol_tree)