mindstudio-probe 1.0.4__py3-none-any.whl → 1.1.1__py3-none-any.whl

msprobe/visualization/compare/graph_comparator.py

@@ -0,0 +1,130 @@
+# Copyright (c) 2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# 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.
+
+from msprobe.visualization.builder.msprobe_adapter import compare_node, get_compare_mode, run_real_data
+from msprobe.visualization.utils import GraphConst, load_json_file, load_data_json_file, get_csv_df
+from msprobe.visualization.graph.graph import Graph, NodeOp
+from msprobe.visualization.graph.node_colors import NodeColors
+from msprobe.visualization.compare.mode_adapter import ModeAdapter
+from msprobe.core.common.const import Const
+
+
+class GraphComparator:
+    def __init__(self, graphs, dump_path_param, output_path, framework=Const.PT_FRAMEWORK, mapping_dict=None):
+        self.graph_n = graphs[0]
+        self.graph_b = graphs[1]
+        self._parse_param(dump_path_param, output_path)
+        self.framework = framework
+        self.mapping_dict = mapping_dict
+
+    def compare(self):
+        """
+        比较函数，初始化结束后单独调用。比较结果写入graph_n
+        """
+        self._compare_nodes(self.graph_n.root)
+        self._postcompare()
+    
+    def add_compare_result_to_node(self, node, compare_result_list):
+        """
+        将比对结果添加到节点的输入输出数据中
+        Args:
+            node: 节点
+            compare_result_list: 包含参数信息和对比指标（真实数据对比模式除外）的list
+        """
+        # 真实数据比对，先暂存节点，在多进程对比得到精度指标后，再将指标添加到节点中
+        if self.ma.prepare_real_data(node):
+            return
+        compare_in_dict = {}
+        compare_out_dict = {}
+        # input和output对比数据分开
+        for item in compare_result_list:
+            if not isinstance(item, (list, tuple)) or not item:
+                continue
+            if '.output.' in item[0]:
+                compare_out_dict[item[0]] = item
+            else:
+                compare_in_dict[item[0]] = item
+        precision_index, other_dict = (
+            self.ma.parse_result(node, [compare_in_dict, compare_out_dict]))
+        node.data[GraphConst.JSON_INDEX_KEY] = precision_index
+        node.data.update(other_dict)
+        if NodeColors.get_node_error_status(self.ma.compare_mode, precision_index):
+            node.get_suggestions()
+    
+    def _parse_param(self, dump_path_param, output_path):
+        self.dump_path_param = dump_path_param
+        self.output_path = output_path
+        compare_mode = get_compare_mode(self.dump_path_param)
+        self.ma = ModeAdapter(compare_mode)
+        self.data_n_dict = load_data_json_file(dump_path_param.get('npu_json_path'))
+        self.data_b_dict = load_data_json_file(dump_path_param.get('bench_json_path'))
+        self.stack_json_data = load_json_file(dump_path_param.get('stack_json_path'))
+
+    def _postcompare(self):
+        self._handle_api_collection_index()
+        if not self.ma.compare_mode == GraphConst.REAL_DATA_COMPARE:
+            return
+        df = get_csv_df(True, self.ma.csv_data, self.ma.compare_mode)
+        df = run_real_data(self.dump_path_param, df, self.framework, True if self.mapping_dict else False)
+        compare_data_dict = {row[0]: row.tolist() for _, row in df.iterrows()}
+        for node in self.ma.compare_nodes:
+            precision_index, _ = self.ma.parse_result(node, [compare_data_dict])
+            node.data[GraphConst.JSON_INDEX_KEY] = precision_index
+            if NodeColors.get_node_error_status(self.ma.compare_mode, precision_index):
+                node.get_suggestions()
+
+    def _handle_api_collection_index(self):
+        """
+        api集合的指标, md5模式使用集合中所有api最小的指标，statistics和tensor模式使用集合中所有api最大的指标
+        md5模式下指标为0代表最差，statistics和tensor模式下指标为1代表最差
+        """
+        for node in self.graph_n.root.subnodes:
+            if node.op == NodeOp.api_collection:
+                precision_index = GraphConst.MAX_INDEX_KEY if self.ma.compare_mode == GraphConst.MD5_COMPARE \
+                    else GraphConst.MIN_INDEX_KEY
+                for api in node.subnodes:
+                    precision_index = min(precision_index,
+                                          api.data.get(GraphConst.JSON_INDEX_KEY, GraphConst.MAX_INDEX_KEY)) \
+                        if self.ma.compare_mode == GraphConst.MD5_COMPARE \
+                        else max(precision_index, api.data.get(GraphConst.JSON_INDEX_KEY, GraphConst.MIN_INDEX_KEY))
+                node.data[GraphConst.JSON_INDEX_KEY] = precision_index
+
+    def _compare_nodes(self, node_n):
+        """
+        递归遍历NPU树中的节点，如果在Bench中找到具有相同名称的节点，检查他们的祖先和参数信息，检查一致则及逆行精度数据对比
+        这里采用先序遍历，好处在于当这个节点被比较时，他的先序已经被匹配，这可以为后续的模糊匹配提供重要信息
+        """
+        if self.mapping_dict:
+            node_b, ancestors_n, ancestors_b = Graph.mapping_match(node_n, self.graph_b, self.mapping_dict)
+            if node_b:
+                ancestors_n.append(node_n.id)
+                ancestors_b.append(node_b.id)
+                node_n.matched_node_link = ancestors_b
+                node_b.matched_node_link = ancestors_n
+        else:
+            node_b, ancestors = Graph.match(self.graph_n, node_n, self.graph_b)
+            if node_b:
+                ancestors.append(node_b.id)
+                node_n.add_link(node_b, ancestors)
+        if node_b:
+            # 真实数据比对只会得到基本信息，并没有精度指标，需要调用多进程对比接口
+            compare_result_list = compare_node([node_n.id, node_b.id],
+                                               [self.data_n_dict, self.data_b_dict],
+                                               self.stack_json_data, self.ma.compare_mode)
+            if compare_result_list:
+                self.ma.add_csv_data(compare_result_list)
+                self.add_compare_result_to_node(node_n, compare_result_list)
+        for subnode in node_n.subnodes:
+            self._compare_nodes(subnode)

msprobe/visualization/compare/mode_adapter.py

@@ -0,0 +1,211 @@
+# Copyright (c) 2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# 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.
+
+import json
+import math
+from msprobe.core.common.const import CompareConst, Const
+from msprobe.visualization.utils import ToolTip, GraphConst, str2float
+
+
+class ModeAdapter:
+    def __init__(self, compare_mode):
+        self.compare_mode = compare_mode
+        self.csv_data = []
+        self.compare_nodes = []
+
+    @staticmethod
+    def _add_md5_compare_data(node_data, compare_data_dict):
+        precision_index = GraphConst.MAX_INDEX_KEY
+        for key, value in node_data.items():
+            if not isinstance(value, dict):
+                continue
+            compare_data = compare_data_dict.get(key)
+            if compare_data:
+                headers = CompareConst.MD5_COMPARE_RESULT_HEADER
+                id_list = [headers.index(x) for x in GraphConst.MD5_INDEX_LIST]
+                ModeAdapter._match_data(value, compare_data, GraphConst.MD5_INDEX_LIST, id_list)
+                # md5比对是否通过
+                if value.get(CompareConst.RESULT) != CompareConst.PASS:
+                    precision_index = GraphConst.MIN_INDEX_KEY
+                node_data[key] = value
+        return precision_index
+
+    @staticmethod
+    def _add_real_compare_data(node_data, compare_data_dict):
+        min_thousandth = float(1)
+        numbers = []
+        for key, value in node_data.items():
+            if not isinstance(value, dict):
+                continue
+            compare_data = compare_data_dict.get(key)
+            if compare_data:
+                headers = CompareConst.COMPARE_RESULT_HEADER
+                id_list = [headers.index(x) for x in GraphConst.REAL_DATA_INDEX_LIST]
+                ModeAdapter._match_data(value, compare_data, GraphConst.REAL_DATA_INDEX_LIST, id_list)
+                # 跳过scalar data，因为无法计算双千指标，会得到Nan
+                if not value.get(Const.SHAPE):
+                    continue
+                # 获取一个节点所有的输入或输出最小的双千指标
+                thousandth = value.get(CompareConst.ONE_THOUSANDTH_ERR_RATIO)
+                # 可能是None，可能是非数字内容str
+                try:
+                    thousandth = float(thousandth)
+                except (ValueError, TypeError):
+                    thousandth = None
+                if thousandth is not None:
+                    numbers.append(thousandth)
+                node_data[key] = value
+        # 双千指标都是None的异常情况
+        if not numbers:
+            min_thousandth = None
+        else:
+            min_thousandth = min(numbers + [min_thousandth])
+        return min_thousandth
+
+    @staticmethod
+    def _add_summary_compare_data(node_data, compare_data_dict):
+        max_relative_err = GraphConst.MIN_INDEX_KEY
+        # data_info: {'type': 'torch.Tensor', 'dtype': 'torch.float32', 'shape': [2, 536320], 'Max': 9.66036224, ...}
+        for key, data_info in node_data.items():
+            if not isinstance(data_info, dict):
+                continue
+            compare_data = compare_data_dict.get(key)
+            if compare_data:
+                dtype = data_info.get(Const.DTYPE)
+                # 对应比对结果csv的列
+                key_list = GraphConst.SUMMARY_INDEX_LIST
+                headers = CompareConst.SUMMARY_COMPARE_RESULT_HEADER
+                id_list = [headers.index(x) for x in key_list]
+                ModeAdapter._match_data(data_info, compare_data, key_list, id_list)
+                for index, item in enumerate(key_list[4:]):
+                    value = data_info.get(GraphConst.VALUE_INDEX_LIST[index])
+                    value_diff = data_info.get(key_list[index])
+                    relative_err = str2float(data_info.get(item))
+                    if isinstance(value, float) and isinstance(value_diff, float) \
+                            and dtype in GraphConst.SMALL_VALUES.keys():
+                        small_value = GraphConst.SMALL_VALUES.get(dtype)
+                        # 小值域
+                        if abs(value) <= small_value:
+                            data_info[item] = ToolTip.SMALL_VALUE_TIP.format(data_info.get(item),
+                                                                             GraphConst.VALUE_INDEX_LIST[index],
+                                                                             small_value)
+                            relative_err = GraphConst.MIN_INDEX_KEY \
+                                if abs(value_diff) <= GraphConst.SMALL_VALUES_ABS_ERROR.get(dtype) \
+                                else GraphConst.MAX_INDEX_KEY
+                    max_relative_err = max(max_relative_err, relative_err)
+                node_data[key] = data_info
+        max_relative_err = 1 if max_relative_err > 1 else max_relative_err
+        return max_relative_err
+
+    @staticmethod
+    def _match_data(data_dict, compare_data, key_list, id_list):
+        """
+        绑定精度指标到node的input_data和output_data
+        """
+        if len(key_list) != len(id_list):
+            return
+        for id_val, key in zip(id_list, key_list):
+            data_dict[key] = compare_data[id_val]
+
+    @staticmethod
+    def _check_list_len(data_list, len_num):
+        if len(data_list) < len_num:
+            raise ValueError(f"compare_data_dict_list must contain at least {len_num} items.")
+
+    def parse_result(self, node, compare_data_dict_list):
+        """
+        根据结果返回数据，分别是precision_index，和附加数据
+        """
+
+        other_dict = {}
+        if self.compare_mode == GraphConst.MD5_COMPARE:
+            ModeAdapter._check_list_len(compare_data_dict_list, 2)
+            precision_index_in = ModeAdapter._add_md5_compare_data(node.input_data, compare_data_dict_list[0])
+            precision_index_out = ModeAdapter._add_md5_compare_data(node.output_data, compare_data_dict_list[1])
+            # 所有输入输出md5对比通过，这个节点才算通过
+            precision_index = min(precision_index_in, precision_index_out)
+            other_result = CompareConst.PASS if precision_index == GraphConst.MAX_INDEX_KEY else CompareConst.DIFF
+            other_dict[CompareConst.RESULT] = other_result
+        elif self.compare_mode == GraphConst.SUMMARY_COMPARE:
+            ModeAdapter._check_list_len(compare_data_dict_list, 2)
+            ModeAdapter._add_summary_compare_data(node.input_data, compare_data_dict_list[0])
+            precision_index_out = ModeAdapter._add_summary_compare_data(node.output_data, compare_data_dict_list[1])
+            precision_index = precision_index_out
+        else:
+            ModeAdapter._check_list_len(compare_data_dict_list, 1)
+            min_thousandth_in = ModeAdapter._add_real_compare_data(node.input_data, compare_data_dict_list[0])
+            min_thousandth_out = ModeAdapter._add_real_compare_data(node.output_data, compare_data_dict_list[0])
+            if min_thousandth_in is not None and min_thousandth_out is not None:
+                change_percentage = min_thousandth_in - min_thousandth_out
+            else:
+                change_percentage = GraphConst.MIN_INDEX_KEY
+            change_percentage = GraphConst.MIN_INDEX_KEY if change_percentage < GraphConst.MIN_INDEX_KEY \
+                else change_percentage
+            precision_index = GraphConst.MAX_INDEX_KEY \
+                if change_percentage > GraphConst.MAX_INDEX_KEY else change_percentage
+        return precision_index, other_dict
+
+    def prepare_real_data(self, node):
+        """
+        为真实数据比较模式准备节点信息
+        """
+        if self.compare_mode == GraphConst.REAL_DATA_COMPARE:
+            self.compare_nodes.append(node)
+            return True
+        return False
+
+    def add_csv_data(self, compare_result_list):
+        if self.compare_mode != GraphConst.REAL_DATA_COMPARE:
+            return
+        self.csv_data.extend(compare_result_list)
+
+    def add_error_key(self, node_data):
+        """
+        根据不同的模式进行提供不同错误信息
+        """
+        for key, value in node_data.items():
+            if not isinstance(value, dict):
+                continue
+            if self.compare_mode == GraphConst.SUMMARY_COMPARE:
+                message = [CompareConst.MAX_RELATIVE_ERR, CompareConst.MIN_RELATIVE_ERR,
+                           CompareConst.MEAN_RELATIVE_ERR, CompareConst.NORM_RELATIVE_ERR]
+            elif self.compare_mode == GraphConst.REAL_DATA_COMPARE:
+                message = [CompareConst.ONE_THOUSANDTH_ERR_RATIO, CompareConst.FIVE_THOUSANDTHS_ERR_RATIO]
+            else:
+                # 输出件优化
+                message = []
+            value[GraphConst.ERROR_KEY] = message
+            node_data[key] = value
+
+    def get_tool_tip(self):
+        """
+        用于前端展示字段的具体含义
+        """
+        if self.compare_mode == GraphConst.SUMMARY_COMPARE:
+            tips = {
+                CompareConst.MAX_DIFF: ToolTip.MAX_DIFF,
+                CompareConst.MIN_DIFF: ToolTip.MIN_DIFF,
+                CompareConst.MEAN_DIFF: ToolTip.MEAN_DIFF,
+                CompareConst.NORM_DIFF: ToolTip.NORM_DIFF}
+        elif self.compare_mode == GraphConst.MD5_COMPARE:
+            tips = {Const.MD5: ToolTip.MD5}
+        else:
+            tips = {
+                CompareConst.ONE_THOUSANDTH_ERR_RATIO: ToolTip.ONE_THOUSANDTH_ERR_RATIO,
+                CompareConst.FIVE_THOUSANDTHS_ERR_RATIO: ToolTip.FIVE_THOUSANDTHS_ERR_RATIO,
+                CompareConst.COSINE: ToolTip.COSINE,
+                CompareConst.MAX_ABS_ERR: ToolTip.MAX_ABS_ERR,
+                CompareConst.MAX_RELATIVE_ERR: ToolTip.MAX_RELATIVE_ERR}
+        return json.dumps(tips)

msprobe/visualization/graph/__init__.py

@@ -0,0 +1,14 @@
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# 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.

msprobe/visualization/graph/base_node.py

@@ -0,0 +1,124 @@
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# 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.
+from msprobe.core.overflow_check.level import OverflowLevel
+from msprobe.visualization.graph.node_op import NodeOp
+from msprobe.visualization.utils import Suggestions, GraphConst
+from msprobe.visualization.builder.msprobe_adapter import format_node_data, compare_data
+
+
+class BaseNode:
+    def __init__(self, node_op, node_id, up_node=None):
+        self.op = node_op
+        self.id = node_id
+        self.data = {}
+        self.output_data = {}
+        self.input_data = {}
+        self.upnode = None
+        self.add_upnode(up_node)
+        self.subnodes = []
+        self.matched_node_link = []
+        self.suggestions = {}
+        self.stack_info = []
+        self.micro_step_id = None
+        self.overflow_level = None
+
+    def __str__(self):
+        info = f'id:\t{self.id}'
+        return info
+
+    def __eq__(self, other):
+        """
+        用来判断两个节点是否可以被匹配上，认为结构上是否一致
+        """
+        if not compare_data(self.input_data, other.input_data):
+            return False
+        if not compare_data(self.output_data, other.output_data):
+            return False
+        return True
+
+    def get_suggestions(self):
+        """
+        精度疑似有问题时，提供一些建议
+        """
+        if self.op == NodeOp.module:
+            self.suggestions[GraphConst.SUGGEST_KEY] = Suggestions.Module
+            self.suggestions[Suggestions.DUMP] = Suggestions.DUMP_URL
+        elif self.op == NodeOp.function_api:
+            self.suggestions[GraphConst.SUGGEST_KEY] = Suggestions.API
+            self.suggestions[Suggestions.API_ACCURACY_CHECKER] = Suggestions.API_ACCURACY_CHECKER_URL
+
+    def set_input_output(self, input_data, output_data):
+        self.input_data = input_data
+        self.output_data = output_data
+
+    def set_overflow_level(self, level):
+        if not level or not isinstance(level, OverflowLevel):
+            return
+        self.overflow_level = level
+
+    def add_upnode(self, node):
+        """
+        绑定upnode，用于对两个节点进行上下级关联
+        """
+        if not node or node.id == self.id or self.upnode:
+            return
+        self.upnode = node
+        node.subnodes.append(self)
+
+    def add_link(self, node, ancestors):
+        """
+        在节点匹配成功后进行匹配数据的录入
+        Args:
+            node: 和self相互匹配的节点
+            ancestors: 对面节点的祖先信息
+        """
+        self.matched_node_link = ancestors
+        node.matched_node_link = ancestors
+
+    def to_dict(self):
+        """
+        输出数据
+        """
+        result = {
+            'id': self.id,
+            'node_type': self.op.value,
+            'output_data': format_node_data(self.output_data),
+            'input_data': format_node_data(self.input_data),
+            'upnode': self.upnode.id if self.upnode else 'None',
+            'subnodes': [node.id for node in self.subnodes],
+            'matched_node_link': self.matched_node_link,
+            'suggestions': self.suggestions,
+            'stack_info': self.stack_info
+        }
+        if self.micro_step_id is not None:
+            result['micro_step_id'] = self.micro_step_id
+        # 是否存在overflow，并保存结果
+        if self.overflow_level and isinstance(self.overflow_level, OverflowLevel):
+            if self.data is None:
+                self.data = dict()
+            self.data['overflow_level'] = self.overflow_level.value
+        result['data'] = self.data
+        return result
+
+    def get_ancestors(self):
+        """
+        获取节点所有祖先的列表
+        """
+        ancestors = []
+        current_node = self.upnode
+        while current_node:
+            ancestors.append(current_node.id)
+            current_node = current_node.upnode
+        return list(reversed(ancestors))

msprobe/visualization/graph/graph.py

@@ -0,0 +1,200 @@
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# 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.
+from msprobe.core.overflow_check.checker import AnomalyDetector
+from msprobe.visualization.graph.base_node import BaseNode
+from msprobe.visualization.graph.node_op import NodeOp
+from msprobe.visualization.utils import GraphConst
+from msprobe.core.common.log import logger
+from msprobe.core.common.const import Const
+
+
+MAX_RECUR_LEVEL = 100
+
+
+class Graph:
+    def __init__(self, model_name, data_path='', dump_data=None):
+        self.node_map = {}
+        self.node_id_map = {}
+        self.add_node(NodeOp.module, model_name)
+        self.root = self.get_node(model_name)
+        self.data_path = data_path
+        self.dump_data = dump_data
+
+    def __str__(self):
+        infos = [f'{str(self.node_map.get(node_id))}' for node_id in self.node_map]
+        info = "\n".join(infos)
+        return info
+
+    @staticmethod
+    def match(graph_n, node_n, graph_b):
+        """
+        给定节点n，在另一个graph中匹配它对应的节点。前置条件是它的父节点匹配已经完成
+        目前采用完全匹配的方式，后续可能在这里加入一定的模糊匹配逻辑
+        返回匹配结果，匹配到的节点，以及祖先树。没匹配到则返回None, []
+        """
+        if not node_n or node_n.id not in graph_b.node_map:
+            return None, []
+        node_b = graph_b.node_map.get(node_n.id)
+        if node_n != node_b:
+            return None, []
+        ancestors_n = node_n.get_ancestors()
+        ancestors_b = node_b.get_ancestors()
+        if ancestors_n != ancestors_b:
+            return None, []
+        return node_b, ancestors_n
+
+    @staticmethod
+    def mapping_match(node_n, graph_b, mapping_dict):
+        """
+        根据映射配置对节点进行匹配
+        """
+        node_b = graph_b.node_map.get(mapping_dict.get(node_n.id, node_n.id))
+        if not node_b:
+            return None, [], []
+        ancestors_n = node_n.get_ancestors()
+        ancestors_b = node_b.get_ancestors()
+        return node_b, ancestors_n, ancestors_b
+
+    @staticmethod
+    def dfs(node, result):
+        info = node.to_dict()
+        result[node.id] = info
+        for subnode in node.subnodes:
+            Graph.dfs(subnode, result)
+
+    @staticmethod
+    def split_nodes_by_micro_step(nodes):
+        """
+        根据Module名称, 区分一个step中的多个micro steps.
+        一个micro step必须是一次完整的前反向过程
+        Example::
+            =============== micro step0
+            Module.forward
+            Module.forward
+            ...
+            Module.backward
+            Module.backward
+            =============== micro step1
+            Module.forward
+            Module.forward
+            ...
+            Module.backward
+            Module.backward
+            =============== micro step2
+            Module.forward
+            Module.forward
+            ...
+            Module.backward
+            Module.backward
+
+        如果是非Module节点，分类到前一个Module节点所在的micro step.
+        """
+        result = {}
+        micro_step = 0
+        result[micro_step] = []
+        backward_flag = False
+
+        for node in nodes:
+            if node.op == NodeOp.module:
+                if f'{Const.SEP}{Const.FORWARD}{Const.SEP}' in node.id:
+                    if backward_flag:
+                        micro_step += 1
+                        result[micro_step] = []
+                        backward_flag = False
+                else:
+                    backward_flag = True
+            result[micro_step].append(node)
+        return result
+
+    def add_node(self, node_op, node_id, up_node=None, id_accumulation=False):
+        """
+        在graph中进行节点的添加
+        Args:
+            node_op: 需要添加的节点类型
+            node_id: 需要添加的节点id
+            up_node：对应节点的父节点
+            id_accumulation: 是否对传入的重复node_id进行累加
+        """
+        if node_id in self.node_map:
+            if id_accumulation:
+                self.node_id_map[node_id] = 0
+            else:
+                return node_id
+        if id_accumulation:
+            if node_id in self.node_id_map:
+                self.node_id_map[node_id] += 1
+            else:
+                self.node_id_map[node_id] = 0
+            node_id = f'{node_id}.{self.node_id_map[node_id]}'
+        node = BaseNode(node_op, node_id, up_node)
+        self.node_map[node_id] = node
+        return node_id
+
+    def get_node(self, node_id):
+        """
+        返回节点，不存在返回None
+        """
+        return self.node_map.get(node_id, None)
+
+    def to_dict(self):
+        """
+        用于数据输出
+        """
+        result = {}
+        result[GraphConst.JSON_ROOT_KEY] = self.root.id if self.root else 'None'
+        result[GraphConst.JSON_DATA_KEY] = self.data_path
+        result[GraphConst.JSON_NODE_KEY] = {}
+        for node_id in self.node_map:
+            info = self.node_map.get(node_id).to_dict()
+            result[GraphConst.JSON_NODE_KEY][node_id] = info
+        return result
+
+    def paging_by_micro_step(self, graph_other=None):
+        """
+        给graph首层节点增加micro step标记，供前端分页展示，有助于在处理大规模图数据时进行优化和管理
+        比对场景中，同步更新另一个图graph_other中相应节点的micro step信息
+        Args:
+            self: 当前graph
+            graph_other: 可选参数，另一个graph
+        Returns: 分批的数量
+        """
+        batches_n = Graph.split_nodes_by_micro_step(self.root.subnodes)
+        for batch_number, nodes in batches_n.items():
+            for node in nodes:
+                node.micro_step_id = batch_number
+                # 在graph_other中更新已匹配节点的micro_step_id
+                if graph_other and node.matched_node_link:
+                    node_other = graph_other.get_node(node.matched_node_link[-1])
+                    if node_other:
+                        node_other.micro_step_id = batch_number
+        # 遍历graph_other根节点下的所有子节点，确保未匹配节点也有micro_step_id
+        if graph_other:
+            for node in graph_other.root.subnodes:
+                if node.micro_step_id is None:
+                    try:
+                        micro_step_id = int(node.id.split(Const.SEP)[-1])
+                    except ValueError:
+                        micro_step_id = 0
+                    node.micro_step_id = micro_step_id
+        return len(batches_n)
+
+    def overflow_check(self):
+        detector = AnomalyDetector(self.dump_data)
+        detector.analyze().filter()
+
+        for node_id, _node in self.node_map.items():
+            if detector.has_overflow(node_id):
+                lv = detector.get_overflow_level(node_id)
+                _node.set_overflow_level(lv)