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

msprobe/core/compare/acc_compare.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 os
 import re
@@ -22,7 +23,6 @@ import numpy as np
 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, remove_path, create_directory, save_excel, save_json
@@ -31,21 +31,19 @@ from msprobe.core.common.utils import CompareException, add_time_with_xlsx, chec
     set_dump_path, get_dump_mode, check_compare_param, load_stack_json, get_file_type, add_time_with_json
 from msprobe.core.compare.check import check_dump_json_str, check_stack_json_str, cross_dtype_mapping, \
     check_configuration_param
-from msprobe.core.compare.utils import merge_tensor, print_compare_ends_info, read_op, set_stack_json_path, \
-    reorder_index
+from msprobe.core.compare.utils import print_compare_ends_info, read_op, set_stack_json_path, reorder_index
 from msprobe.core.compare.config import ModeConfig, MappingConfig, MappingDict
 from msprobe.core.compare.multiprocessing_compute import CompareRealData
-from msprobe.core.compare.highlight import HighLight
 from msprobe.core.compare.diff_analyze.first_diff_analyze import FirstDiffAnalyze
+from msprobe.core.compare.indicator_analysis.calculator import calculate_excel_result_df
+from msprobe.core.compare.stats_diff_calc import ValType, ALL_TYPES
 
 
 @dataclass
 class ComparisonConfig:
     dump_mode: str
     stack_mode: bool
-    auto_analyze: bool
     fuzzy_match: bool
-    highlight: bool
     data_mapping: dict
     suffix: str
     cell_mapping: dict
@@ -107,13 +105,16 @@ class Comparator:
         file_path = self.process_output_file(output_path, suffix, self.mode_config.compared_file_type)
 
         # initialize the compare result table and compare general data(name, dtype, shape, statistics/md5, etc.)
-        npu_json = input_param.get("npu_json_path")
-        bench_json = input_param.get("bench_json_path")
-        stack_json = input_param.get("stack_json_path")
+        npu_json = input_param.get("npu_path")
+        bench_json = input_param.get("bench_path")
+        stack_json = input_param.get("stack_path")
         parse_data = ParseData(self.mode_config, rank)  # load and parse json data
         npu_df, bench_df = parse_data.parse([npu_json, bench_json, stack_json])
+
+        logger.info("Matching APIs/Modules in progress...")
         result_df = self.compare_statistics(npu_df, bench_df)
-        if not result_df.values.tolist():
+        logger.info("APIs/Modules match done.")
+        if result_df.empty:
             logger.warning("Can`t match any op. No compare result file generated.")
             return
 
@@ -132,28 +133,21 @@ class Comparator:
 
         # compare real data
         if self.mode_config.dump_mode == Const.ALL:
+            logger.info("Compare real data in progress...")
             compare_real_data = CompareRealData(self.file_reader, self.mode_config, self.cross_frame)
             result_df = compare_real_data.do_multi_process(input_param, result_df)
+            logger.info("Compare real data done.")
 
-        # save result excel file
-        logger.info(f'Saving result excel file in progress. The file path is: {file_path}.')
-        if self.mode_config.highlight and len(result_df) <= CompareConst.MAX_EXCEL_LENGTH:
-            # highlight if not too long
-            highlight_dict = {"red_rows": set(), "yellow_rows": set(), "red_lines": [], "yellow_lines": []}
-            highlight = HighLight(self.mode_config, rank)
-            if self.mode_config.compared_file_type == Const.DUMP_JSON_FILE:
-                highlight.find_compare_result_error_rows(result_df, highlight_dict)
-            result_df.drop(columns=['state', 'api_origin_name'], inplace=True)  # 删除中间数据，两列不落盘
-            highlight.highlight_rows_xlsx(result_df, highlight_dict, file_path)
-        else:
-            # fallback to simple save without highlight
-            result_df.drop(columns=['state', 'api_origin_name'], inplace=True)  # 删除中间数据，两列不落盘
-            save_excel(file_path, result_df)
+        # calculate Indicators
+        logger.info("Calculating comparison indicators in progress...")
+        calculate_excel_result_df(result_df, self.mode_config.dump_mode)
+        result_df.drop(columns=['state', 'api_origin_name'], inplace=True)  # 删除中间数据，两列不落盘
+        logger.info("Comparison indicators calculation done.")
 
-        # output compare analysis suggestions
-        if self.mode_config.auto_analyze:
-            advisor = Advisor(result_df, output_path, suffix)
-            advisor.analysis()
+        # save result excel file
+        logger.info("Saving result excel file in progress...")
+        logger.info(f"The result excel file path is: {file_path}.")
+        save_excel(file_path, result_df)
 
         print_compare_ends_info()
 
@@ -164,6 +158,10 @@ class Comparator:
         # create new columns for compare op_name and shape
         # process npu_df's COMPARE_KEY whether same or different framework
         process_df = ProcessDf(self.mode_config, self.mapping_config, self.mapping_dict)
+        # 处理重计算对应的backward的序号。反向重计算序号调整属于精确匹配，与模糊匹配互斥。
+        if not self.mode_config.fuzzy_match:
+            npu_df = process_df.update_backward_call(npu_df)
+            bench_df = process_df.update_backward_call(bench_df)
         npu_df, bench_df = process_df.process_compare_key_and_shape(npu_df, bench_df)
 
         # match npu and bench, match_result contains both npu_info and bench_info
@@ -190,6 +188,33 @@ class ParseData:
         self.mode_config = mode_config
         self.rank = rank
 
+    @staticmethod
+    def get_direction_and_call_direction(data_name):
+        parts = data_name.split(Const.SEP)
+        if len(parts) < 2:
+            return None, None
+
+        last = parts[-1]
+        second_last = parts[-2]
+
+        # direction 判断
+        if Const.BACKWARD in (last, second_last):
+            direction = Const.BACKWARD
+        elif Const.FORWARD in (last, second_last):
+            direction = Const.FORWARD
+        else:
+            return None, None
+
+        # call_direction 永远取最后两个
+        call_direction = Const.SEP.join((second_last, last))
+
+        return direction, call_direction
+
+    @staticmethod
+    def get_op_no_number(data_name):
+        parts = data_name.split(Const.SEP)
+        return Const.SEP.join(parts[:-2]) if len(parts) > 2 else ''
+
     def parse(self, file_list):
         npu_json_path, bench_json_path, stack_json_path = file_list
         npu_json_data = load_json(npu_json_path)
@@ -202,7 +227,7 @@ class ParseData:
 
         return npu_df, bench_df
 
-    def gen_data_df(self, data_json, stack_json_data, device: str):
+    def init_result(self):
         result = {
             CompareConst.OP_NAME: [],
             Const.DTYPE: [],
@@ -211,57 +236,90 @@ class ParseData:
             Const.STACK_INFO: [],
             Const.STATE: [],
             Const.API_ORIGIN_NAME: [],
-            Const.REQ_GRAD: []
+            Const.REQ_GRAD: [],
+            Const.DIRECTION: [],  # 目前三种选择：'forward', 'backward', None
+            Const.CALL_DIRECTION: [],
+            Const.OP_NO_NUMBER: [],  # 删除调用序号
+            Const.BACKWARD_CALL_ORDER: [],  # 计算op反向调用顺序，初始化为0
+            Const.SUFFIX: []
         }
         if self.mode_config.dump_mode == Const.ALL:
             result[Const.DATA_NAME] = []
         elif self.mode_config.dump_mode == Const.MD5:
             result[Const.MD5] = []
+        return result
+
+    def create_progress_bar(self, api_nums: int, device: str):
+        desc = f'{device} API/Module Read Progress'
+        if self.rank:
+            desc = f'[{self.rank}]' + desc
+        return tqdm(total=api_nums, desc=desc, unit="api/module", ncols=100)
+
+    def gen_data_df(self, data_json, stack_json_data, device: str):
+        result = self.init_result()
+        op_backward_count = defaultdict(int)  # 记录backward调用次数，用于后续调用序更新
 
         apis_data = data_json.get('data', None)
         if not apis_data:
             logger.warning('No APIs found in dump.json.')
             return pd.DataFrame(result)
 
-        api_nums = len(apis_data)
-        default_bar_desc = f'{device} API/Module Read Progress'
-        bar_desc_add_rank = f'[{self.rank}]' + default_bar_desc if self.rank else default_bar_desc
-        progress_bar = tqdm(total=api_nums, desc=bar_desc_add_rank, unit="api/module", ncols=100)
+        progress_bar = self.create_progress_bar(len(apis_data), device)
 
         # 从json中循环解析API数据，遍历所有API
         for data_name in apis_data:
             check_op_str_pattern_valid(data_name)
+
             op_parsed_list = self.gen_merge_list(data_json, data_name, stack_json_data)
             if not op_parsed_list:
+                progress_bar.update(1)
+                continue
+
+            op_no_number = self.get_op_no_number(data_name)
+            if op_no_number == '':
+                progress_bar.update(1)
                 continue
+
+            direction, call_direction = self.get_direction_and_call_direction(data_name)
+            backward_call_order = op_backward_count.get(op_no_number, 0)
+            if direction == Const.BACKWARD:
+                op_backward_count[op_no_number] += 1
+
             reordered_index_list = reorder_index(op_parsed_list)
+
+            stack_info = op_parsed_list[-1].get('full_info') if self.mode_config.stack_mode else None
+
             for i, index in enumerate(reordered_index_list):
                 op_item = op_parsed_list[index]
+                summary_data = [
+                    str(op_item.get(key)) if op_item.get(key) is None else op_item.get(key)
+                    for key in Const.SUMMARY_METRICS_LIST
+                ]
+                full_op_name = op_item.get(Const.FULL_OP_NAME)
+                suffix = full_op_name.replace(data_name, '')
 
                 # common key
-                result[CompareConst.OP_NAME].append(op_item.get('full_op_name'))
+                result[CompareConst.OP_NAME].append(full_op_name)
                 result[Const.DTYPE].append(op_item.get(Const.DTYPE))
                 result[Const.SHAPE].append(op_item.get(Const.SHAPE))
                 result[Const.STATE].append(op_item.get(Const.STATE))
                 result[Const.REQ_GRAD].append(op_item.get(Const.REQ_GRAD))
                 result[Const.API_ORIGIN_NAME].append(data_name)
-                summary_data = [
-                    str(op_item.get(key)) if op_item.get(key) is None else op_item.get(key)
-                    for key in Const.SUMMARY_METRICS_LIST
-                ]
                 result[Const.SUMMARY].append(summary_data)
+                result[Const.DIRECTION].append(direction)
+                result[Const.CALL_DIRECTION].append(call_direction)
+                result[Const.OP_NO_NUMBER].append(op_no_number)
+                result[Const.BACKWARD_CALL_ORDER].append(backward_call_order)
+                result[Const.SUFFIX].append(suffix)
 
                 # dump_mode differ key
                 if self.mode_config.dump_mode == Const.MD5:
-                    result[Const.MD5].append(op_parsed_list[index].get(Const.MD5))
+                    result[Const.MD5].append(op_item.get(Const.MD5))
                 if self.mode_config.dump_mode == Const.ALL:
                     result[Const.DATA_NAME].append(op_item.get(Const.DATA_NAME))
 
                 # mode_config stack_mode addition key
-                if i == 0 and self.mode_config.stack_mode:
-                    result[Const.STACK_INFO].append(op_parsed_list[-1].get('full_info'))
-                else:
-                    result[Const.STACK_INFO].append(None)
+                result[Const.STACK_INFO].append(stack_info if i == 0 else None)
 
                 # mode_config first_diff_analyze addition key
                 if self.mode_config.first_diff_analyze:
@@ -307,10 +365,64 @@ class ProcessDf:
             raise CompareException(CompareException.INDEX_OUT_OF_BOUNDS_ERROR) from error
         return api_name
 
+    @staticmethod
+    def update_backward_call(cmp_df):
+        # ===============================
+        # Step 1: 拆 call_direction 的两部分
+        # ===============================
+        cd_parts = cmp_df[Const.CALL_DIRECTION].str.rsplit(Const.SEP, n=1, expand=True)
+        cd_parts.columns = ["cd_head", "cd_tail"]
+
+        head_is_digit = cd_parts["cd_head"].str.isdigit()
+        tail_is_digit = cd_parts["cd_tail"].str.isdigit()
+        is_backward = cmp_df[Const.DIRECTION] == Const.BACKWARD
+
+        # ===============================
+        # Step 2: 矢量化替换 backward_call_order
+        # ===============================
+        mask_head = is_backward & head_is_digit
+        mask_tail = is_backward & tail_is_digit
+        update_mask = mask_head | mask_tail
+
+        cd_parts.loc[mask_head, "cd_head"] = (
+            cmp_df.loc[mask_head, Const.BACKWARD_CALL_ORDER].astype(str)
+        )
+        cd_parts.loc[mask_tail, "cd_tail"] = (
+            cmp_df.loc[mask_tail, Const.BACKWARD_CALL_ORDER].astype(str)
+        )
+
+        # 只更新需要更新的 call_direction
+        cmp_df.loc[update_mask, Const.CALL_DIRECTION] = (
+                cd_parts.loc[update_mask, "cd_head"]
+                + Const.SEP
+                + cd_parts.loc[update_mask, "cd_tail"]
+        )
+
+        # ===============================
+        # Step 3: 初始化 + 局部更新 OP_NAME_UPDATE
+        # ===============================
+        # 默认保持原值
+        cmp_df[CompareConst.OP_NAME_UPDATE] = cmp_df[CompareConst.OP_NAME]
+
+        # 只更新命中的行
+        cmp_df.loc[update_mask, CompareConst.OP_NAME_UPDATE] = (
+                cmp_df.loc[update_mask, Const.OP_NO_NUMBER]
+                + Const.SEP
+                + cmp_df.loc[update_mask, Const.CALL_DIRECTION]
+                + cmp_df.loc[update_mask, Const.SUFFIX]
+        )
+
+        return cmp_df
+
     def process_compare_key_and_shape(self, npu_df, bench_df):
         npu_df = self.assign_npu_df_compare_key(npu_df, bench_df)
         npu_df[CompareConst.CMP_SHAPE] = npu_df[Const.SHAPE]
-        bench_df[CompareConst.CMP_KEY] = bench_df[CompareConst.OP_NAME]
+        bench_cmp_key = (
+            bench_df[CompareConst.OP_NAME_UPDATE]
+            if not self.mode_config.fuzzy_match
+            else bench_df[CompareConst.OP_NAME]
+        )
+        bench_df[CompareConst.CMP_KEY] = bench_cmp_key
         bench_df[CompareConst.CMP_SHAPE] = bench_df[Const.SHAPE]
         return npu_df, bench_df
 
@@ -336,7 +448,12 @@ class ProcessDf:
         elif self.mapping_config.data_mapping:
             npu_df[CompareConst.CMP_KEY] = npu_df[CompareConst.OP_NAME].apply(self.process_data_mapping)
         else:
-            npu_df[CompareConst.CMP_KEY] = npu_df[CompareConst.OP_NAME]
+            cmp_key = (
+                npu_df[CompareConst.OP_NAME_UPDATE]
+                if not self.mode_config.fuzzy_match
+                else npu_df[CompareConst.OP_NAME]
+            )
+            npu_df[CompareConst.CMP_KEY] = cmp_key
         return npu_df
 
     def process_internal_api_mapping(self, npu_op_name):
@@ -427,9 +544,22 @@ class ProcessDf:
         if self.mapping_dict.cell_mapping_dict:
             # get cell name & class name from op_name
             # Cell.fc1.Dense.forward.0.input.0
+            # npu_op_name.split(Const.SEP, 1)[-1] 表示Module或Cell字段后面的部分
             cell_name = re.split(r'\.(?:forward|backward|parameters_grad)\.', npu_op_name.split(Const.SEP, 1)[-1])[0]
+
+            # 1. 精确整段匹配（保持原行为）
             if cell_name in self.mapping_dict.cell_mapping_dict:
-                npu_op_name = npu_op_name.replace(cell_name, self.mapping_dict.cell_mapping_dict[cell_name], 1)
+                new_cell_name = self.mapping_dict.cell_mapping_dict[cell_name]
+            # 2. 兜底：简单字符串替换（不做任何限制）
+            else:
+                new_cell_name = cell_name
+                for target_name, golden_name in self.mapping_dict.cell_mapping_dict.items():
+                    if target_name in new_cell_name:
+                        new_cell_name = new_cell_name.replace(target_name, golden_name, 1)
+            # 3. 应用替换
+            if new_cell_name != cell_name:
+                npu_op_name = npu_op_name.replace(cell_name, new_cell_name, 1)
+
         return npu_op_name
 
     def process_data_mapping(self, npu_op_name):
@@ -482,8 +612,7 @@ class Match:
     def check_op_item(self, npu_op_item, bench_op_item):
         name_match = self.rename_api(npu_op_item[CompareConst.CMP_KEY]) == self.rename_api(
             bench_op_item[CompareConst.CMP_KEY])
-        shape_match = npu_op_item[CompareConst.CMP_SHAPE] == bench_op_item[CompareConst.CMP_SHAPE]
-        if name_match and shape_match:
+        if name_match:
             return True
         else:
             npu_op_name = npu_op_item[CompareConst.OP_NAME]
@@ -507,9 +636,13 @@ class Match:
             match_result = match_result.sort_values(CompareConst.OP_NAME_X).reset_index(drop=True)
             match_result[CompareConst.OP_NAME_X] = match_result[CompareConst.OP_NAME_X].astype('object')
         elif not self.mode_config.fuzzy_match:
-            match_result = pd.merge(npu_df, bench_df, on=[CompareConst.CMP_KEY, CompareConst.CMP_SHAPE],
+            match_result = pd.merge(npu_df, bench_df, on=[CompareConst.CMP_KEY],
                                     how='outer')
         else:
+            drop_list = [Const.DIRECTION, Const.CALL_DIRECTION, Const.OP_NO_NUMBER, Const.BACKWARD_CALL_ORDER,
+                         Const.SUFFIX]
+            npu_df.drop(columns=drop_list, inplace=True)
+            bench_df.drop(columns=drop_list, inplace=True)
             match_result = self.process_fuzzy_match(npu_df, bench_df)
         return match_result
 
@@ -675,52 +808,187 @@ class CreateTable:
 class CalcStatsDiff:
     def __init__(self, mode_config: ModeConfig):
         self.mode_config = mode_config
+        self.rules = None
+        self.build_rules()
+        self.DEFAULT_RULE = self.static_diff(CompareConst.N_A)
 
     @staticmethod
-    def type_check(val):
+    def is_same_value(a: pd.Series, b: pd.Series) -> pd.Series:
         """
-        检查是否为数值或字符串形式的nan, 如果是返回True
+        检查是否相等
+        """
+        return a.astype(str).eq(b.astype(str))
+
+    @staticmethod
+    def is_number(val: pd.Series) -> pd.Series:
+        """
+        检查是否为有效的数值，并排除布尔类型
         """
-        check_series = pd.Series(False, index=val.index)
         val_str = val.astype(str)
-        check_series[pd.to_numeric(val_str, errors='coerce').notna() | val_str.str.lower().eq('nan')] = True
-        return check_series
+        mask_bool = val_str.str.lower().eq('true') | val_str.str.lower().eq('false')
+        mask_numeric = pd.to_numeric(val, errors='coerce').notna()
+        return mask_numeric & ~mask_bool
+
+    @staticmethod
+    def is_nan(val: pd.Series) -> pd.Series:
+        """
+        检查是否为字符串形式的 'nan' (包括大小写) 或实际的 NaN
+        """
+        val_str = val.astype(str)
+        return val.isna() | val_str.str.lower().eq('nan')
+
+    @staticmethod
+    def is_inf(val: pd.Series) -> pd.Series:
+        """
+        检查是否为正无穷 (inf)
+        """
+        val_str = val.astype(str)
+        return (val == np.inf) | val_str.str.lower().eq('inf')
+
+    @staticmethod
+    def is_neg_inf(val: pd.Series) -> pd.Series:
+        """
+        检查是否为负无穷 (-inf)
+        """
+        val_str = val.astype(str)
+        return (val == -np.inf) | val_str.str.lower().eq('-inf')
+
+    @staticmethod
+    def is_device(val: pd.Series) -> pd.Series:
+        """
+        检查是否包含 'npu', 'cpu' 或 'cuda' 字符串
+        """
+        return val.astype(str).str.contains('npu|cpu|cuda', case=False, na=False)
+
+    @staticmethod
+    def is_na(val: pd.Series) -> pd.Series:
+        """
+        检查是否为 N/A
+        """
+        return val.astype(str).eq(CompareConst.N_A)
+
+    @staticmethod
+    def rule_num_num(npu_num: pd.Series, bench_num: pd.Series):
+        diff = npu_num - bench_num
+        rel = pd.Series(CompareConst.INF, index=diff.index)
+        mask_nonzero = bench_num != 0
+        rel.loc[mask_nonzero] = (diff[mask_nonzero] / bench_num[mask_nonzero] * 100).abs().astype(str) + "%"
+        return diff, rel
+
+    @staticmethod
+    def static_diff(diff: str, rel=None):
+        if rel is None:
+            rel = diff
+        return diff, rel
 
     @staticmethod
     def get_number(val):
         return pd.to_numeric(val.astype(str), errors='coerce')
 
-    def calc_summary_diff(self, result_df, cond_no_bench, stats_index: str):
+    def build_rules(self):
+        """
+        创建npu、bench不相等规则
+        """
+        # NUM × NUM
+        self.rules = {(ValType.NUM, ValType.NUM): self.rule_num_num}
+
+        # ---------- NAN 规则 ----------
+        nan_rule = self.static_diff(CompareConst.NAN)
+        nan_range = {ValType.NUM, ValType.NAN, ValType.INF, ValType.NEG_INF}
+        for t in nan_range:
+            self.rules[(ValType.NAN, t)] = nan_rule
+            self.rules[(t, ValType.NAN)] = nan_rule
+
+        # ---------- INF / -INF 规则 ----------
+        pos_inf = self.static_diff(CompareConst.INF)
+        neg_inf = self.static_diff(CompareConst.NEG_INF)
+        # INF / -INF 在左
+        for r in (ValType.NUM, ValType.NEG_INF):
+            self.rules[(ValType.INF, r)] = pos_inf
+        for r in (ValType.NUM, ValType.INF):
+            self.rules[(ValType.NEG_INF, r)] = neg_inf
+        # INF / -INF 在右
+        self.rules[(ValType.NUM, ValType.INF)] = neg_inf
+        self.rules[(ValType.NUM, ValType.NEG_INF)] = pos_inf
+
+        # ---------- N/A 规则 ----------
+        na_rule = self.static_diff(CompareConst.N_A)
+        na_range = {ValType.NUM, ValType.NAN, ValType.INF, ValType.NEG_INF, ValType.DEVICE, ValType.NA, ValType.OTHER}
+        for t in na_range:
+            self.rules[(ValType.NA, t)] = na_rule
+            self.rules[(t, ValType.NA)] = na_rule
+
+        # ---------- DEVICE / OTHER 规则 ----------
+        # 给diff，都是device给N/A
+        diff_rule = self.static_diff(CompareConst.DIFF_FLAG)
+        diff_range = {ValType.NUM, ValType.NAN, ValType.INF, ValType.NEG_INF, ValType.DEVICE, ValType.OTHER}
+        for t in diff_range:
+            self.rules[(ValType.DEVICE, t)] = diff_rule
+            self.rules[(t, ValType.DEVICE)] = diff_rule
+            self.rules[(ValType.OTHER, t)] = diff_rule
+            self.rules[(t, ValType.OTHER)] = diff_rule
+        self.rules[(ValType.DEVICE, ValType.DEVICE)] = na_rule
+
+    def classify(self, val: pd.Series) -> pd.Series:
+        result_values = np.select(
+            [
+                self.is_nan(val),
+                self.is_inf(val),
+                self.is_neg_inf(val),
+                self.is_number(val),  # 'inf', '-inf'会被pandas认为是number，所以放在inf/-inf判断后面
+                self.is_device(val),
+                self.is_na(val),
+            ],
+            [
+                ValType.NAN.value,
+                ValType.INF.value,
+                ValType.NEG_INF.value,
+                ValType.NUM.value,
+                ValType.DEVICE.value,
+                ValType.NA.value,
+            ],
+            default=ValType.OTHER.value,
+        )
+        val_to_enum = {t.value: t for t in ValType}
+        result_series = pd.Series(result_values, index=val.index).map(val_to_enum)
+        return result_series
+
+    def calc_summary_diff(self, result_df, stats_index: str):
         npu_val = result_df['NPU ' + stats_index]
         bench_val = result_df['Bench ' + stats_index]
         diff_name = stats_index.capitalize() + ' diff'
         rel_err_name = ('norm' if stats_index == 'l2norm' else stats_index).capitalize() + 'RelativeErr'
 
-        # npu、bench中统计量均为数字或nan
-        cond_num_nan = self.type_check(npu_val) & self.type_check(bench_val)
+        # ---------------------- 初始化 ----------------------
+        result_df[[diff_name, rel_err_name]] = CompareConst.N_A
 
-        # 如果统计量不是数字或nan，就赋值统计量差异为N/A
-        result_df.loc[~cond_num_nan, [diff_name, rel_err_name]] = CompareConst.N_A
-        cond_valid_stat = ~cond_no_bench & cond_num_nan  # 有效统计条件：bench_name不是N/A，并且NPU和bench的统计量都是数字或nan
-        result_df.loc[cond_valid_stat, diff_name] = self.get_number(npu_val) - self.get_number(bench_val)
+        # ---------------------- 基础 mask ----------------------
+        npu_num = self.get_number(npu_val)
+        bench_num = self.get_number(bench_val)
+        mask_equal = self.is_same_value(npu_val, bench_val)
+        mask_unequal = ~mask_equal
 
-        cond_diff_nan = result_df[diff_name].isna()  # 统计量差异是nan
-        cond_nan_diff = cond_valid_stat & cond_diff_nan
-        result_df.loc[cond_nan_diff, [diff_name, rel_err_name]] = CompareConst.NAN
+        # ---------------------- npu, bench统计量相等 ----------------------
+        result_df.loc[mask_equal, [diff_name, rel_err_name]] = 0
 
-        cond_not_nan_diff = cond_valid_stat & ~cond_diff_nan
-        condition_pt_zero = self.get_number(bench_val) == 0
-        result_df.loc[cond_not_nan_diff & condition_pt_zero, rel_err_name] = CompareConst.N_A
+        # ---------------------- npu, bench统计量不相等 ----------------------
+        npu_type = self.classify(npu_val)
+        bench_type = self.classify(bench_val)
+        for t1 in ALL_TYPES:
+            for t2 in ALL_TYPES:
+                mask = mask_unequal & (npu_type == t1) & (bench_type == t2)
+                if not mask.any():
+                    continue
 
-        # 相对误差转成百分比字符串
-        cond_ref_err = cond_not_nan_diff & ~condition_pt_zero
-        result_df.loc[cond_ref_err, rel_err_name] = (
-                result_df.loc[cond_ref_err, diff_name] / bench_val[cond_ref_err].astype(float) * 100)
-        result_df.loc[cond_ref_err, rel_err_name] = (result_df.loc[cond_ref_err, rel_err_name].abs().astype(str) + '%')
+                rule = self.rules.get((t1, t2), self.DEFAULT_RULE)
 
-        magnitude = self.get_number(result_df[diff_name]).abs() / (pd.Series(
-            np.maximum(self.get_number(npu_val), self.get_number(bench_val))).abs() + CompareConst.EPSILON)
-        return magnitude > CompareConst.MAGNITUDE
+                if callable(rule):
+                    diff, rel = rule(npu_num[mask], bench_num[mask])
+                else:
+                    diff, rel = rule
+
+                result_df.loc[mask, diff_name] = diff
+                result_df.loc[mask, rel_err_name] = rel
 
     def calc_accuracy(self, result_df, header):
         # bench name N/A represents no bench data, err_msg adds "No bench data matched."
@@ -734,14 +1002,9 @@ class CalcStatsDiff:
             result_df.loc[condition_md5_equal, CompareConst.RESULT] = CompareConst.PASS
             result_df.loc[~condition_md5_equal & ~condition_no_bench, CompareConst.RESULT] = CompareConst.DIFF
         elif self.mode_config.first_diff_analyze or self.mode_config.dump_mode == Const.SUMMARY:
-            warning_list = [
-                self.calc_summary_diff(result_df, condition_no_bench, stats_index)
-                for stats_index in ['max', 'min', 'mean', 'l2norm']
-            ]
-            warning_flag = pd.DataFrame(warning_list).any()
+            for stats_index in ['max', 'min', 'mean', 'l2norm']:
+                self.calc_summary_diff(result_df, stats_index)
             result_df.loc[~condition_no_bench, [CompareConst.RESULT, CompareConst.ERROR_MESSAGE]] = ''
-            result_df.loc[warning_flag, CompareConst.RESULT] = CompareConst.WARNING
-            result_df.loc[warning_flag, CompareConst.ERROR_MESSAGE] = 'Need double check api accuracy. '
             result_df.loc[~condition_req_grad_consist, CompareConst.ERROR_MESSAGE] += 'Requires_grad inconsistent. '
         else:
             fill_cols = [CompareConst.COSINE, CompareConst.EUC_DIST,
@@ -749,7 +1012,6 @@ class CalcStatsDiff:
                          CompareConst.ONE_THOUSANDTH_ERR_RATIO, CompareConst.FIVE_THOUSANDTHS_ERR_RATIO,
                          CompareConst.ERROR_MESSAGE]
             result_df.loc[~condition_no_bench, fill_cols] = ''  # 默认填充'', df默认省缺值为nan，不便后续处理，容易出现意外情况
-            result_df.loc[~condition_no_bench, CompareConst.ACCURACY] = CompareConst.ACCURACY_CHECK_YES
             result_df.loc[~condition_req_grad_consist, CompareConst.ERROR_MESSAGE] = 'Requires_grad inconsistent. '
 
         return result_df[header]
@@ -761,9 +1023,7 @@ def setup_comparison(input_param, output_path, **kwargs) -> ComparisonConfig:
         config = ComparisonConfig(
             dump_mode='',
             stack_mode=False,
-            auto_analyze=kwargs.get('auto_analyze', True),
             fuzzy_match=kwargs.get('fuzzy_match', False),
-            highlight=kwargs.get('highlight', False),
             data_mapping=kwargs.get('data_mapping', {}),
             suffix=kwargs.get('suffix', ''),
             cell_mapping=kwargs.get('cell_mapping', {}),
@@ -771,18 +1031,15 @@ def setup_comparison(input_param, output_path, **kwargs) -> ComparisonConfig:
             layer_mapping=kwargs.get('layer_mapping', {}),
             first_diff_analyze=kwargs.get('first_diff_analyze', False),
             compared_file_type='',
-            is_print_compare_log=input_param.get('is_print_compare_log', True)
+            is_print_compare_log=kwargs.get('is_print_compare_log', False)
         )
 
         set_dump_path(input_param)
         config.dump_mode = get_dump_mode(input_param)
-        config.compared_file_type = get_file_type(input_param.get("npu_json_path", None))
+        config.compared_file_type = get_file_type(input_param.get("npu_path", None))
 
-        # set stack_mode and set "stack_json_path" in input_param
-        if 'stack_json_path' in input_param:
-            config.stack_mode = kwargs.get('stack_mode', False)
-        else:
-            config.stack_mode = set_stack_json_path(input_param)
+        # set stack_mode and set "stack_path" in input_param
+        config.stack_mode, input_param = set_stack_json_path(input_param)
 
         check_configuration_param(config)
         create_directory(output_path)