mindspore 1.10.0__cp38-cp38-win_amd64.whl → 2.0.0rc1__cp38-cp38-win_amd64.whl

mindspore/rewrite/api/symbol_tree.py

@@ -13,26 +13,26 @@
 # limitations under the License.
 # ============================================================================
 """Rewrite module api: SymbolTree."""
-from __future__ import absolute_import
 from typing import Optional
+from types import FunctionType
+import mindspore as ms
 
 from mindspore.nn import Cell
-from ..._checkparam import Validator
+from mindspore import _checkparam as Validator
 from .node import Node
 from ..symbol_tree_builder import SymbolTreeBuilder
 from ..symbol_tree import Position, SymbolTree as SymbolTreeImpl
 
+ParamTypes = (int, str, float, bool, Node)
+MsDtypes = (ms.float16, ms.float32, ms.float64)
+
 
 class SymbolTree:
     """
     A `SymbolTree` usually corresponding to forward method of a network.
 
     Args:
-        network (Cell): Network to be rewritten. Only support `Cell`-type-network now.
-
-    Raises:
-        RuntimeError: If `network` is not a Cell.
-        RuntimeError: If there is any unsupported ast node type while parsing or optimizing.
+        handler (SymbolTreeImpl): SymbolTree internal implementation instance.
     """
 
     def __init__(self, handler: SymbolTreeImpl):
@@ -56,13 +56,35 @@ class SymbolTree:
         Validator.check_value_type("network", network, [Cell], "SymbolTree")
         return cls(SymbolTreeBuilder(network).build())
 
-    def get_handler(self) -> SymbolTreeImpl:
-        """
-        Get handler of `SymbolTree` implementation.
+    @staticmethod
+    def _check_args_type(args):
+        for arg in args:
+            if arg not in MsDtypes and not isinstance(arg, ParamTypes):
+                raise TypeError(f"For call-function Node, got unsupported arg: {arg}, type: {type(arg)}")
+
+    @staticmethod
+    def _check_kwargs_type(kwargs):
+        for k, v in kwargs.items():
+            if not isinstance(k, str):
+                raise TypeError(f"For call-function Node, key in kwarg must be a str, but got: {type(v)}",)
+            if v not in MsDtypes and not isinstance(v, ParamTypes):
+                raise TypeError(f"For call-function Node, got unsupported kwarg value: {v}, type: {type(v)}")
+
+    def create_call_function(self, func, targets, *args, **kwargs): # pylint: disable=C0111
+        Validator.check_value_type("func", func, [FunctionType], "SymbolTree node")
+        Validator.check_element_type_of_iterable("targets", targets, [str], "SymbolTree node")
+        args_ = list(args)
+        SymbolTree._check_args_type(args_)
+        for i, arg in enumerate(args_):
+            if isinstance(arg, Node):
+                args_[i] = arg.get_handler()
+        SymbolTree._check_kwargs_type(kwargs)
+        for key, value in kwargs.items():
+            if isinstance(value, Node):
+                kwargs[key] = value.get_handler()
+        return Node(self._symbol_tree._create_call_function(func, targets, args_, kwargs)) # pylint: disable=W0212
 
-        Returns:
-            An instance of `SymbolTree`.
-        """
+    def get_handler(self) -> SymbolTreeImpl:
         return self._symbol_tree
 
     def nodes(self):
@@ -71,23 +93,19 @@ class SymbolTree:
 
         Returns:
             A generator for node of current `SymbolTree`.
+
+        Examples:
+            >>> from mindspore.rewrite import SymbolTree
+            >>> from lenet import Lenet
+            >>> net = Lenet()
+            >>> stree = SymbolTree.create(net)
+            >>> for node in stree.nodes():
+            ...     node.set_attribute("channel", 3)
         """
         for node in self._symbol_tree.nodes():
             yield Node(node)
 
     def get_node(self, node_name: str) -> Optional[Node]:
-        """
-        Get node by `node_name`.
-
-        Args:
-            node_name (str): A string represents name of node.
-
-        Returns:
-            An instance of node if find else None.
-
-        Raises:
-            TypeError: If `node_name` is not `str`.
-        """
         Validator.check_value_type("node_name", node_name, [str], "SymbolTree")
         node_impl = self._symbol_tree.get_node(node_name)
         if node_impl is None:
@@ -95,12 +113,6 @@ class SymbolTree:
         return Node(node_impl)
 
     def get_inputs(self) -> [Node]:
-        """
-        Get input nodes of current `SymbolTree`.
-
-        Returns:
-            [Node], the node list of the current `Symboltree`.
-        """
         return [Node(node_impl) for node_impl in self._symbol_tree.get_inputs()]
 
     def before(self, node: Node):
@@ -119,6 +131,15 @@ class SymbolTree:
 
         Raises:
             TypeError: if `node` is not a `Node`.
+
+        Examples:
+            >>> from mindspore.rewrite import SymbolTree
+            >>> from lenet import Lenet
+            >>> net = Lenet()
+            >>> stree = SymbolTree.create(net)
+            >>> for node in stree.nodes():
+            ...     if node.get_name() == "conv1":
+            ...         position = stree.before(node)
         """
         Validator.check_value_type("node", node, [Node], "SymbolTree")
         return self._symbol_tree.before(node.get_handler())
@@ -139,6 +160,15 @@ class SymbolTree:
 
         Raises:
             TypeError: If `node` is not a `Node`.
+
+        Examples:
+            >>> from mindspore.rewrite import SymbolTree
+            >>> from lenet import Lenet
+            >>> net = Lenet()
+            >>> stree = SymbolTree.create(net)
+            >>> for node in stree.nodes():
+            ...     if node.get_name() == "conv1":
+            ...         position = stree.after(node)
         """
         Validator.check_value_type("node", node, [Node], "SymbolTree")
         return self._symbol_tree.after(node.get_handler())
@@ -161,6 +191,16 @@ class SymbolTree:
             RuntimeError: If `position` is not belong to current `SymbolTree`.
             TypeError: If `position` is not a `Position`.
             TypeError: If `node` is not a `Node`.
+
+        Examples:
+            >>> from mindspore.rewrite import SymbolTree
+            >>> from lenet import Lenet
+            >>> net = Lenet()
+            >>> stree = SymbolTree.create(net)
+            >>> node = stree.get_node("conv1")
+            >>> position = stree.after(node)
+            >>> new_node = stree.create_call_function(F.abs, ["x"], node)
+            >>> stree.insert(position, new_node)
         """
         Validator.check_value_type("position", position, [Position], "SymbolTree")
         Validator.check_value_type("node", node, [Node], "SymbolTree")
@@ -178,6 +218,18 @@ class SymbolTree:
 
         Raises:
             TypeError: If `node` is not a `Node`.
+
+        Examples:
+            >>> from mindspore.rewrite import SymbolTree
+            >>> from lenet import Lenet
+            >>> net = Lenet()
+            >>> stree = SymbolTree.create(net)
+            >>> node = stree.get_node("conv1")
+            >>> input_node = node.get_inputs()[0]
+            >>> output_nodes = node.get_users()
+            >>> for n in output_nodes:
+            ...     n.set_arg(0, "x")
+            >>> stree.erase_node(node)
         """
         Validator.check_value_type("node", node, [Node], "SymbolTree")
         return Node(self._symbol_tree.erase_node(node.get_handler()))
@@ -207,9 +259,18 @@ class SymbolTree:
             An instance of Node represents root of node_tree been replaced in.
 
         Raises:
-            RuntimeError: Old node is isolated.
+            RuntimeError: Old node is not isolated.
             TypeError: If `old_node` is not a `Node`.
             TypeError: If `new_nodes` is not a `list` or node in `new_nodes` is not a `Node`.
+
+        Examples:
+            >>> from mindspore.rewrite import SymbolTree
+            >>> from lenet import Lenet
+            >>> net = Lenet()
+            >>> stree = SymbolTree.create(net)
+            >>> node = stree.get_node("conv1")
+            >>> new_node = stree.create_call_function(F.abs, ["x"], node)
+            >>> stree.replace(node, [new_node])
         """
         Validator.check_value_type("old_node", old_node, [Node], "SymbolTree")
         Validator.check_element_type_of_iterable("new_nodes", new_nodes, [Node], "SymbolTree")
@@ -217,35 +278,17 @@ class SymbolTree:
         return Node(self._symbol_tree.replace(old_node.get_handler(), nodes_impl))
 
     def set_output(self, index: int, return_value: str) -> Node:
-        """
-        Set return value of network.
-
-        Args:
-            index (int): Indicate which output being modified.
-            return_value (str): New return value to been set.
-
-        Returns:
-            Return node of current rewrite.
-
-        Raises:
-            RuntimeError: If `index` is out of range.
-            TypeError: If `index` is not a `int` number.
-            TypeError: If `return_value` is not a `str`.
-        """
         Validator.check_value_type("index", index, [int], "SymbolTree")
         Validator.check_value_type("return_value", return_value, [str], "SymbolTree")
         return Node(self._symbol_tree.set_output(return_value, index))
 
     def dump(self):
         """
-        Dump graph to console.
+        Print the ir map information corresponding to the network in 'SymbolTree' to the screen.
         """
         self._symbol_tree.dump()
 
     def print_node_tabulate(self):
-        """
-        Print node information of graph.
-        """
         self._symbol_tree.print_node_tabulate()
 
     def get_code(self) -> str:
@@ -254,6 +297,13 @@ class SymbolTree:
 
         Returns:
             A str represents source code of modified network.
+
+        Examples:
+            >>> from mindspore.rewrite import SymbolTree
+            >>> from lenet import Lenet
+            >>> net = Lenet()
+            >>> stree = SymbolTree.create(net)
+            >>> stree.get_code()
         """
         return self._symbol_tree.get_code()
 
@@ -264,25 +314,22 @@ class SymbolTree:
 
         Returns:
             A network object.
+
+        Examples:
+            >>> from mindspore.rewrite import SymbolTree
+            >>> from lenet import Lenet
+            >>> net = Lenet()
+            >>> stree = SymbolTree.create(net)
+            >>> stree.get_network()
         """
         return self._symbol_tree.get_network()
 
     def set_saved_file_name(self, file_name: str):
-        """
-        Set the name of the file used to save the network.
-
-        Args:
-            file_name (str): filename to be set.
-        """
         Validator.check_value_type("file_name", file_name, [str], "Saving network")
         self._symbol_tree.set_saved_file_name(file_name)
 
     def get_saved_file_name(self):
-        """Gets the filename used to save the network."""
         return self._symbol_tree.get_saved_file_name()
 
     def save_network_to_file(self):
-        """
-        Save the modified network to a file. Default file name is `network_define.py`.
-        """
         self._symbol_tree.save_network_to_file()

mindspore/rewrite/api/tree_node_helper.py

@@ -13,11 +13,10 @@
 # limitations under the License.
 # ============================================================================
 """Rewrite module api: TreeNodeHelper."""
-from __future__ import absolute_import
 from typing import Optional
 
 from mindspore import log as logger
-from ..._checkparam import Validator
+from mindspore import _checkparam as Validator
 from .symbol_tree import SymbolTree
 from .node import Node
 from .node_type import NodeType
@@ -37,7 +36,7 @@ class TreeNodeHelper:
         Getting symbol_tree from a `Tree` type `Node`.
 
         Args:
-            node (Node): A `Node` who may hold a sub-symbol_tree.
+            node (Node): A `Node` which may hold a sub-symbol_tree.
 
         Returns:
             An instance of SymbolTree represents sub-symbol_tree. Note that `node`'s symbol_tree maybe None, in this

mindspore/{compression/quant/__init__.py → rewrite/ast_creator_register.py}

@@ -1,4 +1,4 @@
-# Copyright 2020 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,17 +12,26 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 # ============================================================================
-"""
-Quantization module, including base class of the quantizer, the quantization aware training algorithm,
-and quantization utils.
 
-Note: This is an experimental interface that is subject to change and/or deletion.
-"""
+"""Registry the relation."""
 
 from __future__ import absolute_import
-from .quantizer import OptimizeOption
-from .qat import QuantizationAwareTraining, create_quant_config
-from .quant_utils import load_nonquant_param_into_quant_net, query_quant_layers
+from collections import UserDict
 
-__all__ = ["load_nonquant_param_into_quant_net", "query_quant_layers", "QuantizationAwareTraining",
-           "create_quant_config", "OptimizeOption"]
+
+class Registry(UserDict):
+    """Registry class for registry functions for creating ast node."""
+
+    def register(self, obj_str, obj):
+        """Register object by str."""
+        if isinstance(obj_str, str):
+            self[obj_str] = obj
+
+    def get(self, obj_str):
+        """Get the value by str."""
+        if not isinstance(obj_str, str):
+            raise TypeError("key for ast creator registry must be string.")
+        return self[obj_str]
+
+
+ast_creator_registry = Registry()

mindspore/rewrite/ast_helpers/__init__.py

@@ -16,9 +16,12 @@
 `ast_helpers` package of MindSpore Rewrite package.
 Define some ast helpers for manipulating python ast.
 """
-from __future__ import absolute_import
-from .ast_finder import AstFinder, StrChecker
+
+from .ast_finder import AstFinder, StrChecker, CheckPropertyIsUsed, GetPropertyOfObj
 from .ast_replacer import AstReplacer
 from .ast_modifier import AstModifier
+from .ast_creator import ast_args_creator, ast_assign_creator, ast_attributer_creator, ast_call_creator, \
+    ast_create_arg_value, ast_index_creator, ast_keyword_creator, ast_kwargs_creator, ast_name_creator, \
+    ast_num_creator, ast_str_creator, ast_subscript_creator
 
-__all__ = ["AstFinder", "AstReplacer", "AstModifier", "StrChecker"]
+__all__ = ["AstFinder", "AstReplacer", "AstModifier", "StrChecker", "CheckPropertyIsUsed", "GetPropertyOfObj"]

mindspore/rewrite/ast_helpers/ast_creator.py

@@ -0,0 +1,115 @@
+# 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.
+# ============================================================================
+"""Create ast node in specific scope."""
+import ast
+from mindspore.rewrite.ast_creator_register import ast_creator_registry
+import mindspore as ms
+
+
+def ast_args_creator(args: list):
+    """Create an arg list."""
+    ast_args = list()
+    for arg in args:
+        ast_arg = ast_create_arg_value(arg)
+        ast_args.append(ast_arg)
+    return ast_args
+
+
+def ast_assign_creator(targets: ast.AST, value: ast.AST):
+    """Create an ast.Assign node."""
+    return ast.Assign(targets=targets, value=value, lineno=0, col_offset=0)
+
+
+def ast_attributer_creator(attribute: str):
+    """Create an ast.Attribute node"""
+    value, attr = attribute.rsplit(".", 1)
+    if "." in value:
+        ast_value = ast_attributer_creator(value)
+    else:
+        ast_value = ast_name_creator(value)
+    return ast.Attribute(value=ast_value, attr=attr, lineno=0, col_offset=0, ctx="Load()")
+
+
+def ast_call_creator(func: ast.AST, args: list, keywords: list):
+    """Create an ast.Call node"""
+    return ast.Call(func=func, args=args, keywords=keywords, lineno=0, col_offset=0)
+
+
+def ast_create_arg_value(value):
+    """Create arg node by type."""
+    if isinstance(value, (int, float)):
+        ast_value = ast_num_creator(value)
+    elif isinstance(value, str):
+        ast_value = ast_str_creator(value)
+    elif value in (ms.float16, ms.float32, ms.float64):
+        ast_value = ast_attributer_creator(".".join(["mindspore", str(value).lower()]))
+    elif isinstance(value, ms.rewrite.node.Node):
+        ast_value = ast_str_creator(value.get_targets()[0])
+    else:
+        raise TypeError("Unsupported arg type: ", type(value))
+    return ast_value
+
+
+def ast_index_creator(index: ast.Num):
+    """Create ast.Index node."""
+    index = ast_num_creator(index)
+    return ast.Index(value=index, lineno=0, col_offset=0)
+
+
+def ast_keyword_creator(arg: str, value):
+    """Create ast.keyword node."""
+    ast_value = ast_create_arg_value(value)
+    return ast.keyword(arg=arg, value=ast_value)
+
+
+def ast_kwargs_creator(kwargs: dict):
+    """Create ast.keyword node list."""
+    keywords = list()
+    for k, v in kwargs.items():
+        kw = ast_keyword_creator(k, v)
+        keywords.append(kw)
+    return keywords
+
+
+def ast_name_creator(id_: str):
+    """Create an ast.Name node."""
+    return ast.Name(id=id_, ctx=ast.Store, lineno=0, col_offset=0)
+
+
+def ast_num_creator(num: int):
+    """Create an ast.Num node."""
+    return ast.Num(n=num, lineno=0, col_offset=0)
+
+
+def ast_str_creator(s: str):
+    """Create an ast.str node."""
+    return ast.Str(s=s, lineno=0, col_offset=0)
+
+
+def ast_subscript_creator(value: ast.AST, index: int):
+    """Create an ast.Subscript node."""
+    s = ast_index_creator(index)
+    return ast.Subscript(value=value, slice=s, lineno=0, col_offset=0, ctx=ast.Load)
+
+
+ast_creator_registry.register("Args", ast_args_creator)
+ast_creator_registry.register("Assign", ast_assign_creator)
+ast_creator_registry.register("Attribute", ast_attributer_creator)
+ast_creator_registry.register("Call", ast_call_creator)
+ast_creator_registry.register("Index", ast_index_creator)
+ast_creator_registry.register("KwArgs", ast_kwargs_creator)
+ast_creator_registry.register("Name", ast_name_creator)
+ast_creator_registry.register("Num", ast_num_creator)
+ast_creator_registry.register("Subscript", ast_subscript_creator)

mindspore/rewrite/ast_helpers/ast_finder.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 # ============================================================================
 """Find specific type ast node in specific scope."""
-from __future__ import absolute_import
+
 from typing import Type, Any
 import ast
 
@@ -127,3 +127,101 @@ class StrChecker(ast.NodeVisitor):
         self._hit = False
         self.generic_visit(self._context)
         return self._hit
+
+
+class FindConstValueInInit(ast.NodeVisitor):
+    """
+    Check if specific String exists in specific scope.
+
+    Args:
+        node (ast.AST): An instance of ast node as check scope.
+    """
+    def __init__(self, node: ast.AST):
+        self._context = node
+        self._pattern = ""
+        self._hit = False
+
+    def visit_Constant(self, node: ast.Constant):
+        if node.value == self._pattern:
+            self._hit = True
+        return node
+
+    def check(self, pattern: str) -> bool:
+        """
+        Check if `pattern` exists in `_context`.
+
+        Args:
+            pattern (str): A string indicates target pattern.
+
+        Returns:
+            A bool indicates if `pattern` exists in `_context`.
+        """
+        self._pattern = pattern
+        self._hit = False
+        self.generic_visit(self._context)
+        return self._hit
+
+
+class CheckPropertyIsUsed(ast.NodeVisitor):
+    """
+    Check whether a property is used.
+
+    Args:
+        node (ast.AST): An instance of ast node.
+    """
+    def __init__(self, node: ast.AST):
+        self._context = node
+        self._value = ""
+        self._attr = ""
+        self._hit = False
+
+    def visit_Attribute(self, node: ast.Attribute) -> Any:  # pylint: disable=invalid-name
+        """Visit a node of type ast.Attribute."""
+        if isinstance(node.value, ast.Name) and node.value.id == self._value and node.attr == self._attr:
+            self._hit = True
+        return super(CheckPropertyIsUsed, self).generic_visit(node)
+
+    def generic_visit(self, node: ast.AST) -> Any:
+        """
+        An override method, iterating over all nodes and save target ast nodes.
+        """
+        if self._hit:
+            return
+        super(CheckPropertyIsUsed, self).generic_visit(node)
+
+    def check(self, value, attr) -> bool:
+        """
+        Check whether `value` and `attr` exists.
+        """
+        self._value = value
+        self._attr = attr
+        self._hit = False
+        self.generic_visit(self._context)
+        return self._hit
+
+
+class GetPropertyOfObj(ast.NodeVisitor):
+    """
+    Check whether a property is used.
+
+    Args:
+        node (ast.AST): An instance of ast node.
+    """
+    def __init__(self, node: ast.AST):
+        self._context = node
+        self._property = set()
+
+    def visit_Assign(self, node: ast.Assign) -> Any:  # pylint: disable=invalid-name
+        """Visit a node of type ast.Attribute."""
+        target = node.targets[0]
+        if isinstance(target, ast.Attribute) and isinstance(target.value, ast.Name) and target.value.id == "self":
+            self._property.add(target.attr)
+        return super(GetPropertyOfObj, self).generic_visit(node)
+
+    def get(self):
+        """
+        Check whether `value` and `attr` exists.
+        """
+        self._property = set()
+        self.generic_visit(self._context)
+        return self._property

mindspore/rewrite/ast_helpers/ast_modifier.py

@@ -13,7 +13,6 @@
 # limitations under the License.
 # ============================================================================
 """Ast utils for create or update ast node."""
-from __future__ import absolute_import
 from typing import Optional
 import ast
 
@@ -242,8 +241,10 @@ class AstModifier(ast.NodeTransformer):
             An instance of ast.Assign which has been appended to 'init_func'.
         """
         return AstModifier.insert_assign_to_function(init_func, targets=targets,
-                                                     args=[ScopedValue.create_variable_value(field)],
-                                                     expr=ScopedValue(ValueType.NamingValue, "global_vars", "get"))
+                                                     expr=ScopedValue(ValueType.NamingValue, "", "setattr"),
+                                                     args=[ScopedValue(ValueType.NamingValue, "obj"),
+                                                           ScopedValue.create_variable_value(field)])
+
 
     @staticmethod
     def create_call_assign(targets: [ScopedValue], expr: ScopedValue, args: [ScopedValue],
@@ -460,7 +461,7 @@ class AstModifier(ast.NodeTransformer):
 
         Args:
             src_argument (ScopedValue): An instance of ScopedValue represents new argument.
-            dst_ast (ast.AST): Targets of ast.Assign.
+            dst_ast (ast.AST): Ast node to be updated by ScopedValue.
 
         Raises:
             TypeError: Input src_argument is not a ScopedValue
@@ -485,6 +486,18 @@ class AstModifier(ast.NodeTransformer):
                                    str(src_argument.type))
             dst_ast.value = src_argument.value
             return
+        if isinstance(dst_ast, ast.Num):
+            if src_argument.type not in [ValueType.IntValue, ValueType.FloatValue]:
+                raise RuntimeError("src_argument should be a IntValue or FloatValue, but got:",
+                                   str(src_argument.type))
+            dst_ast.n = src_argument.value
+            return
+        if isinstance(dst_ast, ast.Str):
+            if src_argument.type not in [ValueType.StringValue]:
+                raise RuntimeError("src_argument should be a StringValue, but got:",
+                                   str(src_argument.type))
+            dst_ast.s = src_argument.value
+            return
         if isinstance(dst_ast, ast.Name):
             if src_argument.type not in [ValueType.NamingValue, ValueType.StringValue]:
                 raise RuntimeError("src_argument.type should be ValueType.NamingValue or ValueType.StringValue.")

mindspore/rewrite/ast_helpers/ast_replacer.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 # ============================================================================
 """Replacing specific symbol name with another symbol name in specific scope."""
-from __future__ import absolute_import
+
 from typing import Any
 import ast
 

mindspore/rewrite/ast_transformers/__init__.py

@@ -13,6 +13,5 @@
 # limitations under the License.
 # ============================================================================
 """Transformers for optimizing ast."""
-from __future__ import absolute_import
 from .flatten_recursive_stmt import FlattenRecursiveStmt
 from .remove_return_out_of_if import RemoveReturnOutOfIf