mindstudio-probe 1.2.2__py3-none-any.whl → 8.1.0__py3-none-any.whl

msprobe/visualization/builder/msprobe_adapter.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# Copyright (c) 2024-2025, Huawei Technologies Co., Ltd.
 # All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0  (the "License");
@@ -12,13 +12,16 @@
 # 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.compare.acc_compare import ModeConfig
+from msprobe.core.compare.multiprocessing_compute import CompareRealData
+from msprobe.core.compare.utils import read_op, merge_tensor, get_accuracy, make_result_table
 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.acc_compare import ModeConfig
+
 
 # 用于将节点名字解析成对应的NodeOp的规则
 op_patterns = [
@@ -54,13 +57,11 @@ def run_real_data(dump_path_param, csv_path, framework, is_cross_frame=False):
     mode_config = ModeConfig(stack_mode=False, auto_analyze=True, fuzzy_match=False, dump_mode=Const.ALL)
 
     if framework == Const.PT_FRAMEWORK:
-        from msprobe.pytorch.compare.pt_compare import PTComparator
-        return PTComparator(mode_config).do_multi_process(dump_path_param, csv_path)
+        from msprobe.pytorch.compare.pt_compare import read_real_data
+        return CompareRealData(read_real_data, mode_config, is_cross_frame).do_multi_process(dump_path_param, csv_path)
     else:
-        from msprobe.mindspore.compare.ms_compare import MSComparator, MappingConfig
-        ms_comparator = MSComparator(mode_config, MappingConfig())
-        ms_comparator.cross_frame = is_cross_frame
-        return ms_comparator.do_multi_process(dump_path_param, csv_path)
+        from msprobe.mindspore.compare.ms_compare import read_real_data
+        return CompareRealData(read_real_data, mode_config, is_cross_frame).do_multi_process(dump_path_param, csv_path)
 
 
 def get_input_output(node_data, node_id):
@@ -120,11 +121,13 @@ def compare_data_fuzzy(data_dict_list1, data_dict_list2):
     return True
 
 
-def format_node_data(data_dict, node_id=None):
+def format_node_data(data_dict, node_id=None, compare_mode=None):
     """
     删除节点数据中不需要展示的字段
     """
     del_list = ['requires_grad', 'full_op_name']
+    if GraphConst.MD5_COMPARE != compare_mode:
+        del_list.append(Const.MD5)
     if node_id and GraphConst.BATCH_P2P in node_id:
         del_list.extend(['op', 'peer', 'tag', 'group_id'])
     for _, value in data_dict.items():
@@ -172,7 +175,7 @@ def _format_decimal_string(s):
     """
     使用正则表达式匹配包含数字、小数点和可选的百分号的字符串
     """
-    pattern = re.compile(r'\d{1,20}\.\d{1,20}%?')
+    pattern = re.compile(r'^\d{1,20}\.\d{1,20}%?$')
     matches = pattern.findall(s)
     for match in matches:
         is_percent = match.endswith('%')
@@ -227,3 +230,12 @@ def _format_data(data_dict):
     if all_null:
         data_dict.clear()
         data_dict[GraphConst.VALUE] = GraphConst.NULL
+
+
+def get_csv_df(stack_mode, csv_data, compare_mode):
+    """
+    调用acc接口写入csv
+    """
+
+    dump_mode = GraphConst.GRAPHCOMPARE_MODE_TO_DUMP_MODE_TO_MAPPING.get(compare_mode)
+    return make_result_table(csv_data, dump_mode, stack_mode)

msprobe/visualization/compare/graph_comparator.py

@@ -1,4 +1,4 @@
-# Copyright (c) 2024, Huawei Technologies Co., Ltd.
+# Copyright (c) 2024-2025, Huawei Technologies Co., Ltd.
 # All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0  (the "License");
@@ -14,23 +14,27 @@
 # limitations under the License.
 
 import re
-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.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.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
+from msprobe.core.common.decorator import recursion_depth_decorator
 
 
 class GraphComparator:
-    def __init__(self, graphs, dump_path_param, args, mapping_dict=None):
+    MAX_DEPTH = 1000
+
+    def __init__(self, graphs, dump_path_param, args, is_cross_framework, mapping_dict=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.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
 
     def compare(self):
         """
@@ -41,7 +45,7 @@ class GraphComparator:
         else:
             self._compare_nodes(self.graph_n.root)
         self._postcompare()
-    
+
     def add_compare_result_to_node(self, node, compare_result_list):
         """
         将比对结果添加到节点的输入输出数据中
@@ -66,7 +70,58 @@ class GraphComparator:
             self.ma.parse_result(node, [compare_in_dict, compare_out_dict]))
         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)
+                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:
+                # 真实数据比对只会得到基本信息，并没有精度指标，需要调用多进程对比接口
+                self._get_and_add_result(node_n, node_b)
+            node_list.extend(node_n.subnodes)
+
+        node_list = [node_root]
+        while node_list:
+            compare_single_node(node_list.pop(0))
+
+    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))
+                if node_b:
+                    self._process_matched_nodes(node_n, node_b, ancestors_n, ancestors_b)
+                    # 匹配上的两个模块中的所有api, 忽略dump调用次数，按照名称一致+模块中的调用顺序进行匹配
+                    recount_result_n = self._recount_api_node(node_n)
+                    recount_result_b = self._recount_api_node(node_b)
+                    for recount_node_id, node_id_n in recount_result_n.items():
+                        api_node_n = self.graph_n.node_map.get(node_id_n)
+                        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)))
+                        if api_node_b:
+                            self._process_matched_nodes(api_node_n, api_node_b, ancestors_n, ancestors_b)
+            node_list.extend(node_n.subnodes)
+
+        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
@@ -81,7 +136,7 @@ class GraphComparator:
         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)
+        df = run_real_data(self.dump_path_param, df, self.framework, self.is_cross_framework)
         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])
@@ -103,49 +158,6 @@ class GraphComparator:
                         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:
-            # 真实数据比对只会得到基本信息，并没有精度指标，需要调用多进程对比接口
-            self._get_and_add_result(node_n, node_b)
-        for subnode in node_n.subnodes:
-            self._compare_nodes(subnode)
-
-    def _compare_nodes_fuzzy(self, 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))
-            if node_b:
-                self._process_matched_nodes(node_n, node_b, ancestors_n, ancestors_b)
-                # 匹配上的两个模块中的所有api, 忽略dump调用次数，按照名称一致+模块中的调用顺序进行匹配
-                recount_result_n = self._recount_api_node(node_n)
-                recount_result_b = self._recount_api_node(node_b)
-                for recount_node_id, node_id_n in recount_result_n.items():
-                    api_node_n = self.graph_n.node_map.get(node_id_n)
-                    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)))
-                    if api_node_b:
-                        self._process_matched_nodes(api_node_n, api_node_b, ancestors_n, ancestors_b)
-        for sub_node in node_n.subnodes:
-            self._compare_nodes_fuzzy(sub_node)
-
     def _get_and_add_result(self, node_n, node_b):
         compare_result_list = compare_node([node_n.id, node_b.id],
                                            [self.data_n_dict, self.data_b_dict],

msprobe/visualization/compare/mode_adapter.py

@@ -13,8 +13,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import json
 import math
+import json
 from msprobe.core.common.const import CompareConst, Const
 from msprobe.visualization.utils import ToolTip, GraphConst, str2float
 
@@ -25,6 +25,12 @@ class ModeAdapter:
         self.csv_data = []
         self.compare_nodes = []
 
+    @staticmethod
+    def _is_invalid(value):
+        if not isinstance(value, float):
+            return False
+        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
@@ -49,6 +55,8 @@ class ModeAdapter:
         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
@@ -67,9 +75,13 @@ class ModeAdapter:
                 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
@@ -81,6 +93,8 @@ class ModeAdapter:
         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的列
@@ -92,6 +106,8 @@ class ModeAdapter:
                     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
 
@@ -133,7 +149,11 @@ class ModeAdapter:
             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:
+            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
@@ -157,24 +177,6 @@ class ModeAdapter:
             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):
         """
         用于前端展示字段的具体含义

msprobe/visualization/graph/base_node.py

@@ -12,10 +12,11 @@
 # 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 GraphConst
 from msprobe.visualization.builder.msprobe_adapter import format_node_data, compare_data, compare_data_fuzzy
+from msprobe.core.common.log import logger
 
 
 class BaseNode:
@@ -86,15 +87,15 @@ class BaseNode:
         self.matched_node_link = ancestors
         node.matched_node_link = ancestors
 
-    def to_dict(self):
+    def to_dict(self, compare_mode=None):
         """
         输出数据
         """
         result = {
             'id': self.id,
             'node_type': self.op.value,
-            'output_data': format_node_data(self.output_data, self.id),
-            'input_data': format_node_data(self.input_data, self.id),
+            'output_data': format_node_data(self.output_data, self.id, compare_mode),
+            'input_data': format_node_data(self.input_data, self.id, compare_mode),
             'upnode': self.upnode.id if self.upnode else 'None',
             'subnodes': [node.id for node in self.subnodes],
             'matched_node_link': self.matched_node_link,
@@ -114,7 +115,13 @@ class BaseNode:
         """
         ancestors = []
         current_node = self.upnode
+        seen_nodes = set()
         while current_node:
+            if current_node.id in seen_nodes:
+                logger.warning(f'Detected a cycle in the node structure and cannot get node ancestors, '
+                               f'current node is {current_node.id}.')
+                return []
+            seen_nodes.add(current_node.id)
             ancestors.append(current_node.id)
             current_node = current_node.upnode
         return list(reversed(ancestors))

msprobe/visualization/graph/distributed_analyzer.py

@@ -107,15 +107,6 @@ class DistributedAnalyzer:
             return None, None
         return group_ranks, group_id
 
-    @staticmethod
-    def _get_batch_group_info(node, rank):
-        for data in node.input_data.values():
-            group_id = data.get('group_id')
-            if group_id is not None:
-                return group_id
-        logger.warning(f'The group_id of node {node.id} does not exist, {CANNOT_MATCH}{rank}')
-        return None
-
     def distributed_match(self):
         for rank, graph in self.graphs.items():
             nodes = graph.node_map
@@ -377,7 +368,7 @@ class DistributedAnalyzer:
                 target_api_name = self.config.get(api_name)[0]
                 target_rank = int(id_info[1].replace(Const.RANK, ''))
             except Exception as e:
-                logger.warning(f'Failed to parsing batch p2p parameter with error info: {e}.')
+                logger.warning(f'Failed to parse batch p2p parameter with error info: {e}.')
                 continue
             target_node = self._get_target_node(rank, unique_group_id, api_name, target_rank, target_api_name)
             if not target_node:

msprobe/visualization/graph/graph.py

@@ -20,9 +20,6 @@ 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 = {}
@@ -67,7 +64,6 @@ class Graph:
         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):
@@ -76,13 +72,6 @@ class Graph:
         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):
         """
@@ -157,7 +146,7 @@ class Graph:
         """
         return self.node_map.get(node_id, None)
 
-    def to_dict(self):
+    def to_dict(self, compare_mode=None):
         """
         用于数据输出
         """
@@ -166,7 +155,7 @@ class Graph:
         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()
+            info = self.node_map.get(node_id).to_dict(compare_mode)
             result[GraphConst.JSON_NODE_KEY][node_id] = info
         return result
 

msprobe/visualization/graph/node_op.py

@@ -24,7 +24,6 @@ class NodeOp(Enum):
     function_api = 1
     api_collection = 9
 
-
     @staticmethod
     def get_node_op(node_name: str):
         """
@@ -37,5 +36,5 @@ class NodeOp(Enum):
             pattern = op_patterns[index]
             if re.match(pattern, node_name):
                 return op
-        logger.warning(f"Cannot parsing node_name {node_name} into NodeOp, default parsing as module.")
+        logger.warning(f"Cannot parse node_name {node_name} into NodeOp, default parsing as module.")
         return NodeOp.module