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

msprobe/pytorch/service.py

@@ -1,22 +1,42 @@
+# 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.
+
 import functools
 import os
-
 from collections import namedtuple
+
 import torch
 from msprobe.core.common.const import Const
 from msprobe.core.common.exceptions import DistributedNotInitializedError, MsprobeException
 from msprobe.core.common.file_utils import create_directory
+from msprobe.core.common.utils import print_tools_ends_info
 from msprobe.core.data_dump.data_collector import build_data_collector
 from msprobe.core.data_dump.data_processor.base import ModuleForwardInputsOutputs, ModuleBackwardInputsOutputs
 from msprobe.core.data_dump.scope import BaseScope
+from msprobe.pytorch.api_accuracy_checker.common.utils import ApiData
 from msprobe.pytorch.common.log import logger
 from msprobe.pytorch.common.utils import get_rank_if_initialized
+from msprobe.pytorch.dump.kernel_dump.kernel_config import create_kernel_config_json
 from msprobe.pytorch.hook_module import remove_dropout
 from msprobe.pytorch.hook_module.api_registry import api_register
 from msprobe.pytorch.hook_module.hook_module import HOOKModule
 from msprobe.pytorch.module_processer import ModuleProcesser
-from msprobe.pytorch.api_accuracy_checker.common.utils import ApiData
+
 torch_version_above_or_equal_2 = torch.__version__.split('+')[0] >= '2.0'
+if torch_version_above_or_equal_2:
+    from msprobe.pytorch.api_accuracy_checker.tensor_transport_layer.dump_dispatch import run_ut_dispatch
 
 HookFn = namedtuple('hookFn', ['pre_hook', 'forward_hook', 'backward_hook', 'forward_hook_torch_version_below_2'])
 
@@ -32,6 +52,7 @@ class Service:
         self.first_start = True
         self.current_rank = None
         self.dump_iter_dir = None
+        self.should_stop_service = False
         self.attl = None
 
     @staticmethod
@@ -39,14 +60,29 @@ class Service:
         logger.info_on_rank_0("Data needed ends here.")
         api_register.api_originality()
 
+    @staticmethod
+    def is_registered_backward_hook(module):
+        if hasattr(module, '_backward_hooks') and \
+                len(module._backward_hooks) > 0 and \
+                module._is_full_backward_hook is False:
+            return True
+        return False
+
+    def check_register_full_backward_hook(self, module):
+        if self.is_registered_backward_hook(module):
+            module._backward_hooks.clear()
+            module._is_full_backward_hook = None
+            logger.warning("Found deprecated backward hooks. Removing them and switching to full backward hooks.")
+
     def build_hook(self, module_type, name):
         def pre_hook(api_or_module_name, module, args, kwargs):
+            if not self.should_execute_hook():
+                return args, kwargs
+
             if module_type == BaseScope.Module_Type_Module:
                 api_or_module_name = module.mindstudio_reserved_name
             self.data_collector.update_api_or_module_name(api_or_module_name)
 
-            if not self.switch:
-                return args, kwargs
             if self.config.online_run_ut:
                 return None, None
             if self.data_collector:
@@ -55,13 +91,13 @@ class Service:
             return args, kwargs
 
         def forward_hook(api_or_module_name, module, args, kwargs, output):
+            if not self.should_execute_hook():
+                return None
+
             if module_type == BaseScope.Module_Type_Module:
                 api_or_module_name = module.mindstudio_reserved_name
             self.data_collector.update_api_or_module_name(api_or_module_name)
 
-            if not self.switch:
-                return None
-
             if self.config.online_run_ut:
                 if self.data_collector.scope and not self.data_collector.scope.check(api_or_module_name):
                     return None
@@ -80,18 +116,14 @@ class Service:
             return forward_hook(api_or_module_name, module, args, {}, output)
 
         def backward_hook(api_or_module_name, module, grad_input, grad_output):
+            if not self.should_execute_hook():
+                return
+
             if module_type == BaseScope.Module_Type_Module:
                 api_or_module_name = module.mindstudio_reserved_name
             self.data_collector.update_api_or_module_name(api_or_module_name)
 
-            if not self.switch:
-                return
-
             if self.config.online_run_ut:
-                if self.data_collector.scope and not self.data_collector.scope.check(api_or_module_name):
-                    return
-                api_data = ApiData(name[:-1], grad_input, {}, grad_output, self.current_iter, self.current_rank)
-                self.attl_send(api_data)
                 return
 
             if self.data_collector:
@@ -105,26 +137,15 @@ class Service:
         pre_forward_hook_fn = functools.partial(pre_hook, forward_name_template)
         forward_hook_fn = functools.partial(forward_hook, forward_name_template)
         backward_hook_fn = functools.partial(backward_hook, backward_name_template)
-        forward_hook_torch_version_below_2_fn = functools.partial(forward_hook_torch_version_below_2, forward_name_template)
+        forward_hook_torch_version_below_2_fn = functools.partial(forward_hook_torch_version_below_2,
+                                                                  forward_name_template)
         return HookFn(pre_forward_hook_fn, forward_hook_fn, backward_hook_fn, forward_hook_torch_version_below_2_fn)
 
-    def step(self):
-        self.current_iter += 1
-        self.data_collector.update_iter(self.current_iter)
-
-        ModuleProcesser.reset_module_stats()
-        HOOKModule.reset_module_stats()
-
     def start(self, model, api_origin=False):
-        self.model = model
-        if self.config.step and self.current_iter > max(self.config.step):
-            if self.config.online_run_ut:
-                # send stop signal if online_run_ut
-                self.attl_stop()
-            self.stop()
-            raise Exception("msprobe: exit after iteration {}".format(max(self.config.step)))
-        if self.config.step and self.current_iter not in self.config.step:
+        if self.need_stop_service():
             return
+
+        self.model = model
         if self.first_start:
             try:
                 self.current_rank = get_rank_if_initialized()
@@ -138,13 +159,17 @@ class Service:
             self.first_start = False
         if api_origin:
             api_register.api_modularity()
+        if self.config.online_run_ut and torch_version_above_or_equal_2:
+            run_ut_dispatch(self.attl, True, self.config.online_run_ut_recompute)
         self.switch = True
         logger.info_on_rank_0(f"Dump switch is turned on at step {self.current_iter}. ")
-        if self.config.level != "L2" and not self.config.online_run_ut:
+        if not self.config.online_run_ut:
             self.create_dirs()
             logger.info_on_rank_0(f"Dump data will be saved in {self.dump_iter_dir}.")
 
     def stop(self):
+        if self.should_stop_service:
+            return
         if self.config.level == "L2":
             return
         if self.config.step and self.current_iter not in self.config.step:
@@ -152,14 +177,60 @@ class Service:
         if self.config.rank and self.current_rank not in self.config.rank:
             return
         self.switch = False
-        if self.config.online_run_ut:
+        if self.config.online_run_ut and torch_version_above_or_equal_2:
+            run_ut_dispatch(self.attl, False, self.config.online_run_ut_recompute)
             return
         self.data_collector.write_json()
 
+    def step(self):
+        if self.should_stop_service:
+            return
+        self.current_iter += 1
+        self.data_collector.update_iter(self.current_iter)
+
+        ModuleProcesser.reset_module_stats()
+        HOOKModule.reset_module_stats()
+        self.data_collector.data_writer.reset_cache()
+
+        if self.config.level == Const.LEVEL_L2:
+            self.data_collector.data_processor.reset_status()
+
+    def need_stop_service(self):
+        if self.should_stop_service:
+            return True
+        end_service = self.config.step and self.current_iter > max(self.config.step) or \
+                      self.data_collector and self.data_collector.data_processor.is_terminated
+        if end_service:
+            if self.config.online_run_ut:
+                # send stop signal if online_run_ut
+                self.attl_stop()
+            if self.config.level in [Const.LEVEL_L1, Const.LEVEL_L2, Const.LEVEL_MIX]:
+                api_register.api_originality()
+            self.switch = False
+            self.should_stop_service = True
+            print_tools_ends_info()
+            return True
+        if self.config.step and self.current_iter not in self.config.step:
+            return True
+        return False
+
+    def should_execute_hook(self):
+        if not self.switch:
+            return False
+        if self.data_collector and self.data_collector.data_processor.is_terminated:
+            return False
+        return True
+
     def create_dirs(self):
         create_directory(self.config.dump_path)
         self.dump_iter_dir = os.path.join(self.config.dump_path, f"step{self.current_iter}")
         cur_rank = self.current_rank if self.current_rank is not None else ''
+        if self.config.level == Const.LEVEL_L2:
+            create_directory(self.dump_iter_dir)
+            kernel_config_path = create_kernel_config_json(self.dump_iter_dir, cur_rank)
+            self.config.kernel_config_path = kernel_config_path
+            return
+
         dump_dir = os.path.join(self.dump_iter_dir, f"rank{cur_rank}")
         create_directory(dump_dir)
         if self.config.task in self.data_collector.tasks_need_tensor_data:
@@ -187,14 +258,16 @@ class Service:
                 prefix = BaseScope.Module_Type_Module + Const.SEP + name + Const.SEP + \
                          module.__class__.__name__ + Const.SEP
 
-                pre_forward_hook, forward_hook, backward_hook, forward_hook_torch_version_below_2 \
-                    = self.build_hook(BaseScope.Module_Type_Module, prefix)
+                pre_forward_hook, forward_hook, backward_hook, forward_hook_torch_version_below_2 = self.build_hook(
+                    BaseScope.Module_Type_Module, prefix)
                 if torch_version_above_or_equal_2:
                     module.register_forward_hook(forward_hook, with_kwargs=True)
                 else:
+                    self.check_register_full_backward_hook(module)
                     module.register_full_backward_hook(
                         self.module_processor.node_hook(prefix + Const.BACKWARD, Const.STOP))
                     module.register_forward_hook(forward_hook_torch_version_below_2)
+                self.check_register_full_backward_hook(module)
                 module.register_full_backward_hook(backward_hook)
 
                 module.register_forward_pre_hook(
@@ -204,11 +277,13 @@ class Service:
                 if torch_version_above_or_equal_2:
                     module.register_full_backward_pre_hook(
                         self.module_processor.node_hook(prefix + Const.BACKWARD, Const.START))
+                    self.check_register_full_backward_hook(module)
                     module.register_full_backward_hook(
                         self.module_processor.node_hook(prefix + Const.BACKWARD, Const.STOP))
 
         if self.config.level in ["mix", "L1", "L2"]:
-            api_register.initialize_hook(functools.partial(self.build_hook, BaseScope.Module_Type_API))
+            api_register.initialize_hook(functools.partial(self.build_hook, BaseScope.Module_Type_API),
+                                         self.config.online_run_ut)
             api_register.api_modularity()
 
         if Const.STATISTICS == self.config.task or Const.TENSOR == self.config.task:

msprobe/visualization/__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/builder/__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/builder/graph_builder.py

@@ -0,0 +1,165 @@
+# 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.
+
+import re
+from msprobe.visualization.graph.graph import Graph
+from msprobe.visualization.graph.node_op import NodeOp
+from msprobe.visualization.utils import save_json_file, GraphConst
+from msprobe.visualization.builder.msprobe_adapter import get_input_output
+from msprobe.core.common.file_utils import load_json
+
+
+class GraphBuilder:
+    @staticmethod
+    def build(construct_path, data_path, stack_path, model_name='DefaultModel'):
+        """
+        GraphBuilder的对外提供的构图方法
+        Args:
+            construct_path: construct.json路径
+            data_path: dump.json路径
+            stack_path: stack.json路径
+            model_name: 模型名字，依赖外部输入
+        Returns: Graph，代表图的数据结构
+        """
+        construct_dict = load_json(construct_path)
+        dump_dict = load_json(data_path)
+        stack_dict = load_json(stack_path)
+        data_dict = dump_dict.get(GraphConst.DATA_KEY, {})
+        graph = Graph(model_name, data_path=dump_dict.get('dump_data_dir', ''), dump_data=data_dict)
+        GraphBuilder._init_nodes(graph, construct_dict, data_dict, stack_dict)
+        GraphBuilder._collect_apis_between_modules(graph)
+        return graph
+
+    @staticmethod
+    def to_json(filename, config):
+        """
+        将graph导出成.vis文件的接口
+        """
+        result = {}
+        if config.graph_b:
+            result[GraphConst.JSON_NPU_KEY] = config.graph_n.to_dict()
+            result[GraphConst.JSON_BENCH_KEY] = config.graph_b.to_dict()
+        else:
+            result = config.graph_n.to_dict()
+        if config.tool_tip:
+            result[GraphConst.JSON_TIP_KEY] = config.tool_tip
+        if config.node_colors:
+            result[GraphConst.COLORS] = config.node_colors
+        if config.micro_steps:
+            result[GraphConst.MICRO_STEPS] = config.micro_steps
+        if config.task:
+            result[GraphConst.JSON_TASK_KEY] = config.task
+        save_json_file(filename, result)
+
+    @staticmethod
+    def _handle_backward_upnode_missing(construct_dict, subnode_id, upnode_id):
+        """
+        如果backward节点的父级节点是null，则尝试从同名的forward节点寻找父级节点
+        """
+        # 匹配以.backward.后跟一个或多个数字结尾的模式
+        backward_pattern = r"(\.backward\.)(\d+)$"
+        forward_pattern = r"(\.forward\.)(\d+)$"
+        if re.search(backward_pattern, subnode_id) and not upnode_id:
+            forward_upnode_id = construct_dict.get(re.sub(backward_pattern, r".forward.\2", subnode_id))
+            if forward_upnode_id:
+                new_upnode_id = re.sub(forward_pattern, r".backward.\2", forward_upnode_id)
+                if new_upnode_id in construct_dict:
+                    return new_upnode_id
+        return upnode_id
+
+    @staticmethod
+    def _init_nodes(graph, construct_dict, data_dict, stack_dict):
+        for subnode_id, upnode_id in construct_dict.items():
+            upnode_id = GraphBuilder._handle_backward_upnode_missing(construct_dict, subnode_id, upnode_id)
+            if upnode_id:
+                upnode_op = NodeOp.get_node_op(upnode_id)
+                upnode = GraphBuilder._create_or_get_node(graph, [data_dict, stack_dict], upnode_op, upnode_id)
+            else:
+                upnode = graph.root
+            node_op = NodeOp.get_node_op(subnode_id)
+            GraphBuilder._create_or_get_node(graph, [data_dict, stack_dict], node_op, subnode_id, upnode)
+
+    @staticmethod
+    def _create_or_get_node(graph, data_stack_list, op, name, upnode=None):
+        if name in graph.node_map:
+            node = graph.get_node(name)
+        else:
+            graph.add_node(op, name, upnode)
+            node = graph.get_node(name)
+            node_data = data_stack_list[0].get(name, {})
+            node_stack_info = data_stack_list[1].get(name, [])
+            # 添加输入输出数据
+            input_data, output_data = get_input_output(node_data, node.id)
+            # 更新数据
+            node.set_input_output(input_data, output_data)
+            node.stack_info = node_stack_info
+        # 添加节点
+        node.add_upnode(upnode)
+        return node
+
+    @staticmethod
+    def _collect_apis_between_modules(graph):
+        """
+        图首次展开，这些首层节点包含许多module和api，api数量很多导致图被拉得很长严重影响查阅，因此将module之间的apis收集起来成为节点
+        Args:
+            graph: 模型结构
+
+        Returns: None
+        """
+        i = 0
+        output = []
+        node_list = graph.root.subnodes
+        while i < len(node_list):
+            current_node = node_list[i]
+
+            # 当前节点为api，检查后续是否还有api
+            if current_node.op == NodeOp.function_api:
+                temp_nodes = [current_node]
+                i += 1
+                while i < len(node_list) and node_list[i].op == NodeOp.function_api:
+                    temp_nodes.append(node_list[i])
+                    i += 1
+
+                # 检查api节点是否大于等于2个
+                if len(temp_nodes) >= 2:
+                    # 创建新节点，将这些api节点放入新节点的subnodes属性
+                    node_id = graph.add_node(NodeOp.api_collection, GraphConst.APIS_BETWEEN_MODULES,
+                                             id_accumulation=True)
+                    api_collection_node = graph.get_node(node_id)
+                    api_collection_node.subnodes = temp_nodes
+                    # 重新确立父子关系
+                    for node in temp_nodes:
+                        node.upnode = api_collection_node
+                    api_collection_node.upnode = graph.root
+                    output.append(api_collection_node)
+                else:
+                    # 如果连续的api节点不足2个，将它们原样添加到输出列表
+                    output.extend(temp_nodes)
+            else:
+                # 如果当前节点为module，直接添加到输出列表
+                output.append(current_node)
+                i += 1
+
+        graph.root.subnodes = output
+
+
+class GraphExportConfig:
+    def __init__(self, graph_n, graph_b=None, tool_tip=None, node_colors=None, micro_steps=None, task=''):
+        self.graph_n = graph_n
+        self.graph_b = graph_b
+        self.tool_tip = tool_tip
+        self.node_colors = node_colors
+        self.micro_steps = micro_steps
+        self.task = task

msprobe/visualization/builder/msprobe_adapter.py

@@ -0,0 +1,205 @@
+# 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.
+import re
+import math
+from msprobe.core.compare.acc_compare import read_op, merge_tensor, get_accuracy
+from msprobe.core.common.utils import set_dump_path, get_dump_mode
+from msprobe.visualization.utils import GraphConst
+from msprobe.core.common.const import Const
+
+# 用于将节点名字解析成对应的NodeOp的规则
+op_patterns = [
+    # NodeOp.module
+    r'^(Module.|Cell.)',
+    # NodeOp.function_api
+    r'^(Tensor.|Torch.|Functional.|NPU.|VF.|Distributed.|Aten.|Mint.|Primitive.|Jit.|MintFunctional.)'
+]
+
+
+def get_compare_mode(dump_path_param):
+    """
+    获得比较模式，包括summary、MD5和真实数据三种模式
+    Args:
+        dump_path_param: 调用acc_compare接口所依赖的参数
+    Returns: 0 summary mode, 1 md5 mode, 2 true data mode
+    """
+    set_dump_path(dump_path_param)
+    dump_mode = get_dump_mode(dump_path_param)
+    compare_mode = GraphConst.DUMP_MODE_TO_GRAPHCOMPARE_MODE_MAPPING.get(dump_mode)
+    return compare_mode
+
+
+def run_real_data(dump_path_param, csv_path, framework, is_cross_frame=False):
+    """
+    多进程运行生成真实数据
+    Args:
+        dump_path_param: 调用acc_compare接口所依赖的参数
+        csv_path: 生成文件路径
+        framework: 框架类型, pytorch或mindspore
+        is_cross_frame: 是否进行跨框架比对，仅支持mindspore比pytorch, 其中pytorch为标杆
+    """
+    if framework == Const.PT_FRAMEWORK:
+        from msprobe.pytorch.compare.pt_compare import PTComparator
+        return PTComparator().do_multi_process(dump_path_param, csv_path)
+    else:
+        from msprobe.mindspore.compare.ms_compare import MSComparator
+        ms_comparator = MSComparator()
+        ms_comparator.cross_frame = is_cross_frame
+        return ms_comparator.do_multi_process(dump_path_param, csv_path)
+
+
+def get_input_output(node_data, node_id):
+    """
+    将dump的原始数据进行拆解，分解为output和input两个数据
+    Args:
+        node_data: 属于单个节点的dump数据
+        node_id: 节点名字
+    """
+    input_data = {}
+    output_data = {}
+    op_parsed_list = read_op(node_data, node_id)
+    for item in op_parsed_list:
+        full_op_name = item.get('full_op_name', '')
+        if not full_op_name:
+            continue
+        if GraphConst.OUTPUT in full_op_name and GraphConst.INPUT not in full_op_name:
+            output_data[full_op_name] = item
+        else:
+            name = item.get('data_name')
+            # 节点参数名称尽量使用落盘数据的名称
+            if isinstance(name, str) and name != '-1':
+                input_data[name.rsplit(Const.SEP, 1)[0]] = item
+            else:
+                input_data[full_op_name] = item
+    return input_data, output_data
+
+
+def compare_data(data_dict_list1, data_dict_list2):
+    """
+    比较get_input_output中输出的结果是否结构一致，比较一致返回True
+    """
+    if len(data_dict_list1) != len(data_dict_list2):
+        return False
+    # 用于比较两个节点是否相等的关键字段
+    tag_keys = ['type', 'shape']
+    for key1, key2 in zip(data_dict_list1, data_dict_list2):
+        dict1 = data_dict_list1[key1]
+        dict2 = data_dict_list2[key2]
+        for tag_key in tag_keys:
+            tag_value1 = dict1.get(tag_key, None)
+            tag_value2 = dict2.get(tag_key, None)
+            if tag_value1 != tag_value2:
+                return False
+    return True
+
+
+def format_node_data(data_dict):
+    """
+    批量进行节点数据的输出
+    """
+    del_list = ['requires_grad', 'full_op_name']
+    for _, value in data_dict.items():
+        if not isinstance(value, dict):
+            continue
+        for item in del_list:
+            if item in value:
+                del value[item]
+        _format_data(value)
+    return data_dict
+
+
+def compare_node(node_ids, data_dicts, stack_json_data, compare_mode):
+    """
+    调用acc_compare.py中的get_accuracy获得精度对比指标
+    真实数据对比模式无法获得精度对比指标，需要调用多进程比对接口
+    Returns: 包含参数信息和对比指标（真实数据对比模式除外）的list
+    """
+    merge_n = _parse_node(node_ids[0], data_dicts[0], stack_json_data, compare_mode)
+    merge_b = _parse_node(node_ids[1], data_dicts[1], stack_json_data, compare_mode)
+    result = []
+    dump_mode = GraphConst.GRAPHCOMPARE_MODE_TO_DUMP_MODE_TO_MAPPING.get(compare_mode)
+    get_accuracy(result, merge_n, merge_b, dump_mode)
+    return result
+
+
+def _parse_node(node_id, data_dict, stack_json_data, compare_mode):
+    """
+    转换节点，使其能够作为acc_compare.py中的get_accuracy的入参
+    """
+    dump_mode = GraphConst.GRAPHCOMPARE_MODE_TO_DUMP_MODE_TO_MAPPING.get(compare_mode)
+    op_parsed_list = read_op(data_dict.get(node_id, {}), node_id)
+    if node_id in stack_json_data:
+        op_parsed_list.append(
+            {'full_op_name': node_id, 'full_info': stack_json_data[node_id]})
+    else:
+        op_parsed_list.append({'full_op_name': node_id, 'full_info': None})
+    result = merge_tensor(op_parsed_list, dump_mode)
+    if not result:
+        result['op_name'] = []
+    return result
+
+
+def _format_decimal_string(s):
+    """
+    使用正则表达式匹配包含数字、小数点和可选的百分号的字符串
+    """
+    pattern = re.compile(r'\d{1,20}\.\d{1,20}%?')
+    matches = pattern.findall(s)
+    for match in matches:
+        is_percent = match.endswith('%')
+        number_str = match.rstrip('%')
+        decimal_part = number_str.split('.')[1]
+        # 如果小数位数大于6，进行处理
+        if len(decimal_part) > GraphConst.ROUND_TH:
+            number_float = float(number_str)
+            formatted_number = f"{number_float:.{GraphConst.ROUND_TH}f}"
+            # 如果原来是百分数，加回百分号
+            if is_percent:
+                formatted_number += '%'
+            # 替换原字符串中的数值部分
+            s = s.replace(match, formatted_number)
+    return s
+
+
+def _format_data(data_dict):
+    """
+    格式化数据，小数保留6位，处理一些异常值
+    """
+    pattern = r'^[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)$'
+    all_null = False
+    for key, value in data_dict.items():
+        if isinstance(value, str):
+            # 将单引号删掉，None换成null避免前端解析错误
+            value = value.replace("'", "").replace(GraphConst.NONE, GraphConst.NULL)
+            value = _format_decimal_string(value)
+        elif value is None or value == ' ':
+            value = GraphConst.NULL
+        # 科学计数法1.123123123123e-11，格式化为1.123123e-11
+        elif isinstance(value, float) and len(str(value)) < GraphConst.STR_MAX_LEN and re.match(pattern, str(value)):
+            value = "{:.6e}".format(value)
+        elif isinstance(value, float):
+            value = round(value, GraphConst.ROUND_TH)
+        # Inf会走入这里，确保转成Inf。另外给其他不符合预期的类型做兜底方案
+        if key != GraphConst.ERROR_KEY:
+            # 除了error_key不转str，其他都转str, 避免前端解析错误
+            value = str(value)
+        # max为null, 意味着这个参数值为null
+        if key == Const.MAX and value == GraphConst.NULL:
+            all_null = True
+        data_dict[key] = value
+    # 字典里的value全null，只保留一个null
+    if all_null:
+        data_dict.clear()
+        data_dict[GraphConst.VALUE] = GraphConst.NULL

msprobe/visualization/compare/__init__.py

@@ -0,0 +1,14 @@
+# 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.