mindstudio-probe 8.3.2__py3-none-any.whl → 26.0.0a1__py3-none-any.whl

msprobe/visualization/builder/msprobe_adapter.py

@@ -1,17 +1,18 @@
-# Copyright (c) 2024-2025, Huawei Technologies Co., Ltd.
-# All rights reserved.
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 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
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
 #
-# http://www.apache.org/licenses/LICENSE-2.0
+#          http://license.coscl.org.cn/MulanPSL2
 #
-# 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.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
 
 import re
 
@@ -21,12 +22,12 @@ from msprobe.core.compare.utils import read_op, merge_tensor, get_accuracy, make
 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
-
+from msprobe.core.compare.indicator_analysis.calculator import calculate_result
 
 # 用于将节点名字解析成对应的NodeOp的规则
 op_patterns = [
     # NodeOp.module
-    r'^(Module.|Cell.|optimizer|clip_grad)',
+    r'^(Module.|Cell.|optimizer|clip_grad|DefaultModel)',
     # NodeOp.function_api
     r'^(Tensor.|Torch.|Functional.|NPU.|VF.|Distributed.|Aten.|Mint.|Primitive.|Jit.|MintFunctional.|MindSpeed.)'
 ]
@@ -96,37 +97,6 @@ def get_input_output(node_data, node_id):
     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 compare_data_fuzzy(data_dict_list1, data_dict_list2):
-    """
-    模糊匹配，仅校验参数shape是否一致
-    """
-    for x, y in zip(data_dict_list1.values(), data_dict_list2.values()):
-        x_shape = x.get(Const.SHAPE)
-        y_shape = y.get(Const.SHAPE)
-        if x_shape != y_shape:
-            return False
-    return True
-
-
 def format_node_data(data_dict, node_id=None, compare_mode=None):
     """
     删除节点数据中不需要展示的字段
@@ -160,6 +130,26 @@ def compare_node(node_n, node_b, compare_mode):
     return result
 
 
+def get_api_indicator_info(compare_mode, result, parallel_merge=False):
+    """
+    得到一个api或模块的指标和异常信息
+    """
+    dump_mode = GraphConst.GRAPHCOMPARE_MODE_TO_DUMP_MODE_TO_MAPPING.get(compare_mode)
+    return calculate_result(result, dump_mode, parallel_merge)
+
+
+def get_real_api_data_list(node, compare_data_dict: dict):
+    """
+    真实数据模式下，得到的比对结果包含了所有api参数，需要转换为其中某一个api参数列表
+    """
+    api_data_list = []
+    keys = list(node.input_data.keys()) + list(node.output_data.keys())
+    for key in keys:
+        if key in compare_data_dict:
+            api_data_list.append(compare_data_dict.get(key))
+    return api_data_list
+
+
 def _parse_node(node, dump_mode):
     """
     转换节点，使其能够作为acc_compare.py中的get_accuracy的入参

msprobe/visualization/compare/__init__.py

@@ -1,14 +1,15 @@
-# Copyright (c) 2024, Huawei Technologies Co., Ltd.
-# All rights reserved.
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 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
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
 #
-# http://www.apache.org/licenses/LICENSE-2.0
+#          http://license.coscl.org.cn/MulanPSL2
 #
-# 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.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------

msprobe/visualization/compare/graph_comparator.py

@@ -1,49 +1,55 @@
-# Copyright (c) 2024-2025, Huawei Technologies Co., Ltd.
-# All rights reserved.
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 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
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
 #
-# http://www.apache.org/licenses/LICENSE-2.0
+#          http://license.coscl.org.cn/MulanPSL2
 #
-# 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.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
+
 
 import re
-from msprobe.visualization.builder.msprobe_adapter import compare_node, get_compare_mode, run_real_data, get_csv_df
-from msprobe.visualization.utils import GraphConst, load_json_file, load_data_json_file
+from msprobe.visualization.builder.msprobe_adapter import compare_node, get_compare_mode, run_real_data, get_csv_df, \
+    get_api_indicator_info, get_real_api_data_list
+from msprobe.visualization.utils import GraphConst, update_shared_dict, update_pbar_info
 from msprobe.visualization.graph.graph import Graph, NodeOp
 from msprobe.visualization.compare.mode_adapter import ModeAdapter
 from msprobe.core.common.const import Const
-from msprobe.core.common.decorator import recursion_depth_decorator
+from msprobe.core.compare.utils import get_compare_framework
 
 
 class GraphComparator:
     MAX_DEPTH = 1000
 
-    def __init__(self, graphs, dump_path_param, args, is_cross_framework, mapping_dict=None):
+    def __init__(self, graphs, dump_path_param, args, is_cross_framework, mapping_dict=None, pbar_info=None):
         self.graph_n = graphs[0]
         self.graph_b = graphs[1]
-        self._parse_param(dump_path_param, args.output_path)
-        self.framework = args.framework
+        self.dump_path_param = dump_path_param
+        self.output_path = args.output_path
+        self.parallel_merge = args.parallel_merge if hasattr(args, 'parallel_merge') else False
+        self.ma = ModeAdapter(get_compare_mode(self.dump_path_param), self.parallel_merge)
+        self.framework = get_compare_framework(dump_path_param.get("npu_path"), dump_path_param.get("bench_path"))
         self.layer_mapping = args.layer_mapping
         self.mapping_dict = mapping_dict
         self.fuzzy_match = args.fuzzy_match
         self.pattern = re.compile(r'\.\d+\.')
         self.is_cross_framework = is_cross_framework
-        self.parallel_merge = args.parallel_merge if hasattr(args, 'parallel_merge') else False
         self.rank_pattern = re.compile(r"_rank\d+")
+        self.pbar_info = pbar_info
 
     def compare(self):
         """
         比较函数，初始化结束后单独调用。比较结果写入graph_n
         """
         if self.fuzzy_match:
-            self._compare_nodes_fuzzy(self.graph_n.root, False if self.parallel_merge else True)
+            self._compare_nodes_fuzzy(self.graph_n.root)
         else:
             self._compare_nodes(self.graph_n.root)
         self._postcompare()
@@ -58,26 +64,22 @@ class GraphComparator:
         # 真实数据比对，先暂存节点，在多进程对比得到精度指标后，再将指标添加到节点中
         if self.ma.prepare_real_data(node):
             return
-        compare_in_dict = {}
-        compare_out_dict = {}
+        api_indicator = get_api_indicator_info(self.ma.compare_mode, compare_result_list, self.ma.parallel_merge)
+        compare_result_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]))
+            compare_result_dict[item[0]] = item
+        precision_index = self.ma.parse_result(node, compare_result_dict, api_indicator)
         node.data[GraphConst.JSON_INDEX_KEY] = precision_index
-        node.data.update(other_dict)
 
     def _compare_nodes(self, node_root):
         """
         遍历NPU树中的节点，如果在Bench中找到具有相同名称的节点，检查他们的祖先和参数信息，检查一致则及逆行精度数据对比
         这里采用先序遍历，好处在于当这个节点被比较时，他的先序已经被匹配，这可以为后续的模糊匹配提供重要信息
         """
+
         def compare_single_node(node_n):
             if self.layer_mapping:
                 node_b, ancestors_n, ancestors_b = Graph.mapping_match(node_n, self.graph_b, self.mapping_dict)
@@ -96,16 +98,21 @@ class GraphComparator:
                 self._get_and_add_result(node_n, node_b)
             node_list.extend(node_n.subnodes)
 
+        if self.pbar_info:
+            update_shared_dict(self.pbar_info.current_stage_dict, self.pbar_info.task_id, 1)
+        total = 0
         node_list = [node_root]
         while node_list:
             compare_single_node(node_list.pop(0))
+            total += 1
+            if self.pbar_info:
+                update_pbar_info(self.pbar_info, total, len(self.graph_n.node_map))
 
-    def _compare_nodes_fuzzy(self, node_root, check_shape=True):
+    def _compare_nodes_fuzzy(self, node_root):
         def compare_single_nodes_fuzzy(node_n):
             if node_n.op != NodeOp.function_api:
                 # 模块经过模糊匹配
-                node_b, ancestors_n, ancestors_b = Graph.fuzzy_match(node_n, self.graph_b.node_map.get(node_n.id),
-                                                                     check_shape)
+                node_b, ancestors_n, ancestors_b = Graph.fuzzy_match(node_n, self.graph_b.node_map.get(node_n.id))
                 if node_b:
                     self._process_matched_nodes(node_n, node_b, ancestors_n, ancestors_b)
                     # 匹配上的两个模块中的所有api, 忽略dump调用次数，按照名称一致+模块中的调用顺序进行匹配
@@ -116,48 +123,53 @@ class GraphComparator:
                         if not api_node_n:
                             continue
                         api_node_b, ancestors_n, ancestors_b = Graph.fuzzy_match(
-                            api_node_n, self.graph_b.node_map.get(recount_result_b.get(recount_node_id)), check_shape)
+                            api_node_n, self.graph_b.node_map.get(recount_result_b.get(recount_node_id)))
                         if api_node_b:
                             self._process_matched_nodes(api_node_n, api_node_b, ancestors_n, ancestors_b)
             node_list.extend(node_n.subnodes)
 
+        if self.pbar_info:
+            update_shared_dict(self.pbar_info.current_stage_dict, self.pbar_info.task_id, 1)
+        total = 0
         node_list = [node_root]
         while node_list:
             compare_single_nodes_fuzzy(node_list.pop(0))
-
-    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'))
+            total += 1
+            if self.pbar_info:
+                update_pbar_info(self.pbar_info, total, len(self.graph_n.node_map))
 
     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, self.is_cross_framework)
+        # 真实数据比对时，避免高频率进度监控线程与多进程池之间的GIL 抢占 + CPU 资源竞争，暂停进度监控线程，防止卡死
+        if self.pbar_info and self.pbar_info.progress_dict is not None:
+            self.pbar_info.set_wait_monitor(True)
+        try:
+            df = run_real_data(self.dump_path_param, df, self.framework, self.is_cross_framework)
+        finally:
+            if self.pbar_info and self.pbar_info.progress_dict is not None:
+                self.pbar_info.set_continue_monitor(True)
+
         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])
+            compare_result_list = get_real_api_data_list(node, compare_data_dict)
+            api_indicator = get_api_indicator_info(self.ma.compare_mode, compare_result_list)
+            precision_index = self.ma.parse_result(node, compare_data_dict, api_indicator)
             node.data[GraphConst.JSON_INDEX_KEY] = precision_index
 
     def _handle_api_collection_index(self):
         """
-        api集合的指标, md5模式使用集合中所有api最小的指标，statistics和tensor模式使用集合中所有api最大的指标
-        md5模式下指标为0代表最差，statistics和tensor模式下指标为1代表最差
+        api集合的指标, 使用集合中所有api最差的指标
+        指标为1代表最差
         """
+
         def handle_api_collection_index(api_collection_node):
-            precision_index = GraphConst.MAX_INDEX_KEY if self.ma.compare_mode == GraphConst.MD5_COMPARE \
-                else GraphConst.MIN_INDEX_KEY
+            precision_index = GraphConst.MIN_INDEX_KEY
             for api in api_collection_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))
+                precision_index = max(precision_index,
+                                      api.data.get(GraphConst.JSON_INDEX_KEY, GraphConst.MIN_INDEX_KEY))
             api_collection_node.data[GraphConst.JSON_INDEX_KEY] = precision_index
 
         for node in self.graph_n.root.subnodes:

msprobe/visualization/compare/mode_adapter.py

@@ -1,17 +1,18 @@
-# Copyright (c) 2024, Huawei Technologies Co., Ltd.
-# All rights reserved.
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 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
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
 #
-# http://www.apache.org/licenses/LICENSE-2.0
+#          http://license.coscl.org.cn/MulanPSL2
 #
-# 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.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
 
 import math
 import json
@@ -20,10 +21,11 @@ from msprobe.visualization.utils import ToolTip, GraphConst, str2float
 
 
 class ModeAdapter:
-    def __init__(self, compare_mode):
+    def __init__(self, compare_mode, parallel_merge=False):
         self.compare_mode = compare_mode
         self.csv_data = []
         self.compare_nodes = []
+        self.parallel_merge = parallel_merge
 
     @staticmethod
     def _is_invalid(value):
@@ -32,84 +34,15 @@ class ModeAdapter:
         return math.isnan(value) or math.isinf(value)
 
     @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
-            if value.get(Const.MAX) is None:
-                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
-            if ModeAdapter._is_invalid(value.get(Const.MAX)) or ModeAdapter._is_invalid(value.get(Const.MIN)):
-                numbers.append(CompareConst.N_A)
-        # 双千指标都是None的异常情况
-        if not numbers:
-            min_thousandth = None
-        elif CompareConst.N_A in numbers:
-            min_thousandth = CompareConst.N_A
-        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, ...}
+    def _add_compare_data(node_data, compare_data_dict, key_list, headers):
         for key, data_info in node_data.items():
             if not isinstance(data_info, dict):
                 continue
-            if data_info.get(Const.MAX) is None:
-                continue
             compare_data = compare_data_dict.get(key)
             if compare_data:
                 # 对应比对结果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 item in key_list[4:]:
-                    relative_err = str2float(data_info.get(item))
-                    max_relative_err = max(max_relative_err, relative_err)
-                node_data[key] = data_info
-            if ModeAdapter._is_invalid(data_info.get(Const.MAX)) or ModeAdapter._is_invalid(data_info.get(Const.MIN)):
-                max_relative_err = GraphConst.MAX_INDEX_KEY
-        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):
@@ -126,43 +59,25 @@ class ModeAdapter:
         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):
+    def parse_result(self, node, compare_data_dict, api_indicator):
         """
-        根据结果返回数据，分别是precision_index，和附加数据
+        根据结果返回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
+            key_list = GraphConst.MD5_INDEX_LIST
+            headers = CompareConst.MD5_COMPARE_RESULT_HEADER
         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
+            key_list = GraphConst.SUMMARY_INDEX_LIST
+            headers = CompareConst.SUMMARY_COMPARE_RESULT_HEADER
         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 CompareConst.N_A == min_thousandth_out:
-                change_percentage = GraphConst.MAX_INDEX_KEY
-            elif CompareConst.N_A == min_thousandth_in:
-                change_percentage = GraphConst.MIN_INDEX_KEY
-            elif 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
+            key_list = GraphConst.REAL_DATA_INDEX_LIST
+            headers = CompareConst.COMPARE_RESULT_HEADER
+        ModeAdapter._add_compare_data(node.input_data, compare_data_dict, key_list, headers)
+        ModeAdapter._add_compare_data(node.output_data, compare_data_dict, key_list, headers)
+        precision_index = GraphConst.COMPARE_INDICATOR_TO_PRECISION_INDEX_MAPPING.get(api_indicator,
+                                                                                      CompareConst.PASS)
         precision_index = self._ignore_precision_index(node.id, precision_index)
-        return precision_index, other_dict
+        return precision_index
 
     def prepare_real_data(self, node):
         """