mindstudio-probe 1.0.1__py3-none-any.whl → 1.0.3__py3-none-any.whl

msprobe/core/compare/acc_compare.py

@@ -0,0 +1,299 @@
+import multiprocessing
+import os
+import json
+import pandas as pd
+from msprobe.core.common.file_check import FileOpen
+from msprobe.core.common.const import CompareConst, Const
+from msprobe.core.common.exceptions import FileCheckException
+from msprobe.core.common.log import logger
+from msprobe.core.common.utils import add_time_with_xlsx, CompareException, check_file_not_exists
+from msprobe.core.compare.check import check_graph_mode, check_struct_match, fuzzy_check_op
+from msprobe.core.compare.highlight import find_compare_result_error_rows, highlight_rows_xlsx
+from msprobe.core.compare.utils import read_op, merge_tensor, CompareException, get_un_match_accuracy, get_accuracy
+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.advisor.advisor import Advisor
+
+
+class Comparator:
+    
+    def __init__(self):
+        pass
+    
+    @classmethod
+    def make_result_table(cls,result, md5_compare, summary_compare, stack_mode):
+        header = []
+        if md5_compare:
+            header = CompareConst.MD5_COMPARE_RESULT_HEADER[:]
+        elif summary_compare:
+            header = CompareConst.SUMMARY_COMPARE_RESULT_HEADER[:]
+        else:
+            header = CompareConst.COMPARE_RESULT_HEADER[:]
+
+        all_mode_bool = not (summary_compare or md5_compare)
+        if stack_mode:
+            if all_mode_bool:
+                header.append(CompareConst.STACK)
+                header.append(CompareConst.DATA_NAME)
+            else:
+                header.append(CompareConst.STACK)
+        else:
+            if all_mode_bool:
+                for row in result:
+                    del row[-2]
+                header.append(CompareConst.DATA_NAME)
+            else:
+                for row in result:
+                    del row[-1]
+        result_df = pd.DataFrame(result, columns=header)
+        return result_df   
+    
+    @classmethod
+    def gen_merge_list(self, json_data, op_name,stack_json_data, summary_compare, md5_compare):
+        op_data = json_data['data'][op_name]
+        op_parsed_list = read_op(op_data, op_name)
+        if op_name in stack_json_data:
+            op_parsed_list.append({'full_op_name': op_name, 'full_info': stack_json_data[op_name]})
+        else:
+            op_parsed_list.append({'full_op_name': op_name, 'full_info': None})
+            
+        merge_list = merge_tensor(op_parsed_list, summary_compare, md5_compare)
+        return merge_list
+    
+    def check_op(self, npu_dict, bench_dict, fuzzy_match):
+        a_op_name = npu_dict["op_name"]
+        b_op_name = bench_dict["op_name"]
+        graph_mode = check_graph_mode(a_op_name[0], b_op_name[0])
+        
+        frame_name = getattr(self,"frame_name")
+        if frame_name == "PTComparator":
+            from msprobe.pytorch.compare.match import graph_mapping
+            if graph_mode:
+                return graph_mapping.match(a_op_name[0], b_op_name[0])
+        struct_match = check_struct_match(npu_dict, bench_dict)
+        if not fuzzy_match:
+            return a_op_name == b_op_name and struct_match
+        is_match = True
+        try:
+            is_match = fuzzy_check_op(a_op_name, b_op_name)
+        except Exception as err:
+            logger.warning("%s and %s can not fuzzy match." % (a_op_name, b_op_name))
+            is_match = False
+        return is_match and struct_match
+    
+    def match_op(self, npu_queue, bench_queue, fuzzy_match):
+        for b_index, b_op in enumerate(bench_queue[0: -1]):
+            if self.check_op(npu_queue[-1], b_op, fuzzy_match):
+                return len(npu_queue) - 1, b_index
+        if self.check_op(npu_queue[-1], bench_queue[-1], fuzzy_match):
+            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):
+                return n_index, len(bench_queue) - 1
+        return -1, -1
+    
+    def compare_process(self, file_handles, stack_mode, fuzzy_match, summary_compare=False, md5_compare=False):
+        npu_json_handle, bench_json_handle, stack_json_handle = file_handles
+        npu_json_data = json.load(npu_json_handle)
+        bench_json_data = json.load(bench_json_handle)
+        stack_json_data = json.load(stack_json_handle)
+
+        if fuzzy_match:
+            logger.warning("This task uses fuzzy matching, which may affect the accuracy of the comparison.")
+
+        npu_ops_queue = []
+        bench_ops_queue = []
+        result = []
+
+        ops_npu_iter = iter(npu_json_data['data'])
+        ops_bench_iter = iter(bench_json_data['data'])
+        read_err_npu = True
+        read_err_bench = True
+        last_npu_ops_len = 0
+        last_bench_ops_len = 0
+
+        while True:
+            if not read_err_npu and not read_err_bench:
+                break
+            try:
+                last_npu_ops_len = len(npu_ops_queue)
+                op_name_npu = next(ops_npu_iter)
+                read_err_npu = True
+                npu_merge_list = self.gen_merge_list(npu_json_data,op_name_npu,stack_json_data,summary_compare,md5_compare)
+                if npu_merge_list:
+                    npu_ops_queue.append(npu_merge_list)
+            except StopIteration:
+                read_err_npu = False
+            try:
+                last_bench_ops_len = len(bench_ops_queue)
+                op_name_bench = next(ops_bench_iter)
+                bench_merge_list = self.gen_merge_list(bench_json_data,op_name_bench,stack_json_data,summary_compare,md5_compare)
+                if bench_merge_list:
+                    bench_ops_queue.append(bench_merge_list)
+            except StopIteration:
+                read_err_bench = False
+
+            # merge all boolean expressions
+            both_empty = not npu_ops_queue and not bench_ops_queue
+            no_change = (len(npu_ops_queue) == last_npu_ops_len) and (len(bench_ops_queue) == last_bench_ops_len)
+            if both_empty or no_change:
+                continue
+
+            # APIs in NPU and Bench models unconsistent judgment
+            if bool(npu_ops_queue) ^ bool(bench_ops_queue):
+                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)
+            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, md5_compare, summary_compare)
+            get_accuracy(result, n_match_data, b_match_data, summary_compare, md5_compare)
+            del npu_ops_queue[0: n_match_point + 1]
+            del bench_ops_queue[0: b_match_point + 1]
+        if npu_ops_queue:
+            for npu_data in npu_ops_queue:
+                get_un_match_accuracy(result, npu_data, md5_compare, summary_compare)
+                
+        result_df = self.make_result_table(result, md5_compare, summary_compare, stack_mode)
+        return result_df
+    
+    def compare_by_op(self, npu_op_name, bench_op_name, op_name_mapping_dict, input_param):
+        npu_bench_name_list = op_name_mapping_dict[npu_op_name]
+        data_name = npu_bench_name_list[1]
+        error_file, relative_err, error_flag = None, None, False
+        if data_name == '-1' or data_name == -1:  # 没有真实数据路径
+            n_value, b_value = CompareConst.READ_NONE, CompareConst.READ_NONE
+            error_flag = True
+        else:
+            try:
+                read_npy_data = getattr(self, "read_npy_data")
+                frame_name = getattr(self, "frame_name")
+                if frame_name == "MSComparator":
+                    n_value = read_npy_data(input_param.get("npu_dump_data_dir"), npu_op_name + Const.NUMPY_SUFFIX)
+                    if self.cross_frame:
+                        b_value = read_npy_data(input_param.get("bench_dump_data_dir"), bench_op_name + Const.PT_SUFFIX, load_pt_file=True)
+                    else:
+                        b_value = read_npy_data(input_param.get("bench_dump_data_dir"), bench_op_name + Const.NUMPY_SUFFIX)
+                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_op_name + Const.PT_SUFFIX)
+            except IOError as error:
+                error_file = error.filename
+                n_value, b_value = CompareConst.READ_NONE, CompareConst.READ_NONE
+                error_flag = True
+            except FileCheckException:
+                error_file = data_name
+                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)
+
+        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)
+
+        if 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):
+        """
+        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",
+                                "stack_path").
+            output_path (str): The path where the output Excel report will be saved.
+            **kwargs: Additional keyword arguments including:
+            - stack_mode (bool, optional): Enables stack mode comparison. Defaults to False.
+            - auto_analyze (bool, optional): If True, triggers automatic analysis after comparison. Defaults to True.
+            - suffix (str, optional): Suffix to append to the output file name. Defaults to ''.
+            - fuzzy_match (bool, optional): Enables fuzzy matching during comparison. Defaults to False.
+            - summary_compare (bool, optional): Enables summary comparison mode. Defaults to False.
+            - md5_compare (bool, optional): Enables MD5 comparison. Defaults to False.
+
+        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)
+        summary_compare = kwargs.get('summary_compare', False)
+        md5_compare = kwargs.get('md5_compare', False)
+
+        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)
+        check_file_not_exists(file_path)
+        highlight_dict = {'red_rows': [], 'yellow_rows': []}
+        
+        with FileOpen(input_parma.get("npu_json_path"), "r") as npu_json, \
+                FileOpen(input_parma.get("bench_json_path"), "r") as bench_json, \
+                FileOpen(input_parma.get("stack_json_path"), "r") as stack_json:
+            result_df = self.compare_process([npu_json, bench_json, stack_json], stack_mode, fuzzy_match,
+                                        summary_compare, md5_compare)
+
+        if not md5_compare and not summary_compare:
+            result_df = self._do_multi_process(input_parma, result_df)
+        find_compare_result_error_rows(result_df, highlight_dict, summary_compare, md5_compare)
+        highlight_rows_xlsx(result_df, highlight_dict, file_path)
+        if auto_analyze:
+            advisor = Advisor(result_df, output_path)
+            advisor.analysis()
+    
+    def compare_ops(self, idx, dump_path_dict, result_df, lock, input_param):
+        cos_result = []
+        max_err_result = []
+        max_relative_err_result = []
+        err_mess = []
+        one_thousand_err_ratio_result = []
+        five_thousand_err_ratio_result = []
+        is_print_compare_log = input_param.get("is_print_compare_log")
+        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)
+            if is_print_compare_log:
+                logger.info(
+                    "[{}] Compare result: cosine {}, max_abs_err {}, max_relative_err {}, {}, one_thousand_err_ratio {}, "
+                    "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)
+            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)
+
+        cr = ComparisonResult(
+            cos_result=cos_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
+        )
+
+        return _save_cmp_result(idx, cr, result_df, lock)   
+    
+    def _do_multi_process(self,input_parma, result_df):
+        try:
+            result_df = _handle_multi_process(self.compare_ops, input_parma, 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
+    

msprobe/core/compare/check.py

@@ -0,0 +1,95 @@
+from msprobe.core.common.log import logger
+from msprobe.core.compare.utils import rename_api 
+
+
+dtype_mapping = {
+    "Int8": "torch.int8",
+    "UInt8": "torch.uint8",
+    "Int16": "torch.int16",
+    "UInt16": "torch.uint16",
+    "Int32": "torch.int32",
+    "UInt32": "torch.uint32",
+    "Int64": "torch.int64",
+    "UInt64": "torch.uint64",
+    "Float16": "torch.float16",
+    "Float32": "torch.float32",
+    "Float64": "torch.float64",
+    "Bool": "torch.bool",
+    "BFloat16": "torch.bfloat16",
+    "Complex64": "torch.complex64",
+    "Complex128": "torch.complex128"
+    }
+
+
+def check_struct_match(npu_dict, bench_dict, cross_frame=False):
+    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")
+
+    if cross_frame:
+        npu_struct_in = [(dtype_mapping.get(item[0], item[0]), item[1]) for item in npu_struct_in]
+        npu_struct_out = [(dtype_mapping.get(item[0], item[0]), item[1]) for item in npu_struct_out]
+    is_match = npu_struct_in == bench_struct_in and npu_struct_out == bench_struct_out
+    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_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)
+        is_match = struct_in_is_match and struct_out_is_match
+    return is_match
+
+
+def check_type_shape_match(npu_struct, bench_struct):
+    shape_type_match = False
+    for npu_type_shape, bench_type_shape in zip(npu_struct, bench_struct):
+        npu_type = npu_type_shape[0]
+        npu_shape = npu_type_shape[1]
+        bench_type = bench_type_shape[0]
+        bench_shape = bench_type_shape[1]
+        shape_match = npu_shape == bench_shape
+        type_match = npu_type == bench_type
+        if not type_match:
+            ms_type=[["Float16", "Float32"], ["Float32", "Float16"],["Float16", "BFloat16"],["BFloat16", "Float16"]] 
+            torch_type=[["torch.float16", "torch.float32"], ["torch.float32", "torch.float16"],
+                                ["torch.float16", "torch.bfloat16"], ["torch.bfloat16", "torch.float16"]]
+            if ([npu_type, bench_type] in ms_type)or  ([npu_type, bench_type] in torch_type):                    
+                type_match = True
+            else:
+                type_match = False
+        shape_type_match = shape_match and type_match
+        if not shape_type_match:
+            return False
+    return shape_type_match
+
+
+def check_graph_mode(a_op_name, b_op_name):
+    if "Aten" in a_op_name and "Aten" not in b_op_name:
+        return True
+    if "Aten" not in a_op_name and "Aten" in b_op_name:
+        return True
+    return False
+
+
+def fuzzy_check_op(npu_name_list, bench_name_list):
+    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
+    for npu_name, bench_name in zip(npu_name_list, bench_name_list):
+        is_match = fuzzy_check_name(npu_name, bench_name)
+        if not is_match:
+            break
+    return is_match
+
+
+def fuzzy_check_name(npu_name, bench_name):
+    if "forward" in npu_name and "forward" in bench_name:
+        is_match = rename_api(npu_name, "forward") == rename_api(bench_name, "forward")
+    elif "backward" in npu_name and "backward" in bench_name:
+        is_match = rename_api(npu_name, "backward") == rename_api(bench_name, "backward")
+    else:
+        is_match = npu_name == bench_name
+    return is_match
+
+
+

msprobe/core/compare/compare_cli.py

@@ -0,0 +1,49 @@
+import json
+from msprobe.core.common.file_check import FileOpen, check_file_type
+from msprobe.core.common.const import FileCheckConst, Const
+from msprobe.core.common.utils import CompareException
+from msprobe.core.common.log import logger
+
+
+def compare_cli(args):
+    with FileOpen(args.input_path, "r") as file:
+        input_param = json.load(file)
+    npu_path = input_param.get("npu_path", None)
+    bench_path = input_param.get("bench_path", None)
+    frame_name = args.framework
+    auto_analyze = not args.compare_only
+    if frame_name == Const.PT_FRAMEWORK:
+        from msprobe.pytorch.compare.pt_compare import compare
+        from msprobe.pytorch.compare.distributed_compare import compare_distributed
+    else:
+        from msprobe.mindspore.compare.ms_compare import ms_compare
+        from msprobe.mindspore.compare.distributed_compare import ms_compare_distributed, ms_graph_compare
+    if check_file_type(npu_path) == FileCheckConst.FILE and check_file_type(bench_path) == FileCheckConst.FILE:
+        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 frame_name == Const.PT_FRAMEWORK:
+            compare(input_param, args.output_path, stack_mode=args.stack_mode, auto_analyze=auto_analyze,
+                    fuzzy_match=args.fuzzy_match)
+        else:
+            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,
+            }
+
+            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 = {"stack_mode": args.stack_mode, "auto_analyze": auto_analyze, "fuzzy_match": args.fuzzy_match}
+        if input_param.get("rank_id") is not None:
+            ms_graph_compare(input_param, args.output_path)
+            return
+        if frame_name == Const.PT_FRAMEWORK:
+            compare_distributed(npu_path, bench_path, args.output_path, **kwargs)
+        else:
+            ms_compare_distributed(npu_path, bench_path, args.output_path, **kwargs)
+    else:
+        logger.error("The npu_path and bench_path need to be of the same type.")
+        raise CompareException(CompareException.INVALID_COMPARE_MODE)

msprobe/core/compare/highlight.py

@@ -0,0 +1,222 @@
+import math
+import abc
+from collections import namedtuple
+import numpy as np
+import openpyxl
+from openpyxl.styles import PatternFill
+from msprobe.core.common.utils import get_header_index, save_workbook
+from msprobe.core.common.log import logger
+from msprobe.core.common.const import CompareConst
+
+
+class HighlightCheck(abc.ABC):
+    @abc.abstractmethod
+    def apply(self, info, color_columns, summary_compare):
+        raise NotImplementedError
+
+
+class CheckOrderMagnitude(HighlightCheck):
+    """检查Max diff的数量级差异"""
+    def apply(self, info, color_columns, summary_compare=True):
+        api_in, api_out, num = info
+        max_diff_index = get_header_index('Max diff' if summary_compare else 'MaxAbsErr', summary_compare)
+        if abs(api_in[max_diff_index]) > abs(api_out[max_diff_index]):
+            return
+        in_order = 0 if abs(api_in[max_diff_index]) < 1 else math.log10(abs(api_in[max_diff_index]))
+        out_order = 0 if abs(api_out[max_diff_index]) < 1 else math.log10(abs(api_out[max_diff_index]))
+        if out_order - in_order >= CompareConst.ORDER_MAGNITUDE_DIFF_YELLOW:
+            color_columns.yellow.append(num)
+
+
+class CheckOneThousandErrorRatio(HighlightCheck):
+    """检查千分误差比率"""
+    def apply(self, info, color_columns, summary_compare=True):
+        api_in, api_out, num = info
+        one_thousand_index = get_header_index('One Thousandth Err Ratio', summary_compare)
+        if not isinstance(api_in[one_thousand_index], (float, int)) or not isinstance(api_out[one_thousand_index], (float, int)):
+            return
+        if api_in[one_thousand_index] > CompareConst.ONE_THOUSAND_ERROR_IN_RED and api_out[one_thousand_index] < CompareConst.ONE_THOUSAND_ERROR_OUT_RED:
+            color_columns.red.append(num)
+        elif api_in[one_thousand_index] - api_out[one_thousand_index] > CompareConst.ONE_THOUSAND_ERROR_DIFF_YELLOW:
+            color_columns.yellow.append(num)
+
+
+class CheckCosineSimilarity(HighlightCheck):
+    """检查余弦相似度"""
+    def apply(self, info, color_columns, summary_compare=True):
+        api_in, api_out, num = info
+        cosine_index = get_header_index('Cosine', summary_compare)
+        if not isinstance(api_in[cosine_index], (float, int)) or not isinstance(api_out[cosine_index], (float, int)):
+            return
+        if api_in[cosine_index] - api_out[cosine_index] > CompareConst.COSINE_DIFF_YELLOW:
+            color_columns.yellow.append(num)
+
+
+class CheckMaxRelativeDiff(HighlightCheck):
+    """检查最大相对差异"""
+    def apply(self, info, color_columns, summary_compare=True):
+        api_in, api_out, num = info
+        max_diff_index = get_header_index('Max diff', summary_compare)
+        bench_max_index = get_header_index('Bench max', summary_compare)
+        input_max_relative_diff = np.abs(np.divide(api_in[max_diff_index], max(0.01, api_in[bench_max_index])))
+        output_max_relative_diff = np.abs(np.divide(api_out[max_diff_index], max(0.01, api_out[bench_max_index])))
+        if not isinstance(input_max_relative_diff, (float, int)) or not isinstance(output_max_relative_diff,
+                                                                                   (float, int)):
+            return
+        if output_max_relative_diff > CompareConst.MAX_RELATIVE_OUT_RED:
+            color_columns.red.append(num)
+        elif output_max_relative_diff > CompareConst.MAX_RELATIVE_OUT_YELLOW and input_max_relative_diff < CompareConst.MAX_RELATIVE_IN_YELLOW:
+            color_columns.yellow.append(num)
+
+
+class CheckOverflow(HighlightCheck):
+    """检查是否存在溢出"""
+    def apply(self, info, color_columns, summary_compare=True):
+        line, num = info
+        npu_max_index = get_header_index('NPU max', summary_compare)
+        npu_min_index = get_header_index('NPU min', summary_compare)
+        max_diff_index = get_header_index('Max diff' if summary_compare else 'MaxAbsErr', summary_compare)
+        if str(line[npu_max_index]) in CompareConst.OVERFLOW_LIST or str(
+                line[npu_min_index]) in CompareConst.OVERFLOW_LIST:
+            color_columns.red.append(num)
+            return
+        # check if Max_Diff > 1e+10
+        if isinstance(line[max_diff_index], (float, int)) and line[max_diff_index] > CompareConst.MAX_DIFF_RED:
+            color_columns.red.append(num)
+
+
+class HighlightRules:
+    """高亮规则集合，用于检查API的误差"""
+    # 适用于每行的规则
+    basic_rules = {
+        "check_overflow": CheckOverflow()
+    }
+
+    # 用于比较输入和输出的规则
+    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(),
+    }
+    
+
+def find_error_rows(result, last_len, n_num_input, highlight_dict, summary_compare=False, md5_compare=False):
+    """找到单个API中需要高亮的行"""
+    if md5_compare:
+        return
+    npu_max_index = get_header_index('NPU max', summary_compare)
+    bench_max_index = get_header_index('Bench max', summary_compare)
+    max_diff_index = get_header_index('Max diff' if summary_compare else 'MaxAbsErr', summary_compare)
+
+    red_lines, yellow_lines = [], []
+    LineInfo = namedtuple('LineInfo', ['line_data', 'num_pointer'])
+    ApiInfo = namedtuple('ApiInfo', ['api_input', 'api_output', 'num_pointer'])
+    ColorColumns = namedtuple('ColorColumns', ['red', 'yellow'])
+    color_columns = ColorColumns(red=red_lines, yellow=yellow_lines)
+
+    # 对单行API的输入或输出进行误差判断
+    for i, line in enumerate(result):
+        num = last_len + i
+        line_info = LineInfo(line_data=line, num_pointer=num)
+        for rule in HighlightRules.basic_rules.values():
+            rule.apply(line_info, color_columns, summary_compare)
+
+    # 对API的输出与输入比较，进行误差判断
+    for n, api_out in enumerate(result[n_num_input:len(result)]):
+        num = last_len + n_num_input + n
+        if num in red_lines:
+            continue
+        if not isinstance(api_out[npu_max_index], (float, int)) \
+                or not isinstance(api_out[bench_max_index], (float, int)) \
+                or not isinstance(api_out[max_diff_index], (float, int)):
+            continue
+        for _, api_in in enumerate(result[0:n_num_input]):
+            if not isinstance(api_in[npu_max_index], (float, int)) \
+                    or not isinstance(api_in[bench_max_index], (float, int)) \
+                    or not isinstance(api_in[max_diff_index], (float, int)):
+                continue
+
+            api_info = ApiInfo(api_input=api_in, api_output=api_out, num_pointer=num)
+            if summary_compare:
+                for rule in HighlightRules.summary_compare_rules.values():
+                    rule.apply(api_info, color_columns, summary_compare)
+            else:
+                for rule in HighlightRules.compare_rules.values():
+                    rule.apply(api_info, color_columns, summary_compare)
+
+    highlight_dict.get('red_rows', []).extend(list(set(red_lines)))
+    highlight_dict.get('yellow_rows', []).extend(list(set(yellow_lines) - set(red_lines)))
+
+
+def get_name_and_state(name):
+    """Get api/module name and state"""
+    if "input" in name:
+        api_name = name.split("input")[0]
+        state = "input"
+    else:
+        api_name = name.split("output")[0]
+        state = "output"
+    return api_name, state
+
+
+def find_compare_result_error_rows(result_df, highlight_dict, summary_compare, md5_compare):
+    """将dataframe根据API分组，并找到有误差的算子用于高亮"""
+    result = result_df.values
+    start, input_num, output_num, end = 0, 0, 0, len(result_df)
+    last_api_name, last_state = None, None
+    num, last_len = 0, 0
+    for res_i in result:
+        api_name, state = get_name_and_state(res_i[0])
+        if last_api_name:
+            if api_name == last_api_name:
+                if state == last_state:
+                    num += 1
+                else:
+                    input_num = num
+                    num, last_state = 1, state
+            else:
+                output_num = num
+                find_error_rows(result[start:start + input_num + output_num], start, input_num, highlight_dict,
+                                summary_compare, md5_compare)
+                num, last_api_name, last_state = 1, api_name, state
+                start += input_num + output_num
+                input_num, output_num = 1, 0
+        else:
+            num, last_api_name, last_state = 1, api_name, state
+    if state:
+        if state == "input":
+            input_num = num
+        else:
+            output_num = num
+        find_error_rows(result[start:start + input_num + output_num], start, input_num, highlight_dict, summary_compare, md5_compare)
+
+
+def highlight_rows_xlsx(result_df, highlight_dict, file_path):
+    """Write and highlight results in Excel"""
+    logger.info('Compare result is %s' % file_path)
+
+    wb = openpyxl.Workbook()
+    ws = wb.active
+
+    # write header
+    for j, col_name in enumerate(result_df.columns, start=1):
+        ws.cell(row=1, column=j, value=col_name)
+
+    for i, row in enumerate(result_df.iterrows(), start=2):
+        for j, value in enumerate(row[1], start=1):
+            if not isinstance(value, (float, int)):
+                value = f'{str(value)}\t' if str(value) in ('inf', '-inf', 'nan') else str(value)
+            ws.cell(row=i, column=j, value=f'{str(value)}\t' if str(value) in ('inf', '-inf', 'nan') else value)
+
+            if (i - 2) in highlight_dict['red_rows']:
+                ws.cell(row=i, column=j).fill = PatternFill(start_color=CompareConst.RED,
+                                                            end_color=CompareConst.RED, fill_type="solid")
+            elif (i - 2) in highlight_dict['yellow_rows']:
+                ws.cell(row=i, column=j).fill = PatternFill(start_color=CompareConst.YELLOW,
+                                                            end_color=CompareConst.YELLOW, fill_type="solid")
+
+    save_workbook(wb, file_path)