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

msprobe/core/compare/acc_compare.py

@@ -282,6 +282,8 @@ class Comparator:
         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():
+            check_op_str_pattern_valid(ms_op_name)
+            check_op_str_pattern_valid(bench_op_name)
             if ms_op_name in npu_ops_all and bench_op_name in bench_ops_all:
                 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)
@@ -311,9 +313,9 @@ class Comparator:
                 ]
 
                 if self.dump_mode == Const.SUMMARY:
-                    result_item = base_result_item + [" "] * 8
+                    result_item = base_result_item + [" "] * 8  # 8个统计量数据情况的比对指标
                 else:
-                    result_item = base_result_item + [" "] * 5
+                    result_item = base_result_item + [" "] * 6  # 6个真实数据情况的比对指标
 
                 npu_summary_data = npu_ops_all.get(ms_op_name).get("summary")
                 result_item.extend(npu_summary_data)
@@ -329,8 +331,11 @@ class Comparator:
                 else:
                     result_item.append(CompareConst.NONE)
                 if self.dump_mode == Const.ALL:
-                    result_item.append(npu_ops_all.get(ms_op_name).get("data_name", None))
+                    ms_data_name = npu_ops_all.get(ms_op_name).get("data_name", None)
+                    pt_data_name = bench_ops_all.get(bench_op_name).get("data_name", None)
+                    result_item.append([ms_data_name, pt_data_name])
                 result.append(result_item)
+                logger.info(f"{ms_op_name}, {bench_op_name} compared.")
             elif ms_op_name not in npu_ops_all:
                 logger.warning(f'Can not find npu op name : `{ms_op_name}` in npu dump json file.')
             elif bench_op_name not in npu_ops_all:
@@ -349,47 +354,48 @@ class Comparator:
         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):
+    def compare_by_op(self, npu_op_name, bench_op_name, op_name_mapping_dict, input_param):
         """
         :param npu_op_name: excel中的NPU_Name，例如：MintFunctional.conv2d.0.forward.input.3.0
         :param bench_op_name: excel中的Bench_Name，例如：Functional.conv2d.0.forward.input.3.0
         :param op_name_mapping_dict: op_name和npy或pt文件的映射关系
         :param input_param: npu_json_path/bench_json_path/stack_json_path等参数
-        :param bench_data: bench的dump数据中"data"字段
         :return: result_list，包含余弦相似度、最大绝对误差、最大相对误差、千分之一误差率、千分之五误差率和错误信息
-        用于读取excel中的NPU_Name和Bench_Name，根据映射关系找到npy或pt文件，然后读取文件中的数据进行比较，计算余弦相似度、
+        用于读取excel中的NPU_Name和Bench_Name，根据映射关系找到npy或pt文件，然后读取文件中的数据进行比较，计算余弦相似度、欧式距离
         最大绝对误差、最大相对误差、千分之一误差率、千分之五误差率并生成错误信息
         """
-        npu_bench_name_list = op_name_mapping_dict[npu_op_name]
-        data_name = safe_get_value(npu_bench_name_list, 1, "npu_bench_name_list")
         error_file, relative_err, error_flag = None, None, False
-        bench_data_name = get_bench_data_name(bench_op_name, bench_data)
-        if data_name == '-1' or data_name == -1:  # 没有真实数据路径
-            n_value, b_value = CompareConst.READ_NONE, CompareConst.READ_NONE
-            error_flag = True
-        elif not bench_data_name:
+
+        data_name_pair = op_name_mapping_dict.get(npu_op_name)
+        npu_data_name = data_name_pair[0]
+        bench_data_name = data_name_pair[1]
+
+        if str(npu_data_name) == '-1':  # 没有npu真实数据
+            n_value, b_value, error_flag = CompareConst.READ_NONE, CompareConst.READ_NONE, True
+        elif str(bench_data_name) == '-1':  # 没有bench真实数据
             n_value, b_value, error_flag = CompareConst.READ_NONE, CompareConst.READ_NONE, True
             error_file = 'no_bench_data'
         else:
+            npu_dir = input_param.get("npu_dump_data_dir")
+            bench_dir = input_param.get("bench_dump_data_dir")
             try:
-                read_npy_data = getattr(self, "read_npy_data")
                 frame_name = getattr(self, "frame_name")
+                read_npy_data = getattr(self, "read_npy_data")
                 if frame_name == "MSComparator":
-                    n_value = read_npy_data(input_param.get("npu_dump_data_dir"), npu_op_name + Const.NUMPY_SUFFIX)
+                    n_value = read_npy_data(npu_dir, npu_data_name)
                     if self.cross_frame:
-                        b_value = read_npy_data(input_param.get("bench_dump_data_dir"), bench_data_name,
-                                                load_pt_file=True)
+                        b_value = read_npy_data(bench_dir, bench_data_name, load_pt_file=True)
                     else:
-                        b_value = read_npy_data(input_param.get("bench_dump_data_dir"), bench_data_name)
+                        b_value = read_npy_data(bench_dir, bench_data_name)
                 else:
-                    n_value = read_npy_data(input_param.get("npu_dump_data_dir"), npu_op_name + Const.PT_SUFFIX)
-                    b_value = read_npy_data(input_param.get("bench_dump_data_dir"), bench_data_name)
+                    n_value = read_npy_data(npu_dir, npu_data_name)
+                    b_value = read_npy_data(bench_dir, bench_data_name)
             except IOError as error:
                 error_file = error.filename
                 n_value, b_value = CompareConst.READ_NONE, CompareConst.READ_NONE
                 error_flag = True
             except (FileCheckException, CompareException):
-                error_file = data_name
+                error_file = npu_data_name
                 n_value, b_value = CompareConst.READ_NONE, CompareConst.READ_NONE
                 error_flag = True
 
@@ -427,7 +433,9 @@ class Comparator:
         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)
         file_path = os.path.join(os.path.realpath(output_path), file_name)
-        remove_path(file_path)
+        if os.path.exists(file_path):
+            logger.warning(f"{file_path} will be deleted.")
+            remove_path(file_path)
         highlight_dict = {"red_rows": set(), "yellow_rows": set(), "red_lines": [], "yellow_lines": []}
 
         npu_json = input_param.get("npu_json_path")
@@ -456,21 +464,23 @@ class Comparator:
 
     def compare_ops(self, idx, dump_path_dict, result_df, lock, input_param):
         cos_result = []
+        euc_dist_result = []
         max_err_result = []
         max_relative_err_result = []
-        err_mess = []
         one_thousand_err_ratio_result = []
         five_thousand_err_ratio_result = []
+        err_mess = []
+
         is_print_compare_log = input_param.get("is_print_compare_log")
-        bench_data = load_json(input_param.get("bench_json_path")).get('data')
+
         for i in range(len(result_df)):
             npu_op_name = result_df.iloc[i, 0]
             bench_op_name = result_df.iloc[i, 1]
             if is_print_compare_log:
                 logger.info("start compare: {}".format(npu_op_name))
 
-            cos_sim, max_abs_err, max_relative_err, one_thousand_err_ratio, five_thousand_err_ratio, err_msg = \
-                self.compare_by_op(npu_op_name, bench_op_name, dump_path_dict, input_param, bench_data)
+            cos_sim, euc_dist, max_abs_err, max_relative_err, one_thousand_err_ratio, five_thousand_err_ratio, err_msg \
+                = self.compare_by_op(npu_op_name, bench_op_name, dump_path_dict, input_param)
 
             if is_print_compare_log:
                 logger.info(
@@ -479,71 +489,30 @@ class Comparator:
                     "five_thousand_err_ratio {}".format(npu_op_name, cos_sim, max_abs_err, max_relative_err,
                                                         err_msg, one_thousand_err_ratio, five_thousand_err_ratio))
             cos_result.append(cos_sim)
+            euc_dist_result.append(euc_dist)
             max_err_result.append(max_abs_err)
             max_relative_err_result.append(max_relative_err)
-            err_mess.append(err_msg)
             one_thousand_err_ratio_result.append(one_thousand_err_ratio)
             five_thousand_err_ratio_result.append(five_thousand_err_ratio)
+            err_mess.append(err_msg)
 
         cr = ComparisonResult(
             cos_result=cos_result,
+            euc_dist_result=euc_dist_result,
             max_err_result=max_err_result,
             max_relative_err_result=max_relative_err_result,
-            err_msgs=err_mess,
             one_thousand_err_ratio_result=one_thousand_err_ratio_result,
-            five_thousand_err_ratio_result=five_thousand_err_ratio_result
+            five_thousand_err_ratio_result=five_thousand_err_ratio_result,
+            err_msgs=err_mess
         )
 
         return _save_cmp_result(idx, cr, result_df, lock)
 
-    def do_multi_process(self, input_parma, result_df):
+    def do_multi_process(self, input_param, result_df):
         try:
-            result_df = _handle_multi_process(self.compare_ops, input_parma, result_df,
+            result_df = _handle_multi_process(self.compare_ops, input_param, result_df,
                                               multiprocessing.Manager().RLock())
             return result_df
         except ValueError as e:
             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|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):
-        if isinstance(container, dict):
-            return container.get(key)
-        if isinstance(container, list):
-            try:
-                return container[int(key)]
-            except (ValueError, IndexError):
-                return None
-        return None
-
-    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)
-
-    if Const.INPUT == bench_name_list[1]:
-        return get_by_layer(bench_data_bundle.get(Const.INPUT, bench_data_bundle.get(Const.INPUT_ARGS)))
-    elif Const.KWARGS == bench_name_list[1]:
-        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

@@ -82,12 +82,8 @@ def check_type_shape_match(npu_struct, bench_struct):
                          f'should both be 2, please check!')
             raise CompareException(CompareException.INDEX_OUT_OF_BOUNDS_ERROR) from error
         shape_match = npu_shape == bench_shape
-        type_match = npu_type == bench_type
-        if not type_match:
-            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
+        type_match = ((npu_type == bench_type) or
+                      any(npu_type in group and bench_type in group for group in CompareConst.DTYPE_MATCH_GROUPS))
         struct_match = shape_match and type_match
         if not struct_match:
             return False

msprobe/core/compare/highlight.py

@@ -146,11 +146,13 @@ class HighlightRules:
     }
 
     # 用于比较输入和输出的规则
+    # 真实数据检查规则
     compare_rules = {
         "check_order_magnitude": CheckOrderMagnitude(),
         "check_one_thousand_error": CheckOneThousandErrorRatio(),
         "check_cosine_similarity": CheckCosineSimilarity()
     }
+    # 统计量数据检查规则
     summary_compare_rules = {
         "check_order_magnitude": CheckOrderMagnitude(),
         "check_max_relative_diff": CheckMaxRelativeDiff(),

msprobe/core/compare/layer_mapping/layer_mapping.py

@@ -23,7 +23,7 @@ from msprobe.core.common.utils import (add_time_with_yaml,
                                        get_stack_construct_by_dump_json_path)
 from msprobe.core.compare.layer_mapping.data_scope_parser import get_dump_data_items
 from msprobe.core.compare.utils import read_op, reorder_op_name_list
-
+from msprobe.core.common.decorator import recursion_depth_decorator
 
 
 class LayerTrie:
@@ -71,6 +71,7 @@ class LayerTrie:
         file_path = os.path.join(os.path.realpath(output_path), file_name)
         save_yaml(file_path, result)
 
+    @recursion_depth_decorator("LayerMapping: LayerTrie.convert_to_dict", max_depth=100)
     def convert_to_dict(self, node):
         result = {}
         result["data_item"] = {st: [dt.data_name for dt in dts] for st, dts in node.data_items.items()}

msprobe/core/compare/merge_result/merge_result.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");
@@ -21,7 +21,8 @@ from functools import partial
 import pandas as pd
 from tqdm import tqdm
 
-from msprobe.core.common.file_utils import load_yaml, logger, FileChecker, save_excel, read_xlsx, create_directory
+from msprobe.core.common.file_utils import load_yaml, logger, FileChecker, save_excel, read_xlsx, create_directory, \
+    remove_path
 from msprobe.core.common.const import FileCheckConst, Const, CompareConst
 from msprobe.core.common.utils import CompareException, add_time_with_xlsx
 from msprobe.core.compare.utils import table_value_is_valid
@@ -63,6 +64,7 @@ def get_result_path(input_dir):
                                 for f in os.listdir(input_dir) if f.endswith(FileCheckConst.XLSX_SUFFIX)]
     filt_compare_result_path_list = []
     for file_path in compare_result_path_list:
+        FileChecker(file_path, FileCheckConst.FILE, FileCheckConst.READ_ABLE).common_check()
         file_name = os.path.basename(file_path)
         if check_compare_result_name(file_name):
             compare_result_path_checker = FileChecker(file_path, FileCheckConst.FILE, FileCheckConst.READ_ABLE)
@@ -329,6 +331,10 @@ def generate_merge_result(all_compare_index_dict_list, all_rank_num_list, all_co
     for i, df in enumerate(merge_df_list):
         # merge_df_list中df与compare_index_list中compare_index一一对应
         final_result_df_list.append((df, compare_index_list[i]))
+
+    if os.path.exists(output_path):
+        logger.warning(f"{output_path} will be deleted.")
+        remove_path(output_path)
     save_excel(output_path, final_result_df_list)
     logger.info(f"The compare results of the multi-ranks are merged and saved in: {output_path}.")
 

msprobe/core/compare/multiprocessing_compute.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");
@@ -15,14 +15,17 @@
 
 import multiprocessing
 from dataclasses import dataclass
+from functools import partial
+
 import pandas as pd
 from tqdm import tqdm
+
 from msprobe.core.common.log import logger
 from msprobe.core.common.utils import CompareException
 from msprobe.core.common.const import CompareConst
 
 
-def _handle_multi_process(func, input_parma, result_df, lock):
+def _handle_multi_process(func, input_param, result_df, lock):
     process_num = max(int((multiprocessing.cpu_count() + 1) // 4), 1)
     op_name_mapping_dict = read_dump_data(result_df)
 
@@ -44,7 +47,7 @@ def _handle_multi_process(func, input_parma, result_df, lock):
 
     progress_bar = tqdm(total=len(result_df), desc="API/Module Item Compare Process", unit="row", ncols=100)
 
-    def update_progress(size, progress_lock):
+    def update_progress(size, progress_lock, extra_param=None):
         with progress_lock:
             progress_bar.update(size)
 
@@ -52,10 +55,12 @@ def _handle_multi_process(func, input_parma, result_df, lock):
         idx = df_chunk_size * process_idx
         chunk_size = len(df_chunk)
         result = pool.apply_async(func,
-                                  args=(idx, op_name_mapping_dict, df_chunk, lock, input_parma),
+                                  args=(idx, op_name_mapping_dict, df_chunk, lock, input_param),
                                   error_callback=err_call,
-                                  callback=update_progress(chunk_size, lock))
+                                  callback=partial(update_progress, chunk_size, lock)
+                                  )
         results.append(result)
+
     final_results = [r.get() for r in results]
     pool.close()
     pool.join()
@@ -92,12 +97,12 @@ def _ms_graph_handle_multi_process(func, result_df, mode):
 def read_dump_data(result_df):
     try:
         npu_dump_name_list = result_df.iloc[0:, 0].tolist()
-        npu_dump_tensor_list = result_df.iloc[0:, -1].tolist()
+        dump_tensor_pair_list = result_df.iloc[0:, -1].tolist()
         op_name_mapping_dict = {}
         for index, _ in enumerate(npu_dump_name_list):
             npu_dump_name = npu_dump_name_list[index]
-            npu_dump_tensor = npu_dump_tensor_list[index]
-            op_name_mapping_dict[npu_dump_name] = [npu_dump_tensor, npu_dump_tensor]
+            dump_tensor_pair = dump_tensor_pair_list[index]
+            op_name_mapping_dict[npu_dump_name] = dump_tensor_pair
         return op_name_mapping_dict
     except ValueError as e:
         logger.error('result dataframe is not found.')
@@ -110,11 +115,12 @@ def read_dump_data(result_df):
 @dataclass
 class ComparisonResult:
     cos_result: list
+    euc_dist_result: list
     max_err_result:  list
     max_relative_err_result: list
-    err_msgs: list
     one_thousand_err_ratio_result: list
     five_thousand_err_ratio_result: list
+    err_msgs: list
 
 
 def _save_cmp_result(offset, result: ComparisonResult, result_df, lock):
@@ -135,15 +141,16 @@ def _save_cmp_result(offset, result: ComparisonResult, result_df, lock):
         for i, _ in enumerate(result.cos_result):
             process_index = i + offset
             result_df.loc[process_index, CompareConst.COSINE] = result.cos_result[i]
+            result_df.loc[process_index, CompareConst.EUC_DIST] = result.euc_dist_result[i]
             result_df.loc[process_index, CompareConst.MAX_ABS_ERR] = result.max_err_result[i]
             result_df.loc[process_index, CompareConst.MAX_RELATIVE_ERR] = result.max_relative_err_result[i]
-            result_df.loc[process_index, CompareConst.ERROR_MESSAGE] = result.err_msgs[i]
-            result_df.loc[process_index, CompareConst.ACCURACY] = (
-                check_accuracy(result.cos_result[i], result.max_err_result[i]))
             result_df.loc[process_index, CompareConst.ONE_THOUSANDTH_ERR_RATIO] = (
                 result.one_thousand_err_ratio_result)[i]
             result_df.loc[process_index, CompareConst.FIVE_THOUSANDTHS_ERR_RATIO] = (
                 result.five_thousand_err_ratio_result)[i]
+            result_df.loc[process_index, CompareConst.ACCURACY] = (
+                check_accuracy(result.cos_result[i], result.max_err_result[i]))
+            result_df.loc[process_index, CompareConst.ERROR_MESSAGE] = result.err_msgs[i]
         return result_df
     except ValueError as e:
         logger.error('result dataframe is not found.')

msprobe/core/compare/npy_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");
@@ -70,7 +70,7 @@ def get_error_flag_and_msg(n_value, b_value, error_flag=False, error_file=None):
         error_flag = True
         return CompareConst.NONE, CompareConst.NONE, error_flag, err_msg
     if not n_value.shape:  # 判断数据是否为0维张量
-        err_msg = (f"This is type of 0-d tensor, can not calculate '{CompareConst.COSINE}', "
+        err_msg = (f"This is type of 0-d tensor, can not calculate '{CompareConst.COSINE}', '{CompareConst.EUC_DIST}', "
                    f"'{CompareConst.ONE_THOUSANDTH_ERR_RATIO}' and '{CompareConst.FIVE_THOUSANDTHS_ERR_RATIO}'. ")
         error_flag = False  # 0-d tensor 最大绝对误差、最大相对误差仍然支持计算，因此error_flag设置为False，不做统一处理
         return n_value, b_value, error_flag, err_msg
@@ -168,8 +168,9 @@ def statistics_data_check(result_dict):
 
 class TensorComparisonBasic(abc.ABC):
     """NPU和bench中npy数据的比较模板"""
+
     @abc.abstractmethod
-    def apply(self, n_value, b_value, relative_err):
+    def apply(self, n_value, b_value, relative_err, err_msg):
         raise NotImplementedError
 
 
@@ -190,6 +191,7 @@ def get_relative_err(n_value, b_value):
 
 class GetCosineSimilarity(TensorComparisonBasic):
     """计算cosine相似度"""
+
     @staticmethod
     def correct_data(result):
         if result == CompareConst.NAN:
@@ -198,9 +200,9 @@ class GetCosineSimilarity(TensorComparisonBasic):
             return round(float(result), 6)
         return result
 
-    def apply(self, n_value, b_value, relative_err):
-        if not n_value.shape:
-            return CompareConst.UNSUPPORTED, ""
+    def apply(self, n_value, b_value, relative_err, err_msg):
+        if "This is type of 0-d tensor" in err_msg:
+            return CompareConst.UNSUPPORTED, err_msg
 
         with np.errstate(divide="ignore", invalid="ignore"):
             if len(n_value) == 1:
@@ -224,9 +226,22 @@ class GetCosineSimilarity(TensorComparisonBasic):
         return result, ""
 
 
+class GetEuclideanDistance(TensorComparisonBasic):
+    """计算欧式距离"""
+
+    def apply(self, n_value, b_value, relative_err, err_msg):
+        if "This is type of 0-d tensor" in err_msg:
+            return CompareConst.UNSUPPORTED, err_msg
+
+        distance = np.linalg.norm(n_value - b_value, ord=2)
+
+        return distance, ""
+
+
 class GetMaxAbsErr(TensorComparisonBasic):
     """计算最大绝对误差"""
-    def apply(self, n_value, b_value, relative_err):
+
+    def apply(self, n_value, b_value, relative_err, err_msg):
         temp_res = n_value - b_value
         max_value = np.max(np.abs(temp_res))
         if np.isnan(max_value):
@@ -237,7 +252,8 @@ class GetMaxAbsErr(TensorComparisonBasic):
 
 class GetMaxRelativeErr(TensorComparisonBasic):
     """计算最大相对误差"""
-    def apply(self, n_value, b_value, relative_err):
+
+    def apply(self, n_value, b_value, relative_err, err_msg):
         max_relative_err = np.max(np.abs(relative_err))
         if np.isnan(max_relative_err):
             msg = "Cannot compare by MaxRelativeError, the data contains nan/inf/-inf in dump data."
@@ -247,12 +263,13 @@ class GetMaxRelativeErr(TensorComparisonBasic):
 
 class GetErrRatio(TensorComparisonBasic):
     """计算相对误差小于指定阈值(千分之一、千分之五)的比例"""
+
     def __init__(self, threshold):
         self.threshold = threshold
 
-    def apply(self, n_value, b_value, relative_err):
-        if not n_value.shape:
-            return CompareConst.UNSUPPORTED, ""
+    def apply(self, n_value, b_value, relative_err, err_msg):
+        if "This is type of 0-d tensor" in err_msg:
+            return CompareConst.UNSUPPORTED, err_msg
 
         if not np.size(relative_err):
             return CompareConst.NAN, ""
@@ -264,6 +281,7 @@ class GetErrRatio(TensorComparisonBasic):
 class CompareOps:
     compare_ops = {
         "cosine_similarity": GetCosineSimilarity(),
+        "euclidean_distance": GetEuclideanDistance(),
         "max_abs_error": GetMaxAbsErr(),
         "max_relative_error": GetMaxRelativeErr(),
         "one_thousand_err_ratio": GetErrRatio(CompareConst.THOUSAND_RATIO_THRESHOLD),
@@ -295,7 +313,7 @@ def compare_ops_apply(n_value, b_value, error_flag, err_msg):
     n_value, b_value = reshape_value(n_value, b_value)
 
     for op in CompareOps.compare_ops.values():
-        result, msg = op.apply(n_value, b_value, relative_err)
+        result, msg = op.apply(n_value, b_value, relative_err, err_msg)
         result_list.append(result)
         err_msg += msg
     return result_list, err_msg

msprobe/core/compare/utils.py

@@ -285,9 +285,9 @@ def result_item_init(n_info, b_info, dump_mode):
             md5_compare_result = CompareConst.PASS if n_info.struct[2] == b_info.struct[2] else CompareConst.DIFF
             result_item.extend([n_info.struct[2], b_info.struct[2], md5_compare_result])
         elif dump_mode == Const.SUMMARY:
-            result_item.extend([" "] * 8)
+            result_item.extend([" "] * 8)  # 8个统计量数据情况的比对指标
         else:
-            result_item.extend([" "] * 5)
+            result_item.extend([" "] * 6)  # 6个真实数据情况的比对指标
     else:
         err_msg = "index out of bounds error will occur in result_item_init, please check!\n" \
                   f"npu_info_struct is {n_info.struct}\n" \
@@ -321,8 +321,8 @@ def get_accuracy(result, n_dict, b_dict, dump_mode):
         has_stack = npu_stack_info and bench_stack_info
 
         if dump_mode == Const.ALL:
-            npu_data_name = n_dict.get("data_name", None)
-            bench_data_name = b_dict.get("data_name", None)
+            npu_data_name_list = n_dict.get("data_name", None)
+            bench_data_name_list = b_dict.get("data_name", None)
 
         for index in range(min_len):
             n_name = safe_get_value(n_dict, n_start + index, "n_dict", key="op_name")
@@ -353,7 +353,9 @@ def get_accuracy(result, n_dict, b_dict, dump_mode):
             result_item.append(err_msg)
             result_item = stack_column_process(result_item, has_stack, index, key, npu_stack_info)
             if dump_mode == Const.ALL:
-                result_item.append(safe_get_value(npu_data_name, n_start + index, "npu_data_name"))
+                npu_data_name = safe_get_value(npu_data_name_list, n_start + index, "npu_data_name_list")
+                bench_data_name = safe_get_value(bench_data_name_list, b_start + index, "bench_data_name_list")
+                result_item.append([npu_data_name, bench_data_name])
 
             result.append(result_item)
 
@@ -371,7 +373,7 @@ def get_accuracy(result, n_dict, b_dict, dump_mode):
                         continue
                     result_item = [
                         n_name, CompareConst.NAN, n_struct[0], CompareConst.NAN, n_struct[1], CompareConst.NAN,
-                        " ", " ", " ", " ", " "
+                        " ", " ", " ", " ", " ", " "
                     ]
                     summary_data = n_dict.get(CompareConst.SUMMARY)[n_start + index]
                     result_item.extend(summary_data)
@@ -388,7 +390,8 @@ def get_accuracy(result, n_dict, b_dict, dump_mode):
                 result_item.append(err_msg)
                 result_item = stack_column_process(result_item, has_stack, index, key, npu_stack_info)
                 if dump_mode == Const.ALL:
-                    result_item.append(safe_get_value(npu_data_name, n_start + index, "npu_data_name"))
+                    npu_data_name = safe_get_value(npu_data_name_list, n_start + index, "npu_data_name_list")
+                    result_item.append([npu_data_name, "-1"])
 
                 result.append(result_item)
 
@@ -453,9 +456,9 @@ def get_un_match_accuracy(result, n_dict, dump_mode):
             result.append(result_item)
             continue
         if dump_mode == Const.SUMMARY:
-            result_item.extend([CompareConst.N_A] * 8)
+            result_item.extend([CompareConst.N_A] * 8)  # 8个统计量数据情况的比对指标
         if dump_mode == Const.ALL:
-            result_item.extend([CompareConst.N_A] * 5)
+            result_item.extend([CompareConst.N_A] * 6)  # 6个真实数据情况的比对指标
 
         npu_summary_data = safe_get_value(summary_reorder, index, "summary_reorder")
         bench_summary_data = [CompareConst.N_A] * 4
@@ -467,7 +470,7 @@ def get_un_match_accuracy(result, n_dict, dump_mode):
         result_item.append(err_msg)
         append_stack_info(result_item, npu_stack_info, index)
         if dump_mode == Const.ALL and result_item[1] == CompareConst.N_A:
-            result_item.extend(["-1"])
+            result_item.extend([["-1", "-1"]])
         result.append(result_item)
 
 
@@ -542,10 +545,17 @@ def get_name_and_state(name):
 
     state type: input, output, kwargs, parameters, parameters_grad
     """
+    if not isinstance(name, str):
+        logger.error(f'Invalid name: {name}, type should be string, please check.')
+        raise CompareException(CompareException.INVALID_API_NAME_ERROR)
+
     if Const.PARAMS_GRAD in name.split(Const.SEP):
         return name.split(Const.PARAMS_GRAD)[0], Const.PARAMS_GRAD
 
     split = re.split(Const.REGEX_FORWARD_BACKWARD, name)
+    if len(split) < 3:
+        logger.error(f'Invalid name string: {name}, can not be split by forward/backward, please check.')
+        raise CompareException(CompareException.INVALID_API_NAME_ERROR)
     api = f'{split[0]}.{split[1]}.'
     state_str = split[2]
     match = re.match(r'^(\d+\.)?(input|output|kwargs|parameters)\..+$', state_str)