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

msprobe/core/compare/acc_compare.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");
@@ -19,28 +19,37 @@ import re
 from copy import deepcopy
 
 import pandas as pd
+from tqdm import tqdm
+
 from msprobe.core.advisor.advisor import Advisor
 from msprobe.core.common.const import CompareConst, Const
 from msprobe.core.common.exceptions import FileCheckException
-from msprobe.core.common.file_utils import load_json
-from msprobe.core.common.file_utils import remove_path
+from msprobe.core.common.file_utils import load_json, remove_path
 from msprobe.core.common.log import logger
-from msprobe.core.common.utils import add_time_with_xlsx, CompareException, check_op_str_pattern_valid, safe_get_value
-from msprobe.core.compare.check import check_graph_mode, check_struct_match, fuzzy_check_op, check_dump_json_str, \
-    check_stack_json_str
+from msprobe.core.common.utils import CompareException, add_time_with_xlsx, check_op_str_pattern_valid, safe_get_value
+from msprobe.core.compare.check import check_dump_json_str, check_graph_mode, check_stack_json_str, \
+    check_struct_match, fuzzy_check_op
 from msprobe.core.compare.highlight import find_compare_result_error_rows, highlight_rows_xlsx
-from msprobe.core.compare.multiprocessing_compute import _handle_multi_process, ComparisonResult, _save_cmp_result
-from msprobe.core.compare.npy_compare import compare_ops_apply, get_error_type, reshape_value, get_relative_err, \
-    get_error_message
-from msprobe.core.compare.utils import read_op, merge_tensor, get_un_match_accuracy, get_accuracy, \
-    get_rela_diff_summary_mode, print_compare_ends_info
-from tqdm import tqdm
+from msprobe.core.compare.multiprocessing_compute import ComparisonResult, _handle_multi_process, _save_cmp_result
+from msprobe.core.compare.npy_compare import compare_ops_apply, get_error_flag_and_msg
+from msprobe.core.compare.utils import get_accuracy, get_rela_diff_summary_mode, get_un_match_accuracy, merge_tensor, \
+    print_compare_ends_info, read_op, get_name_and_state, reorder_op_x_list
 
 
-class Comparator:
+class ModeConfig:
+    def __init__(self, stack_mode=False, auto_analyze=True, fuzzy_match=False, dump_mode=None):
+        self.stack_mode = stack_mode
+        self.auto_analyze = auto_analyze
+        self.fuzzy_match = fuzzy_match
+        self.dump_mode = dump_mode
 
-    def __init__(self):
-        pass
+
+class Comparator:
+    def __init__(self, mode_config: ModeConfig):
+        self.stack_mode = mode_config.stack_mode
+        self.auto_analyze = mode_config.auto_analyze
+        self.fuzzy_match = mode_config.fuzzy_match
+        self.dump_mode = mode_config.dump_mode
 
     @staticmethod
     def get_result_md5_compare(ms_op_name, bench_op_name, npu_ops_all, bench_ops_all, *args):
@@ -85,16 +94,15 @@ class Comparator:
                 value[k] = CompareConst.N_A
         return value
 
-    @classmethod
-    def make_result_table(cls, result, stack_mode, dump_mode):
-        header = CompareConst.HEAD_OF_COMPARE_MODE[dump_mode][:]
+    def make_result_table(self, result):
+        header = CompareConst.HEAD_OF_COMPARE_MODE[self.dump_mode][:]
 
-        if stack_mode:
+        if self.stack_mode:
             header.append(CompareConst.STACK)
-            if dump_mode == Const.ALL:
+            if self.dump_mode == Const.ALL:
                 header.append(CompareConst.DATA_NAME)
         else:
-            if dump_mode == Const.ALL:
+            if self.dump_mode == Const.ALL:
                 for row in result:
                     del row[-2]  # 输出结果不要堆栈信息时，删除中间结果result中的stack info，真实数据时为倒数第2列
                 header.append(CompareConst.DATA_NAME)
@@ -104,24 +112,25 @@ class Comparator:
         result_df = pd.DataFrame(result, columns=header, dtype='object')
         return result_df
 
-    @classmethod
-    def gen_merge_list(cls, json_data, op_name, stack_json_data, dump_mode):
+    def gen_merge_list(self, json_data, op_name, stack_json_data):
         op_data = json_data['data'][op_name]
         check_dump_json_str(op_data, op_name)
         op_parsed_list = read_op(op_data, op_name)
 
-        stack_info = stack_json_data.get(op_name)
-        if stack_info is not None:
-            check_stack_json_str(stack_info, op_name)
-        op_parsed_list.append({
-            'full_op_name': op_name,
-            'full_info': stack_info
-        })
-
-        merge_list = merge_tensor(op_parsed_list, dump_mode)
+        if self.stack_mode:
+            stack_info = stack_json_data.get(op_name)
+            if stack_info is not None:
+                check_stack_json_str(stack_info, op_name)
+            # append only when stack_mode is True,
+            op_parsed_list.append({
+                'full_op_name': op_name,
+                'full_info': stack_info
+            })
+
+        merge_list = merge_tensor(op_parsed_list, self.dump_mode)
         return merge_list
 
-    def check_op(self, npu_dict, bench_dict, fuzzy_match):
+    def check_op(self, npu_dict, bench_dict):
         npu_op_name = npu_dict[CompareConst.OP_NAME]
         bench_op_name = bench_dict[CompareConst.OP_NAME]
         graph_mode = check_graph_mode(safe_get_value(npu_op_name, 0, "npu_op_name"),
@@ -133,34 +142,34 @@ class Comparator:
             if graph_mode:
                 return graph_mapping.match(npu_op_name[0], bench_op_name[0])
         struct_match = check_struct_match(npu_dict, bench_dict)
-        if not fuzzy_match:
-            return npu_op_name == bench_op_name and struct_match
-        is_match = True
+        if not self.fuzzy_match:
+            name_match = npu_op_name == bench_op_name
+            return name_match and struct_match
         try:
-            is_match = fuzzy_check_op(npu_op_name, bench_op_name)
+            name_match = fuzzy_check_op(npu_op_name, bench_op_name)
         except Exception as err:
             logger.warning("%s and %s can not fuzzy match." % (npu_op_name, bench_op_name))
-            is_match = False
-        return is_match and struct_match
+            name_match = False
+        return name_match and struct_match
 
-    def match_op(self, npu_queue, bench_queue, fuzzy_match):
+    def match_op(self, npu_queue, bench_queue):
         for b_index, b_op in enumerate(bench_queue[0: -1]):
-            if self.check_op(npu_queue[-1], b_op, fuzzy_match):
+            if self.check_op(npu_queue[-1], b_op):
                 return len(npu_queue) - 1, b_index
-        if self.check_op(npu_queue[-1], bench_queue[-1], fuzzy_match):
+        if self.check_op(npu_queue[-1], bench_queue[-1]):
             return len(npu_queue) - 1, len(bench_queue) - 1
         for n_index, n_op in enumerate(npu_queue[0: -1]):
-            if self.check_op(n_op, bench_queue[-1], fuzzy_match):
+            if self.check_op(n_op, bench_queue[-1]):
                 return n_index, len(bench_queue) - 1
         return -1, -1
 
-    def compare_process(self, file_lists, stack_mode, fuzzy_match, dump_mode):
+    def compare_process(self, file_lists):
         npu_json_path, bench_json_path, stack_json_path = file_lists
         npu_json_data = load_json(npu_json_path)
         bench_json_data = load_json(bench_json_path)
-        stack_json_data = load_json(stack_json_path)
+        stack_json_data = load_json(stack_json_path) if self.stack_mode else None
 
-        if fuzzy_match:
+        if self.fuzzy_match:
             logger.warning("This task uses fuzzy matching, which may affect the accuracy of the comparison.")
 
         npu_ops_queue = []
@@ -184,8 +193,7 @@ class Comparator:
                 last_npu_ops_len = len(npu_ops_queue)
                 op_name_npu = next(ops_npu_iter)
                 check_op_str_pattern_valid(op_name_npu)
-                read_err_npu = True
-                npu_merge_list = self.gen_merge_list(npu_json_data, op_name_npu, stack_json_data, dump_mode)
+                npu_merge_list = self.gen_merge_list(npu_json_data, op_name_npu, stack_json_data)
                 if npu_merge_list:
                     npu_ops_queue.append(npu_merge_list)
             except StopIteration:
@@ -194,7 +202,7 @@ class Comparator:
                 last_bench_ops_len = len(bench_ops_queue)
                 op_name_bench = next(ops_bench_iter)
                 check_op_str_pattern_valid(op_name_bench)
-                bench_merge_list = self.gen_merge_list(bench_json_data, op_name_bench, stack_json_data, dump_mode)
+                bench_merge_list = self.gen_merge_list(bench_json_data, op_name_bench, stack_json_data)
                 if bench_merge_list:
                     bench_ops_queue.append(bench_merge_list)
             except StopIteration:
@@ -213,59 +221,64 @@ class Comparator:
                 logger.info("Please check whether the number and calls of APIs in NPU and Bench models are consistent.")
                 break
 
-            n_match_point, b_match_point = self.match_op(npu_ops_queue, bench_ops_queue, fuzzy_match)
+            n_match_point, b_match_point = self.match_op(npu_ops_queue, bench_ops_queue)
+
+            # 如果没有匹配到，数据放到队列中，跳过，直到后面匹配到，把匹配之前的api放到不匹配中
             if n_match_point == -1 and b_match_point == -1:
                 continue
+
             n_match_data = npu_ops_queue[n_match_point]
             b_match_data = bench_ops_queue[b_match_point]
             un_match_data = npu_ops_queue[0: n_match_point]
             for npu_data in un_match_data:
-                get_un_match_accuracy(result, npu_data, dump_mode)
-            get_accuracy(result, n_match_data, b_match_data, dump_mode)
+                get_un_match_accuracy(result, npu_data, self.dump_mode)
+            get_accuracy(result, n_match_data, b_match_data, self.dump_mode)
             del npu_ops_queue[0: n_match_point + 1]
             del bench_ops_queue[0: b_match_point + 1]
         progress_bar.close()
         if npu_ops_queue:
             for npu_data in npu_ops_queue:
-                get_un_match_accuracy(result, npu_data, dump_mode)
+                get_un_match_accuracy(result, npu_data, self.dump_mode)
 
-        result_df = self.make_result_table(result, stack_mode, dump_mode)
+        result_df = self.make_result_table(result)
         return result_df
 
-    def merge_data(self, json_data, stack_json_data, dump_mode):
+    def merge_data(self, json_data, stack_json_data):
         ops_all = {}
         for op_name in json_data.get('data', {}):
-            merge_list = self.gen_merge_list(json_data, op_name, stack_json_data, dump_mode)
+            merge_list = self.gen_merge_list(json_data, op_name, stack_json_data)
             if merge_list:
-                input_index, output_index = 0, 0
-                for index, input_or_output in enumerate(merge_list[CompareConst.OP_NAME]):
-                    input_or_output_list = input_or_output.split(Const.SEP)
-                    data_name = merge_list.get('data_name')
-                    data_name = data_name[index] if data_name else None
-                    if Const.INPUT in input_or_output_list or Const.KWARGS in input_or_output_list:
-                        ops_all[input_or_output] = {
-                            CompareConst.STRUCT: safe_get_value(merge_list, input_index, "merge_list",
-                                                                key=CompareConst.INPUT_STRUCT),
-                            CompareConst.SUMMARY: safe_get_value(merge_list, index, "merge_list",
-                                                                 key=CompareConst.SUMMARY),
-                            'data_name': data_name,
-                            'stack_info': merge_list.get('stack_info')
-                        }
-                        input_index += 1
-
-                    elif Const.OUTPUT in input_or_output_list:
-                        ops_all[input_or_output] = {
-                            CompareConst.STRUCT: safe_get_value(merge_list, output_index, "merge_list",
-                                                                key=CompareConst.OUTPUT_STRUCT),
-                            CompareConst.SUMMARY: safe_get_value(merge_list, index, "merge_list",
-                                                                 key=CompareConst.SUMMARY),
-                            'data_name': data_name,
-                            'stack_info': merge_list.get('stack_info')
-                        }
-                        output_index += 1
+                struct_to_index_mapping = {
+                    CompareConst.INPUT_STRUCT: 0,
+                    CompareConst.OUTPUT_STRUCT: 0,
+                    CompareConst.PARAMS_STRUCT: 0,
+                    CompareConst.PARAMS_GRAD_STRUCT: 0
+                }
+
+                op_name_list = merge_list.get(CompareConst.OP_NAME)
+                summary_list = merge_list.get(Const.SUMMARY)
+                data_name_list = merge_list.get('data_name')
+                op_name_reorder, summary_reorder, data_name_reorder = reorder_op_x_list(op_name_list,
+                                                                                        summary_list,
+                                                                                        data_name_list)
+                for index, op_full_name in enumerate(op_name_reorder):
+                    data_name = data_name_reorder[index] if data_name_reorder else None
+
+                    _, state = get_name_and_state(op_full_name)
+                    struct_key = CompareConst.STATE_TO_STRUCT_MAPPING.get(state)
+                    if not struct_key:
+                        continue
+                    ops_all[op_full_name] = {
+                        CompareConst.STRUCT: safe_get_value(merge_list, struct_to_index_mapping.get(struct_key),
+                                                            "merge_list", key=struct_key),
+                        CompareConst.SUMMARY: safe_get_value(summary_reorder, index, "summary_reorder"),
+                        'data_name': data_name,
+                        'stack_info': merge_list.get('stack_info')
+                    }
+                    struct_to_index_mapping[struct_key] += 1
         return ops_all
 
-    def get_accuracy(self, npu_ops_all, bench_ops_all, dump_mode):
+    def get_accuracy(self, npu_ops_all, bench_ops_all):
         result = []
         bench_ops_all[CompareConst.N_A] = self._generate_na_data(bench_ops_all)
         for ms_op_name, bench_op_name in self.data_mapping_dict.items():
@@ -273,7 +286,7 @@ class Comparator:
                 npu_stack_info = npu_ops_all.get(ms_op_name).get("stack_info", None)
                 bench_stack_info = bench_ops_all.get(bench_op_name).get("stack_info", None)
                 has_stack = npu_stack_info and bench_stack_info
-                if dump_mode == Const.MD5:
+                if self.dump_mode == Const.MD5:
                     result.append(self.get_result_md5_compare(ms_op_name, bench_op_name, npu_ops_all,
                                                               bench_ops_all, has_stack, npu_stack_info))
                     continue
@@ -297,7 +310,7 @@ class Comparator:
                     bench_struct[1]
                 ]
 
-                if dump_mode == Const.SUMMARY:
+                if self.dump_mode == Const.SUMMARY:
                     result_item = base_result_item + [" "] * 8
                 else:
                     result_item = base_result_item + [" "] * 5
@@ -306,7 +319,7 @@ class Comparator:
                 result_item.extend(npu_summary_data)
                 bench_summary_data = bench_ops_all.get(bench_op_name).get("summary")
                 result_item.extend(bench_summary_data)
-                if dump_mode == Const.SUMMARY:
+                if self.dump_mode == Const.SUMMARY:
                     self.calculate_summary_data(npu_summary_data, bench_summary_data, result_item)
                 else:
                     result_item.append(CompareConst.ACCURACY_CHECK_YES)
@@ -315,7 +328,7 @@ class Comparator:
                     result_item.extend(npu_stack_info)
                 else:
                     result_item.append(CompareConst.NONE)
-                if dump_mode == Const.ALL:
+                if self.dump_mode == Const.ALL:
                     result_item.append(npu_ops_all.get(ms_op_name).get("data_name", None))
                 result.append(result_item)
             elif ms_op_name not in npu_ops_all:
@@ -324,17 +337,16 @@ class Comparator:
                 logger.warning(f'Can not find bench op name : `{bench_op_name}` in bench dump json file.')
         return result
 
-    def compare_process_custom(self, file_lists, stack_mode, dump_mode):
+    def compare_process_custom(self, file_lists):
         npu_json_path, bench_json_path, stack_json_path = file_lists
         npu_json_data = load_json(npu_json_path)
         bench_json_data = load_json(bench_json_path)
-        stack_json_data = load_json(stack_json_path)
-
-        npu_ops_all = self.merge_data(npu_json_data, stack_json_data, dump_mode)
-        bench_ops_all = self.merge_data(bench_json_data, stack_json_data, dump_mode)
+        stack_json_data = load_json(stack_json_path) if self.stack_mode else None
+        npu_ops_all = self.merge_data(npu_json_data, stack_json_data)
+        bench_ops_all = self.merge_data(bench_json_data, stack_json_data)
 
-        result = self.get_accuracy(npu_ops_all, bench_ops_all, dump_mode)
-        result_df = self.make_result_table(result, stack_mode, dump_mode)
+        result = self.get_accuracy(npu_ops_all, bench_ops_all)
+        result_df = self.make_result_table(result)
         return result_df
 
     def compare_by_op(self, npu_op_name, bench_op_name, op_name_mapping_dict, input_param, bench_data):
@@ -381,25 +393,23 @@ class Comparator:
                 n_value, b_value = CompareConst.READ_NONE, CompareConst.READ_NONE
                 error_flag = True
 
-        n_value, b_value, error_flag = get_error_type(n_value, b_value, error_flag)
-        if not error_flag:
-            relative_err = get_relative_err(n_value, b_value)
-            n_value, b_value = reshape_value(n_value, b_value)
+        # 通过n_value, b_value同时得到错误标志和错误信息
+        n_value, b_value, error_flag, err_msg = get_error_flag_and_msg(n_value, b_value,
+                                                                       error_flag=error_flag, error_file=error_file)
 
-        err_msg = get_error_message(n_value, b_value, npu_op_name, error_flag, error_file=error_file)
-        result_list, err_msg = compare_ops_apply(n_value, b_value, error_flag, err_msg, relative_err=relative_err)
+        result_list, err_msg = compare_ops_apply(n_value, b_value, error_flag, err_msg)
 
-        if npu_op_name != bench_op_name and bench_op_name != CompareConst.N_A:
+        if self.fuzzy_match and npu_op_name != bench_op_name and bench_op_name != CompareConst.N_A:
             err_msg += " Fuzzy matching data, the comparison accuracy may be affected."
         result_list.append(err_msg)
         return result_list
 
-    def compare_core(self, input_parma, output_path, **kwargs):
+    def compare_core(self, input_param, output_path, **kwargs):
         """
         Compares data from multiple JSON files and generates a comparison report.
 
         Args:
-            input_parma (dict): A dictionary containing paths to JSON files ("npu_path", "bench_path",
+            input_param (dict): A dictionary containing paths to JSON files ("npu_path", "bench_path",
                                 "stack_path").
             output_path (str): The path where the output Excel report will be saved.
             **kwargs: Additional keyword arguments including:
@@ -412,11 +422,7 @@ class Comparator:
         Returns:
         """
         # get kwargs or set default value
-        stack_mode = kwargs.get('stack_mode', False)
-        auto_analyze = kwargs.get('auto_analyze', True)
         suffix = kwargs.get('suffix', '')
-        fuzzy_match = kwargs.get('fuzzy_match', False)
-        dump_mode = kwargs.get('dump_mode', None)
 
         logger.info("Please check whether the input data belongs to you. If not, there may be security risks.")
         file_name = add_time_with_xlsx("compare_result" + suffix)
@@ -424,30 +430,25 @@ class Comparator:
         remove_path(file_path)
         highlight_dict = {"red_rows": set(), "yellow_rows": set(), "red_lines": [], "yellow_lines": []}
 
-        npu_json = input_parma.get("npu_json_path")
-        bench_json = input_parma.get("bench_json_path")
-        stack_json = input_parma.get("stack_json_path")
+        npu_json = input_param.get("npu_json_path")
+        bench_json = input_param.get("bench_json_path")
+        stack_json = input_param.get("stack_json_path")
         if self.data_mapping:
-            result_df = self.compare_process_custom([npu_json, bench_json, stack_json], stack_mode, dump_mode)
+            result_df = self.compare_process_custom([npu_json, bench_json, stack_json])
         else:
-            result_df = self.compare_process(
-                [npu_json, bench_json, stack_json],
-                stack_mode,
-                fuzzy_match,
-                dump_mode
-            )
+            result_df = self.compare_process([npu_json, bench_json, stack_json])
 
         if not result_df.values.tolist():
             logger.warning("Can`t match any op.")
             return
 
-        if dump_mode == Const.ALL:
-            result_df = self.do_multi_process(input_parma, result_df)
+        if self.dump_mode == Const.ALL:
+            result_df = self.do_multi_process(input_param, result_df)
 
-        find_compare_result_error_rows(result_df, highlight_dict, dump_mode)
+        find_compare_result_error_rows(result_df, highlight_dict, self.dump_mode)
         highlight_rows_xlsx(result_df, highlight_dict, file_path)
 
-        if auto_analyze:
+        if self.auto_analyze:
             advisor = Advisor(result_df, output_path, suffix)
             advisor.analysis()
 
@@ -504,14 +505,18 @@ class Comparator:
             logger.error('result dataframe is not found.')
             raise CompareException(CompareException.INVALID_DATA_ERROR) from e
 
+
 def get_bench_data_name(bench_op_name, bench_data):
-    bench_name_list = re.split(r'\.(input|output|kwargs)\.', bench_op_name)
-    bench_data_bundle = bench_data.get(bench_name_list[0], {})
+    bench_name_list = re.split(r'\.(input|output|kwargs|parameters|parameters_grad)\.', bench_op_name)
+    if len(bench_name_list) > 1 and bench_name_list[1] == Const.PARAMS_GRAD:
+        bench_data_bundle = bench_data.get(bench_name_list[0] + Const.SEP + bench_name_list[1], {})
+    else:
+        bench_data_bundle = bench_data.get(bench_name_list[0], {})
     if not bench_data_bundle or len(bench_name_list) < 3:
         return None
     layers = bench_name_list[2].split(Const.SEP)
 
-    def get(key, container):
+    def _get(key, container):
         if isinstance(container, dict):
             return container.get(key)
         if isinstance(container, list):
@@ -521,11 +526,14 @@ def get_bench_data_name(bench_op_name, bench_data):
                 return None
         return None
 
-    def get_by_layer(container):
+    def get_by_layer(container, params_grad=False):
         data = container
+        # dump.json中parameters_grad的结构为key：[{}], 如果存在key，有且只有一个列表元素，而op_name中只命名到了key，因此加'0'
+        if params_grad:
+            layers.append('0')
         for layer in layers:
-            data = get(layer, data)
-        return get(CompareConst.DATA_NAME.lower(), data)
+            data = _get(layer, data)
+        return _get(CompareConst.DATA_NAME.lower(), data)
 
     if Const.INPUT == bench_name_list[1]:
         return get_by_layer(bench_data_bundle.get(Const.INPUT, bench_data_bundle.get(Const.INPUT_ARGS)))
@@ -533,6 +541,9 @@ def get_bench_data_name(bench_op_name, bench_data):
         return get_by_layer(bench_data_bundle.get(Const.INPUT_KWARGS))
     elif Const.OUTPUT == bench_name_list[1]:
         return get_by_layer(bench_data_bundle.get(Const.OUTPUT))
+    elif Const.PARAMS == bench_name_list[1]:
+        return get_by_layer(bench_data_bundle.get(Const.PARAMS))
+    elif Const.PARAMS_GRAD == bench_name_list[1]:
+        return get_by_layer(bench_data_bundle, params_grad=True)
     else:
         return None
-

msprobe/core/compare/check.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");
@@ -16,8 +16,7 @@
 from msprobe.core.common.log import logger
 from msprobe.core.compare.utils import rename_api
 from msprobe.core.common.utils import check_op_str_pattern_valid, CompareException
-from msprobe.core.common.const import Const
-
+from msprobe.core.common.const import CompareConst, Const
 
 dtype_mapping = {
     "Int8": "torch.int8",
@@ -38,31 +37,40 @@ dtype_mapping = {
 }
 
 
-def check_struct_match(npu_dict, bench_dict):
-    npu_struct_in = npu_dict.get("input_struct")
-    bench_struct_in = bench_dict.get("input_struct")
-    npu_struct_out = npu_dict.get("output_struct")
-    bench_struct_out = bench_dict.get("output_struct")
+def compare_op_dict_struct(npu_dict, bench_dict):
+    return all(npu_dict.get(key) == bench_dict.get(key) for key in CompareConst.STRUCT_COMPARE_KEY)
 
-    is_match = npu_struct_in == bench_struct_in and npu_struct_out == bench_struct_out
+
+def check_struct_match(npu_dict, bench_dict):
+    is_match = compare_op_dict_struct(npu_dict, bench_dict)
     if not is_match:
-        if len(npu_struct_in) == 0 or len(bench_struct_in) == 0 or len(npu_struct_in) != len(bench_struct_in):
-            return False
+        struct_match_list = []
         try:
-            struct_in_is_match = check_type_shape_match(npu_struct_in, bench_struct_in)
-            struct_out_is_match = check_type_shape_match(npu_struct_out, bench_struct_out)
+            for i, key in enumerate(CompareConst.STRUCT_COMPARE_KEY):
+                # 首先额外检查input_struct是否空，input_struct不可能为空
+                if i == 0 and (not npu_dict.get(key, []) or not bench_dict.get(key, [])):
+                    return False
+                struct_match_list.append(check_type_shape_match(npu_dict.get(key, []), bench_dict.get(key, [])))
         except CompareException as error:
             err_msg = f'index out of bounds error occurs in npu or bench api, please check!\n' \
                       f'npu_dict: {npu_dict}' \
                       f'bench_dict: {bench_dict}'
             logger.error(err_msg)
             raise CompareException(CompareException.INDEX_OUT_OF_BOUNDS_ERROR) from error
-        is_match = struct_in_is_match and struct_out_is_match
+        is_match = all(struct_match_list)
     return is_match
 
 
 def check_type_shape_match(npu_struct, bench_struct):
-    shape_type_match = False
+    """
+    further check dtypes with a dtype mapping list when dtypes are not entirely consistent.
+    """
+    if len(npu_struct) != len(bench_struct):
+        return False
+    if not npu_struct and not bench_struct:
+        return True
+
+    struct_match = False
     for npu_type_shape, bench_type_shape in zip(npu_struct, bench_struct):
         try:
             npu_type = npu_type_shape[0]
@@ -76,22 +84,14 @@ def check_type_shape_match(npu_struct, bench_struct):
         shape_match = npu_shape == bench_shape
         type_match = npu_type == bench_type
         if not type_match:
-            ms_type = [
-                [Const.FLOAT16, Const.FLOAT32], [Const.FLOAT32, Const.FLOAT16],
-                [Const.FLOAT16, Const.BFLOAT16], [Const.BFLOAT16, Const.FLOAT16]
-            ]
-            torch_type = [
-                [Const.TORCH_FLOAT16, Const.TORCH_FLOAT32], [Const.TORCH_FLOAT32, Const.TORCH_FLOAT16],
-                [Const.TORCH_FLOAT16, Const.TORCH_BFLOAT16], [Const.TORCH_BFLOAT16, Const.TORCH_FLOAT16]
-            ]
-            if ([npu_type, bench_type] in ms_type) or ([npu_type, bench_type] in torch_type):
+            if ([npu_type, bench_type] in CompareConst.MS_TYPE) or ([npu_type, bench_type] in CompareConst.TORCH_TYPE):
                 type_match = True
             else:
                 type_match = False
-        shape_type_match = shape_match and type_match
-        if not shape_type_match:
+        struct_match = shape_match and type_match
+        if not struct_match:
             return False
-    return shape_type_match
+    return struct_match
 
 
 def check_graph_mode(a_op_name, b_op_name):
@@ -103,6 +103,8 @@ def check_graph_mode(a_op_name, b_op_name):
 
 
 def fuzzy_check_op(npu_name_list, bench_name_list):
+    # 先检查api里的item长度是否相等，如果不是parameters_grad, 必然有input或者output，长度不可能为0
+    # 如果是parameters_grad, "parameters_grad"字段的字典不会是空字典，因此len>=1
     if len(npu_name_list) == 0 or len(bench_name_list) == 0 or len(npu_name_list) != len(bench_name_list):
         return False
     is_match = True
@@ -148,11 +150,11 @@ def check_json_key_value(input_output, op_name, depth=0):
         return
     if isinstance(input_output, list):
         for item in input_output:
-            check_json_key_value(item, op_name, depth+1)
+            check_json_key_value(item, op_name, depth + 1)
     elif isinstance(input_output, dict):
         for key, value in input_output.items():
             if isinstance(value, dict):
-                check_json_key_value(value, op_name, depth+1)
+                check_json_key_value(value, op_name, depth + 1)
             else:
                 valid_key_value(key, value, op_name)
 

msprobe/core/compare/compare_cli.py

@@ -38,40 +38,41 @@ def compare_cli(args):
     else:
         from msprobe.mindspore.compare.ms_compare import ms_compare
         from msprobe.mindspore.compare.distributed_compare import ms_compare_distributed, ms_graph_compare
+
+    common_kwargs = {
+        "auto_analyze": auto_analyze,
+        "fuzzy_match": args.fuzzy_match,
+        "data_mapping": args.data_mapping,
+    }
+
     if check_file_type(npu_path) == FileCheckConst.FILE and check_file_type(bench_path) == FileCheckConst.FILE:
-        if "stack_path" not in input_param:
-            logger.error(f"Missing stack_path in configuration file {args.input_path}, please check!")
-            raise CompareException(CompareException.INVALID_PATH_ERROR)
         input_param["npu_json_path"] = input_param.pop("npu_path")
         input_param["bench_json_path"] = input_param.pop("bench_path")
-        input_param["stack_json_path"] = input_param.pop("stack_path")
+        if "stack_path" not in input_param:
+            logger.warning(f"Missing stack_path in the configuration file. "
+                           f"Automatically detecting stack.json to determine whether to display NPU_Stack_Info.")
+        else:
+            input_param["stack_json_path"] = input_param.pop("stack_path")
+
         if frame_name == Const.PT_FRAMEWORK:
-            kwargs = {
-                "data_mapping": args.data_mapping
-            }
-            compare(input_param, args.output_path, stack_mode=args.stack_mode, auto_analyze=auto_analyze,
-                    fuzzy_match=args.fuzzy_match, **kwargs)
+            kwargs = {**common_kwargs, "stack_mode": args.stack_mode}
+            compare(input_param, args.output_path, **kwargs)
         else:
             kwargs = {
+                **common_kwargs,
                 "stack_mode": args.stack_mode,
-                "auto_analyze": auto_analyze,
-                "fuzzy_match": args.fuzzy_match,
                 "cell_mapping": args.cell_mapping,
                 "api_mapping": args.api_mapping,
-                "data_mapping": args.data_mapping,
                 "layer_mapping": args.layer_mapping
             }
-
             ms_compare(input_param, args.output_path, **kwargs)
     elif check_file_type(npu_path) == FileCheckConst.DIR and check_file_type(bench_path) == FileCheckConst.DIR:
         kwargs = {
+            **common_kwargs,
             "stack_mode": args.stack_mode,
-            "auto_analyze": auto_analyze,
-            "fuzzy_match": args.fuzzy_match,
             "is_print_compare_log": input_param.get("is_print_compare_log", True),
             "cell_mapping": args.cell_mapping,
             "api_mapping": args.api_mapping,
-            "data_mapping": args.data_mapping,
             "layer_mapping": args.layer_mapping
         }
         if input_param.get("rank_id") is not None: