mindspore 2.4.0__cp311-cp311-win_amd64.whl

mindspore/rewrite/common/__init__.py

@@ -0,0 +1,19 @@
+# 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.
+# ============================================================================
+"""
+`common` package of MindSpore Rewrite package.
+Define some common instruments.
+"""
+from . import config

mindspore/rewrite/common/config.py

@@ -0,0 +1,24 @@
+# Copyright 2024 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.
+# ============================================================================
+"""
+MindSpore rewrite configurations.
+"""
+
+def clear_caches():
+    """clear rewrite caches"""
+    from ..parsers import AssignParser
+    AssignParser._cached_trees = {} # pylint: disable=protected-access
+    AssignParser._cached_functions = {} # pylint: disable=protected-access
+    AssignParser._cached_cell_containers = {} # pylint: disable=protected-access

mindspore/rewrite/common/error_log.py

@@ -0,0 +1,39 @@
+# 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.
+# ============================================================================
+"""Error Log for Rewrite."""
+
+import sys
+import ast
+if sys.version_info >= (3, 9):
+    import ast as astunparse # pylint: disable=reimported, ungrouped-imports
+else:
+    import astunparse
+
+
+def error_str(reason: str, child_node: ast.expr = None, father_node: ast.expr = None) -> str:
+    """Raise error func for Rewrite."""
+    output_estr = "Unsupported grammar in MindSpore Rewrite, "
+    output_estr += reason
+    if child_node:
+        output_estr += "\n" + "-" * 100 + "\n"
+        output_estr += astunparse.unparse(child_node).strip()
+        output_estr += "\n" + "-" * 100 + "\n"
+        if father_node:
+            output_estr += "in"
+    if father_node:
+        output_estr += "\n" + "-" * 100 + "\n"
+        output_estr += astunparse.unparse(father_node).strip()
+        output_estr += "\n" + "-" * 100 + "\n"
+    return output_estr

mindspore/rewrite/common/event.py

@@ -0,0 +1,28 @@
+# 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.
+# ============================================================================
+"""Event Enum as type of event."""
+
+from enum import Enum
+
+
+class Event(Enum):
+    """
+    An enum represents different type of event.
+
+    - TopologicalChangeEvent: an event represents topological relation changed in `SymbolTree`.
+    - CodeChangeEvent: an event represents code been changed when building `SymbolTree`.
+    """
+    TopologicalChangeEvent = 0
+    CodeChangeEvent = 1

mindspore/rewrite/common/namer.py

@@ -0,0 +1,271 @@
+# 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.
+# ============================================================================
+"""Unique name producer for target, name of node, class name, etc."""
+
+from typing import Union, Tuple
+
+from ..node import Node
+from ..api.node_type import NodeType
+
+
+class Namer:
+    """
+    Used for unique identity in a class-scope. current used for target of construct-function.
+    Namer records times of name been used, and add prefix to origin name for unique name. For example, when a Namer
+    record "name1" has been used 10 times, when a new request require a unique name base on 'name1', namer will respond
+    "name1_10" as unique name.
+    """
+
+    def __init__(self):
+        """Constructor of Namer."""
+        self._names: {str: int} = {}
+
+    @staticmethod
+    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:
+
+            1. "name1" has been used 10 times, which means "name1", "name1_2", "name1_3" ... "name1_10" has been used;
+            2. new request require a unique name base on 'name1_5'
+            3. If namer not find real name of "name1_5", namer will find that "name1_5" is never used and respond
+            "name1_5" as unique name which is used before, actually.
+
+        Args:
+            name (str): Origin name which may have digit prefix.
+
+        Returns:
+            A string represents real-name and a int represents suffix.
+        """
+        if name == '_':
+            return name, None
+        pos = name.rfind("_")
+        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 name[:pos], int(name[pos + 1:])
+        return name, None
+
+    def get_name(self, origin_name: str) -> str:
+        """
+        Get unique name from 'origin_name'.
+
+        Args:
+            origin_name (str): Origin name which may be duplicated.
+
+        Returns:
+            A string represents unique-name.
+        """
+        if origin_name == '_':
+            return 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[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"{name}_{number}"
+            number += 1
+            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
+
+    def add_name(self, name: str):
+        """
+        Add a name to Namer which should be unique.
+
+        Args:
+            name (str): A name should be unique in current namer.
+        """
+        if self._names.get(name) is None:
+            self._names[name] = 1
+
+
+class TargetNamer(Namer):
+    """
+    Used for unique-ing targets of node.
+    """
+    def get_unique_name(self, origin_name: str) -> str:
+        """
+        Get unique name from 'origin_name'.
+
+        Args:
+            origin_name (str): Origin name which may be duplicated.
+
+        Returns:
+            A string represents unique-name.
+        """
+        return super(TargetNamer, self).get_name(origin_name)
+
+
+class NodeNamer(Namer):
+    """
+    Used for unique-ing node-name which is also used as field of init-function and key of global_vars
+    """
+
+    def get_name(self, node_or_name: Union[Node, str]) -> str:
+        """
+        Override get_name in Namer class.
+        Get unique node_name from 'origin_name' or an instance of node.
+
+        Args:
+            node_or_name (Union[Node, str]): A string represents candidate node_name or an instance of node who require
+                                             A unique node_name.
+
+        Returns:
+            A string represents unique node_name.
+        """
+        if isinstance(node_or_name, Node):
+            origin_name = node_or_name.get_name()
+            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):
+                    origin_name = type(node_or_name.get_instance()).__name__
+                elif node_or_name.get_node_type() == NodeType.Python:
+                    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:
+                    origin_name = "return"
+                elif node_or_name.get_node_type() == NodeType.MathOps:
+                    origin_name = "math_ops"
+                else:
+                    origin_name = str(node_or_name.get_node_type())
+        elif isinstance(node_or_name, str):
+            if not node_or_name:
+                raise ValueError("input node_name is empty.")
+            origin_name = node_or_name
+        else:
+            raise ValueError("unexpected type of node_or_name:", type(node_or_name))
+        return super(NodeNamer, self).get_name(origin_name)
+
+
+class ClassNamer(Namer):
+    """
+    Used for unique-ing class name in a network.
+
+    Class name should be unique in a network, in other word, in a Rewrite process. So please do not invoke constructor
+    of `ClassNamer` and call `instance()` of `ClassNamer` to obtain singleton of ClassNamer.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self._prefix = "Opt"
+
+    @classmethod
+    def instance(cls):
+        """
+        Class method of `ClassNamer` for singleton of `ClassNamer`.
+
+        Returns:
+            An instance of `ClassNamer` as singleton of `ClassNamer`.
+        """
+
+        if not hasattr(ClassNamer, "_instance"):
+            ClassNamer._instance = ClassNamer()
+        return ClassNamer._instance
+
+    def get_name(self, origin_name: str) -> str:
+        """
+        Unique input `origin_name`.
+
+        Args:
+            origin_name (str): A string represents original class name.
+
+        Returns:
+            A string represents a unique class name generated from `origin_name`.
+        """
+
+        return super(ClassNamer, self).get_name(origin_name + self._prefix)
+
+    def add_name(self, name: str):
+        """
+        Declare a `name` so that other class can not apply this `name` anymore.
+
+        Args:
+            name (str): A string represents a class name.
+        """
+
+        super(ClassNamer, self).add_name(name + self._prefix)
+
+class FunctionNamer(Namer):
+    """
+    Used for unique-ing function name in a network.
+
+    Function name should be unique in a network, in other word, in a Rewrite process. So please do not invoke
+    constructor of `FunctionNamer` and call `instance()` of `FunctionNamer` to obtain singleton of FunctionNamer.
+    """
+
+    def __init__(self):
+        super().__init__()
+        self._prefix = ""
+
+    @classmethod
+    def instance(cls):
+        """
+        Class method of `FunctionNamer` for singleton of `FunctionNamer`.
+
+        Returns:
+            An instance of `FunctionNamer` as singleton of `FunctionNamer`.
+        """
+
+        if not hasattr(FunctionNamer, "_instance"):
+            FunctionNamer._instance = FunctionNamer()
+        return FunctionNamer._instance
+
+    def get_name(self, origin_name: str) -> str:
+        """
+        Unique input `origin_name`.
+
+        Args:
+            origin_name (str): A string represents original function name.
+
+        Returns:
+            A string represents a unique function name generated from `origin_name`.
+        """
+
+        return super(FunctionNamer, self).get_name(origin_name + self._prefix)
+
+    def add_name(self, name: str):
+        """
+        Declare a `name` so that other function can not apply this `name` anymore.
+
+        Args:
+            name (str): A string represents a function name.
+        """
+
+        super(FunctionNamer, self).add_name(name + self._prefix)

mindspore/rewrite/common/namespace.py

@@ -0,0 +1,118 @@
+# 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.
+# ============================================================================
+"""Define the namespace of MindSpore op definition."""
+import os
+import sys
+import inspect
+import types
+from mindspore._extends.parse.namespace import ModuleNamespace
+from mindspore.nn import CellList, SequentialCell
+
+
+_ms_common_ns = ModuleNamespace('mindspore.common')
+_ms_nn_ns = ModuleNamespace('mindspore.nn')
+_ms_ops_ns = ModuleNamespace('mindspore.ops.operations')
+_ms_functional_ns = ModuleNamespace('mindspore.ops.functional')
+
+# 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 = [CellList, SequentialCell]
+# Whether to convert mindspore built-in cells to symbol tree.
+_ms_cells_to_subtree = False
+# Paths of modules which will not be considered as third party module
+_ignore_third_party_paths = []
+
+def is_subtree(cls_inst):
+    """Determine whether 'cls_inst' is a subtree."""
+    cls_name = type(cls_inst).__name__
+    if isinstance(cls_inst, tuple(_subtree_black_list)):
+        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 bool(_ms_cells_to_subtree)
+    if cls_name in _ms_ops_ns and isinstance(cls_inst, _ms_ops_ns[cls_name]):
+        return False
+    return True
+
+
+def is_ms_function(func_obj):
+    """Determine whether 'func_obj' is a mindspore function."""
+    if isinstance(func_obj, types.BuiltinFunctionType):
+        return False
+    try:
+        # module, class, method, function, traceback, frame, or code object was expected
+        func_file = inspect.getabsfile(func_obj)
+    except TypeError:
+        return False
+    func_file = os.path.normcase(func_file)
+    ms_module = sys.modules.get('mindspore')
+    if ms_module is None:
+        return False
+    ms_path = ms_module.__file__
+    ms_path = os.path.normcase(ms_path)
+    ms_path = ms_path.rsplit(os.path.sep, 1)[0]
+    return func_file.startswith(ms_path)
+
+
+def is_functional(func_name):
+    """Determine whether 'cls_name' is a functional."""
+    return func_name in _ms_functional_ns
+
+
+def get_functional(func_name):
+    """Get the function corresponding to the func_name."""
+    if func_name in _ms_functional_ns:
+        return _ms_functional_ns[func_name]
+    return None
+
+
+def is_third_party(func_obj):
+    """Check whether func_obj is from third party module"""
+    module = inspect.getmodule(func_obj)
+    # A module without __file__ attribute (normally to be a c++ lib) is considered to be third party module.
+    if not hasattr(module, '__file__'):
+        return True
+    module_path = os.path.realpath(module.__file__)
+    for path in _ignore_third_party_paths:
+        if module_path.startswith(path):
+            return False
+    # Python builtin modules are treated as third-party libraries.
+    python_builtin_dir = os.path.realpath(os.path.dirname(os.__file__))
+    if module_path.startswith(python_builtin_dir):
+        return True
+    # Check if module is under user workspace directory.
+    user_workspace_dir = get_top_level_module_path(os.getcwd())
+    if module_path.startswith(user_workspace_dir):
+        return False
+    # Third-party modules are under site-packages.
+    split_path = module_path.split(os.path.sep)
+    if "site-packages" in split_path:
+        return True
+    return False
+
+
+def get_top_level_module_path(module_path):
+    """Get the path of the top level package of the current working directory."""
+    module_abspath = os.path.realpath(module_path)
+    upper_path = os.path.realpath(os.path.dirname(module_abspath))
+    if module_abspath == upper_path:
+        return module_abspath
+    # Check whether __init__.py exists in the upper directory.
+    init_path = os.path.join(upper_path, '__init__.py')
+    # If the path does not exist or is accessed without permission, os.path.isfile returns false.
+    if os.path.isfile(init_path):
+        module_abspath = get_top_level_module_path(upper_path)
+    return module_abspath

mindspore/rewrite/common/observable.py

@@ -0,0 +1,44 @@
+# 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.
+# ============================================================================
+"""Base class, observable of observer design pattern."""
+
+from .observer import Observer
+from .event import Event
+
+
+class Observable:
+    """Abstract class, observable of observer design pattern."""
+
+    def __init__(self):
+        self._observers: [Observer] = []
+
+    def changed(self, event: Event):
+        """
+        Called when current observable is changed.
+        `Observable` declares a change and all registered observers observe a change and do something for this change.
+        """
+
+        for observer in self._observers:
+            observer.on_change(event)
+
+    def reg_observer(self, observer: Observer):
+        """
+        Register an `observer` so that it can observe changes of current observable.
+
+        Args:
+             observer (Observer): An `Observer` to be registered into current observable.
+        """
+
+        self._observers.append(observer)

mindspore/rewrite/common/observer.py

@@ -0,0 +1,54 @@
+# 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.
+# ============================================================================
+"""Abstract class, observer of observer design pattern."""
+
+import abc
+from .event import Event
+
+
+class Observer(abc.ABC):
+    """Abstract class, observer of observer design pattern."""
+
+    def __init__(self):
+        self._event_filter = set()
+        self._event_filter.add(Event.CodeChangeEvent)
+
+    def add_event(self, event: Event):
+        """
+        Add event filter. An observer only responses to event in its event_filter list.
+        """
+        self._event_filter.add(event)
+
+    def remove_event(self, event: Event):
+        """
+        Remove event filter. An observer only responses to event in its event_filter list.
+        """
+        self._event_filter.remove(event)
+
+    def on_change(self, event: Event):
+        """
+        Called back when any changes occurred in linked `Observable`.
+        """
+
+        if event in self._event_filter:
+            self._on_change(event)
+
+    @abc.abstractmethod
+    def _on_change(self, event: Event):
+        """
+        Abstract method for defining how to response when any changes occurred in linked `Observable`.
+        """
+
+        raise NotImplementedError

mindspore/rewrite/node/__init__.py

@@ -0,0 +1,22 @@
+# 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.
+# ============================================================================
+"""
+SymbolTree node
+"""
+from .node import Node, TreeNode, LocalPrim
+from .node_manager import NodeManager
+from .call_function import CallFunction
+from .cell_container import CellContainer
+from .control_flow import ControlFlow