mindstudio-probe 1.1.0__py3-none-any.whl → 1.2.1__py3-none-any.whl

msprobe/visualization/graph/graph.py

@@ -0,0 +1,209 @@
+# 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 fuzzy_match(node_n, node_b):
+        if not node_n or not node_b or not node_n.fuzzy_eq(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)

msprobe/visualization/graph/node_colors.py

@@ -0,0 +1,95 @@
+# 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 enum import Enum
+from msprobe.visualization.utils import GraphConst, ToolTip
+
+SUMMARY_DESCRIPTION = "此节点所有输入输出的统计量相对误差, 值越大代表测量值与标杆值的偏差越大, 相对误差计算方式:|(测量值-标杆值)/标杆值|"
+REAL_DATA_DESCRIPTION = (f"此节点所有输入的最小双千分之一和所有输出的最小双千分之一的差值的绝对值, 代表双千指标的变化情况, "
+                         f"值越大代表测量值与标杆值的偏差越大, 双千分之一指标计算方式：{ToolTip.ONE_THOUSANDTH_ERR_RATIO}")
+MD5_DESCRIPTION_N = "与标杆相比, 此节点任意输入输出的md5值不同"
+MD5_DESCRIPTION_Y = "与标杆相比, 此节点所有输入输出的md5值相同"
+NOT_MATCHED = "比对过程中节点未匹配上"
+
+
+class NodeColors(Enum):
+    # 枚举值后缀数字越小, 颜色越浅
+    # value值左闭右开, 两个值相同代表固定值
+    YELLOW_1 = ("#FFFCF3", {
+        GraphConst.SUMMARY_COMPARE: {GraphConst.VALUE: [0, 0.2], GraphConst.DESCRIPTION: SUMMARY_DESCRIPTION},
+        GraphConst.REAL_DATA_COMPARE: {GraphConst.VALUE: [0, 0.05], GraphConst.DESCRIPTION: REAL_DATA_DESCRIPTION},
+        GraphConst.MD5_COMPARE: {GraphConst.VALUE: [1, 1], GraphConst.DESCRIPTION: MD5_DESCRIPTION_Y},
+    })
+    YELLOW_2 = ("#FFEDBE", {
+        GraphConst.SUMMARY_COMPARE: {GraphConst.VALUE: [0.2, 0.4], GraphConst.DESCRIPTION: SUMMARY_DESCRIPTION},
+        GraphConst.REAL_DATA_COMPARE: {GraphConst.VALUE: [0.05, 0.1], GraphConst.DESCRIPTION: REAL_DATA_DESCRIPTION}
+    })
+    ORANGE_1 = ("#FFDC7F", {
+        GraphConst.SUMMARY_COMPARE: {GraphConst.VALUE: [0.4, 0.6], GraphConst.DESCRIPTION: SUMMARY_DESCRIPTION},
+        GraphConst.REAL_DATA_COMPARE: {GraphConst.VALUE: [0.1, 0.15], GraphConst.DESCRIPTION: REAL_DATA_DESCRIPTION}
+    })
+    ORANGE_2 = ("#FFC62E", {
+        GraphConst.SUMMARY_COMPARE: {GraphConst.VALUE: [0.6, 0.8], GraphConst.DESCRIPTION: SUMMARY_DESCRIPTION},
+        GraphConst.REAL_DATA_COMPARE: {GraphConst.VALUE: [0.15, 0.2], GraphConst.DESCRIPTION: REAL_DATA_DESCRIPTION}
+    })
+    RED = ("#FF704D", {
+        GraphConst.SUMMARY_COMPARE: {GraphConst.VALUE: [0.8, 1], GraphConst.DESCRIPTION: SUMMARY_DESCRIPTION},
+        GraphConst.REAL_DATA_COMPARE: {GraphConst.VALUE: [0.2, 1], GraphConst.DESCRIPTION: REAL_DATA_DESCRIPTION},
+        GraphConst.MD5_COMPARE: {GraphConst.VALUE: [0, 0], GraphConst.DESCRIPTION: MD5_DESCRIPTION_N},
+    })
+    GREY = ("#C7C7C7", {
+        GraphConst.VALUE: [], GraphConst.DESCRIPTION: NOT_MATCHED
+    })
+
+    def __init__(self, hex_value, mode_info):
+        self.hex_value = hex_value
+        self.mode_info = mode_info
+
+    @staticmethod
+    def get_node_colors(mode):
+        """
+        获取不同比对模式下的颜色说明
+        Args:
+            mode: 比对模式
+        Returns: 颜色说明
+        """
+        return {
+            color.hex_value: color.get_info_by_mode(mode) for color in NodeColors if color.get_info_by_mode(mode)
+        }
+
+    @staticmethod
+    def get_node_error_status(mode, value):
+        """
+        判断精度数据比对指标是否大于基准值
+        Args:
+            mode: 比对模式
+            value: 精度数据比对指标
+        Returns: bool
+        """
+        info = NodeColors.ORANGE_1.get_info_by_mode(mode)
+        if info and GraphConst.VALUE in info:
+            value_range = info[GraphConst.VALUE]
+            return value > value_range[0]
+        return False
+
+    def get_info_by_mode(self, mode):
+        if isinstance(self.mode_info, dict):
+            # 检查是否是模式特定的信息
+            if isinstance(next(iter(self.mode_info.values())), dict):
+                return self.mode_info.get(mode, {})
+            else:
+                # 所有模式共享相同的信息
+                return self.mode_info
+        return {}

msprobe/visualization/graph/node_op.py

@@ -0,0 +1,39 @@
+# 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 enum import Enum
+import re
+from msprobe.visualization.builder.msprobe_adapter import op_patterns
+
+
+class NodeOp(Enum):
+    module = 0
+    function_api = 1
+    api_collection = 9
+
+
+    @staticmethod
+    def get_node_op(node_name: str):
+        """
+        基于代表节点的字符串，解析节点种类
+        """
+        for op in NodeOp:
+            index = op.value
+            if index < 0 or index >= len(op_patterns):
+                raise Exception("NodeOp and op_patterns in MsprobeAdapter do not match")
+            pattern = op_patterns[index]
+            if re.match(pattern, node_name):
+                return op
+        raise Exception(f"Cannot parse node_name {node_name} into NodeOp")

msprobe/visualization/graph_service.py

@@ -0,0 +1,288 @@
+# 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 os
+import time
+import json
+from msprobe.core.common.file_utils import (FileOpen, check_file_type, create_directory, FileChecker,
+                                            check_file_or_directory_path)
+from msprobe.core.common.const import FileCheckConst, Const
+from msprobe.core.common.utils import CompareException
+from msprobe.core.overflow_check.checker import AnomalyDetector
+from msprobe.visualization.compare.graph_comparator import GraphComparator
+from msprobe.visualization.utils import GraphConst, check_directory_content
+from msprobe.visualization.builder.graph_builder import GraphBuilder, GraphExportConfig
+from msprobe.core.common.log import logger
+from msprobe.visualization.graph.node_colors import NodeColors
+from msprobe.core.compare.layer_mapping import generate_api_mapping_by_layer_mapping
+from msprobe.core.compare.utils import check_and_return_dir_contents
+from msprobe.visualization.graph.distributed_analyzer import DistributedAnalyzer
+
+current_time = time.strftime("%Y%m%d%H%M%S")
+
+
+def _compare_graph(input_param, args):
+    logger.info('Start building model graphs...')
+    # 对两个数据进行构图
+    dump_path_n = input_param.get('npu_path')
+    dump_path_b = input_param.get('bench_path')
+    construct_path_n = FileChecker(os.path.join(dump_path_n, GraphConst.CONSTRUCT_FILE),
+                                   FileCheckConst.FILE, FileCheckConst.READ_ABLE).common_check()
+    construct_path_b = FileChecker(os.path.join(dump_path_b, GraphConst.CONSTRUCT_FILE),
+                                   FileCheckConst.FILE, FileCheckConst.READ_ABLE).common_check()
+    data_path_n = FileChecker(os.path.join(dump_path_n, GraphConst.DUMP_FILE), FileCheckConst.FILE,
+                              FileCheckConst.READ_ABLE).common_check()
+    data_path_b = FileChecker(os.path.join(dump_path_b, GraphConst.DUMP_FILE), FileCheckConst.FILE,
+                              FileCheckConst.READ_ABLE).common_check()
+    stack_path_n = FileChecker(os.path.join(dump_path_n, GraphConst.STACK_FILE), FileCheckConst.FILE,
+                               FileCheckConst.READ_ABLE).common_check()
+    stack_path_b = FileChecker(os.path.join(dump_path_b, GraphConst.STACK_FILE), FileCheckConst.FILE,
+                               FileCheckConst.READ_ABLE).common_check()
+    graph_n = GraphBuilder.build(construct_path_n, data_path_n, stack_path_n, complete_stack=args.complete_stack)
+    graph_b = GraphBuilder.build(construct_path_b, data_path_b, stack_path_b, complete_stack=args.complete_stack)
+    logger.info('Model graphs built successfully, start Comparing graphs...')
+    # 基于graph、stack和data进行比较
+    dump_path_param = {
+        'npu_json_path': data_path_n,
+        'bench_json_path': data_path_b,
+        'stack_json_path': stack_path_n,
+        'is_print_compare_log': input_param.get("is_print_compare_log", True)
+    }
+    mapping_dict = None
+    if args.layer_mapping:
+        yaml_path = FileChecker(args.layer_mapping, FileCheckConst.FILE, FileCheckConst.READ_ABLE).common_check()
+        try:
+            mapping_dict = generate_api_mapping_by_layer_mapping(data_path_n, data_path_b, yaml_path)
+        except Exception:
+            logger.warning('The layer mapping file parsing failed, please check file format, mapping is not effective.')
+    graph_comparator = GraphComparator([graph_n, graph_b], dump_path_param, args, mapping_dict=mapping_dict)
+    graph_comparator.compare()
+    micro_steps = graph_n.paging_by_micro_step(graph_b)
+    # 开启溢出检测
+    if args.overflow_check:
+        graph_n.overflow_check()
+        graph_b.overflow_check()
+
+    return CompareGraphResult(graph_n, graph_b, graph_comparator, micro_steps)
+
+
+def _export_compare_graph_result(args, graphs, graph_comparator, micro_steps,
+                                 output_file_name=f'compare_{current_time}.vis'):
+    create_directory(args.output_path)
+    output_path = os.path.join(args.output_path, output_file_name)
+    task = GraphConst.GRAPHCOMPARE_MODE_TO_DUMP_MODE_TO_MAPPING.get(graph_comparator.ma.compare_mode)
+    export_config = GraphExportConfig(graphs[0], graphs[1], graph_comparator.ma.get_tool_tip(),
+                                      NodeColors.get_node_colors(graph_comparator.ma.compare_mode), micro_steps, task,
+                                      args.overflow_check)
+    GraphBuilder.to_json(output_path, export_config)
+    logger.info(f'Model graphs compared successfully, the result file is saved in {output_path}')
+
+
+def _build_graph(dump_path, args):
+    logger.info('Start building model graph...')
+    construct_path = FileChecker(os.path.join(dump_path, GraphConst.CONSTRUCT_FILE), FileCheckConst.FILE,
+                                 FileCheckConst.READ_ABLE).common_check()
+    data_path = FileChecker(os.path.join(dump_path, GraphConst.DUMP_FILE), FileCheckConst.FILE,
+                            FileCheckConst.READ_ABLE).common_check()
+    stack_path = FileChecker(os.path.join(dump_path, GraphConst.STACK_FILE), FileCheckConst.FILE,
+                             FileCheckConst.READ_ABLE).common_check()
+    graph = GraphBuilder.build(construct_path, data_path, stack_path, complete_stack=args.complete_stack)
+    micro_steps = graph.paging_by_micro_step()
+    # 开启溢出检测
+    if args.overflow_check:
+        graph.overflow_check()
+    return BuildGraphResult(graph, micro_steps)
+
+
+def _export_build_graph_result(out_path, graph, micro_steps, overflow_check,
+                               output_file_name=f'build_{current_time}.vis'):
+    create_directory(out_path)
+    output_path = os.path.join(out_path, output_file_name)
+    GraphBuilder.to_json(output_path, GraphExportConfig(graph, micro_steps=micro_steps, overflow_check=overflow_check))
+    logger.info(f'Model graph built successfully, the result file is saved in {output_path}')
+
+
+def _compare_graph_ranks(input_param, args, step=None):
+    dump_rank_n = input_param.get('npu_path')
+    dump_rank_b = input_param.get('bench_path')
+    npu_ranks = sorted(check_and_return_dir_contents(dump_rank_n, Const.RANK))
+    bench_ranks = sorted(check_and_return_dir_contents(dump_rank_b, Const.RANK))
+    if npu_ranks != bench_ranks:
+        logger.error('The number of ranks in the two runs are different. Unable to match the ranks.')
+        raise CompareException(CompareException.INVALID_PATH_ERROR)
+    compare_graph_results = []
+    for nr, br in zip(npu_ranks, bench_ranks):
+        logger.info(f'Start processing data for {nr}...')
+        input_param['npu_path'] = os.path.join(dump_rank_n, nr)
+        input_param['bench_path'] = os.path.join(dump_rank_b, br)
+        output_file_name = f'compare_{step}_{nr}_{current_time}.vis' if step else f'compare_{nr}_{current_time}.vis'
+        result = _compare_graph(input_param, args)
+        result.output_file_name = output_file_name
+        if nr != Const.RANK:
+            try:
+                result.rank = int(nr.replace(Const.RANK, ""))
+            except Exception as e:
+                logger.error('The folder name format is incorrect, expected rank+number.')
+                raise CompareException(CompareException.INVALID_PATH_ERROR) from e
+        # 暂存所有rank的graph，用于匹配rank间的分布式节点
+        compare_graph_results.append(result)
+
+    # 匹配rank间的分布式节点
+    if len(compare_graph_results) > 1:
+        DistributedAnalyzer({obj.rank: obj.graph_n for obj in compare_graph_results},
+                            args.overflow_check).distributed_match()
+        DistributedAnalyzer({obj.rank: obj.graph_b for obj in compare_graph_results},
+                            args.overflow_check).distributed_match()
+
+    for result in compare_graph_results:
+        _export_compare_graph_result(args, [result.graph_n, result.graph_b], result.graph_comparator,
+                                     result.micro_steps, output_file_name=result.output_file_name)
+
+
+def _compare_graph_steps(input_param, args):
+    dump_step_n = input_param.get('npu_path')
+    dump_step_b = input_param.get('bench_path')
+
+    npu_steps = sorted(check_and_return_dir_contents(dump_step_n, Const.STEP))
+    bench_steps = sorted(check_and_return_dir_contents(dump_step_b, Const.STEP))
+
+    if npu_steps != bench_steps:
+        logger.error('The number of steps in the two runs are different. Unable to match the steps.')
+        raise CompareException(CompareException.INVALID_PATH_ERROR)
+
+    for folder_step in npu_steps:
+        logger.info(f'Start processing data for {folder_step}...')
+        input_param['npu_path'] = os.path.join(dump_step_n, folder_step)
+        input_param['bench_path'] = os.path.join(dump_step_b, folder_step)
+
+        _compare_graph_ranks(input_param, args, step=folder_step)
+
+
+def _build_graph_ranks(dump_ranks_path, args, step=None):
+    ranks = sorted(check_and_return_dir_contents(dump_ranks_path, Const.RANK))
+    build_graph_results = []
+    for rank in ranks:
+        logger.info(f'Start processing data for {rank}...')
+        dump_path = os.path.join(dump_ranks_path, rank)
+        output_file_name = f'build_{step}_{rank}_{current_time}.vis' if step else f'build_{rank}_{current_time}.vis'
+        result = _build_graph(dump_path, args)
+        result.output_file_name = output_file_name
+        if rank != Const.RANK:
+            try:
+                result.rank = int(rank.replace(Const.RANK, ""))
+            except Exception as e:
+                logger.error('The folder name format is incorrect, expected rank+number.')
+                raise CompareException(CompareException.INVALID_PATH_ERROR) from e
+        build_graph_results.append(result)
+
+    if len(build_graph_results) > 1:
+        DistributedAnalyzer({obj.rank: obj.graph for obj in build_graph_results},
+                            args.overflow_check).distributed_match()
+
+    for result in build_graph_results:
+        _export_build_graph_result(args.output_path, result.graph, result.micro_steps, args.overflow_check,
+                                   result.output_file_name)
+
+
+def _build_graph_steps(dump_steps_path, args):
+    steps = sorted(check_and_return_dir_contents(dump_steps_path, Const.STEP))
+    for step in steps:
+        logger.info(f'Start processing data for {step}...')
+        dump_ranks_path = os.path.join(dump_steps_path, step)
+        _build_graph_ranks(dump_ranks_path, args, step)
+
+
+def _graph_service_parser(parser):
+    parser.add_argument("-i", "--input_path", dest="input_path", type=str,
+                        help="<Required> The compare input path, a dict json.", required=True)
+    parser.add_argument("-o", "--output_path", dest="output_path", type=str,
+                        help="<Required> The compare task result out path.", required=True)
+    parser.add_argument("-lm", "--layer_mapping", dest="layer_mapping", type=str,
+                        help="<Optional> The layer mapping file path.", required=False)
+    parser.add_argument("-oc", "--overflow_check", dest="overflow_check", action="store_true",
+                        help="<Optional> whether open overflow_check for graph.", required=False)
+    parser.add_argument("-f", "--fuzzy_match", dest="fuzzy_match", action="store_true",
+                        help="<Optional> Whether to perform a fuzzy match on the api name.", required=False)
+    parser.add_argument("-cs", "--complete_stack", dest="complete_stack", action="store_true",
+                        help="<Optional> Whether to use complete stack information.", required=False)
+
+
+def _graph_service_command(args):
+    with FileOpen(args.input_path, "r") as file:
+        input_param = json.load(file)
+    npu_path = input_param.get("npu_path")
+    bench_path = input_param.get("bench_path")
+    check_file_or_directory_path(npu_path, isdir=True)
+    if bench_path:
+        check_file_or_directory_path(bench_path, isdir=True)
+    if check_file_type(npu_path) == FileCheckConst.DIR and not bench_path:
+        content = check_directory_content(npu_path)
+        if content == GraphConst.RANKS:
+            _build_graph_ranks(npu_path, args)
+        elif content == GraphConst.STEPS:
+            _build_graph_steps(npu_path, args)
+        else:
+            result = _build_graph(npu_path, args)
+            _export_build_graph_result(args.output_path, result.graph, result.micro_steps, args.overflow_check)
+    elif check_file_type(npu_path) == FileCheckConst.DIR and check_file_type(bench_path) == FileCheckConst.DIR:
+        content_n = check_directory_content(npu_path)
+        content_b = check_directory_content(bench_path)
+        if content_n != content_b:
+            raise ValueError('The directory structures of npu_path and bench_path are inconsistent.')
+        if content_n == GraphConst.RANKS:
+            _compare_graph_ranks(input_param, args)
+        elif content_n == GraphConst.STEPS:
+            _compare_graph_steps(input_param, args)
+        else:
+            result = _compare_graph(input_param, args)
+            _export_compare_graph_result(args, [result.graph_n, result.graph_b],
+                                         result.graph_comparator, result.micro_steps)
+    else:
+        logger.error("The npu_path or bench_path should be a folder.")
+        raise CompareException(CompareException.INVALID_COMPARE_MODE)
+
+
+def _pt_graph_service_parser(parser):
+    _graph_service_parser(parser)
+
+
+def _pt_graph_service_command(args):
+    _graph_service_command(args)
+
+
+def _ms_graph_service_parser(parser):
+    _graph_service_parser(parser)
+
+
+def _ms_graph_service_command(args):
+    _graph_service_command(args)
+
+
+class CompareGraphResult:
+    def __init__(self, graph_n, graph_b, graph_comparator, micro_steps, rank=0, output_file_name=''):
+        self.graph_n = graph_n
+        self.graph_b = graph_b
+        self.graph_comparator = graph_comparator
+        self.micro_steps = micro_steps
+        self.rank = rank
+        self.output_file_name = output_file_name
+
+
+class BuildGraphResult:
+    def __init__(self, graph, micro_steps, rank=0, output_file_name=''):
+        self.graph = graph
+        self.micro_steps = micro_steps
+        self.rank = rank
+        self.output_file_name = output_file_name