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

msprobe/core/compare/indicator_analysis/algorithm.py

@@ -0,0 +1,363 @@
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
+#
+# 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://license.coscl.org.cn/MulanPSL2
+#
+# 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.
+# -------------------------------------------------------------------------
+
+
+from abc import ABC, abstractmethod
+from msprobe.core.compare.indicator_analysis.api_data import ApiData
+from msprobe.core.compare.indicator_analysis.utils import is_inf_or_nan, str2float, ResultLevel, IgnoreInfo, \
+    get_data_list_by_ignore_info
+from msprobe.core.common.const import CompareConst
+
+
+class BaseAlgorithm(ABC):
+    """比对算法基类"""
+
+    @abstractmethod
+    def run(self, api_data: ApiData, ignore_info: IgnoreInfo):
+        """
+        算法执行接口
+        :param api_data: 结构化的 API 数据
+        :param ignore_info: 当前 API 数据需要忽略的指标信息
+        """
+        pass
+
+
+class InfNanErrChecker(BaseAlgorithm):
+    """
+    适用于真实数据模式、统计数据模式
+    一个 API 或模块的 NPU 的最大值或最小值中存在 nan/inf/-inf 标记为 error
+    但如果 bench 侧也有相同现象，则忽略
+    """
+
+    def __init__(self):
+        self.result_level = ResultLevel.ERROR
+        self.err_msg = f'{self.result_level.value}: There is nan/inf/-inf in the maximum or minimum value of NPU.'
+
+    def run(self, api_data: ApiData, ignore_info: IgnoreInfo):
+        data_lists = get_data_list_by_ignore_info(api_data, ignore_info)
+        if not data_lists:
+            return
+
+        for data_list in data_lists:
+            bench_max = api_data.get_data_by_header(CompareConst.BENCH_MAX, data_list)
+            bench_min = api_data.get_data_by_header(CompareConst.BENCH_MIN, data_list)
+
+            if is_inf_or_nan(bench_max) or is_inf_or_nan(bench_min):
+                continue
+
+            npu_max = api_data.get_data_by_header(CompareConst.NPU_MAX, data_list)
+            npu_min = api_data.get_data_by_header(CompareConst.NPU_MIN, data_list)
+
+            if is_inf_or_nan(npu_max) or is_inf_or_nan(npu_min):
+                api_data.set_result(data_list, self.result_level)
+                api_data.set_err_msg(data_list, self.err_msg)
+
+
+class RelativeErrChecker(BaseAlgorithm):
+    """
+    适用于统计数据模式
+    指标需要结合输入和输出共同计算得到
+    一个 API 或模块的 input 的相对误差 < 0.1 且 output 的相对误差 > 0.5，默认选取norm relative err观测， 标记为 error
+    """
+
+    def __init__(self):
+        self.in_threshold = 0.1
+        self.out_threshold = 0.5
+        self.result_level = ResultLevel.ERROR
+        self.err_msg = (f'{self.result_level.value}: The {CompareConst.NORM_RELATIVE_ERR} of output '
+                        f'is greater than {self.out_threshold}.')
+
+    def run(self, api_data: ApiData, ignore_info: IgnoreInfo):
+        if ignore_info in [IgnoreInfo.ALL_IGNORE, IgnoreInfo.INPUT_IGNORE]:
+            return
+
+        norm_relative_err_max = abs(api_data.get_min_or_max_value(CompareConst.NORM_RELATIVE_ERR, is_min=False))
+
+        if norm_relative_err_max < self.in_threshold:
+            for data_list in api_data.output_data:
+                norm_relative_err = str2float(api_data.get_data_by_header(CompareConst.NORM_RELATIVE_ERR, data_list))
+                if abs(norm_relative_err) > self.out_threshold:
+                    api_data.set_result(data_list, self.result_level)
+                    api_data.set_err_msg(data_list, self.err_msg)
+
+
+class OneThousandthErrChecker(BaseAlgorithm):
+    """
+    适用于真实数据模式
+    指标需要结合输入和输出共同计算得到
+    一个 API 或模块的 One Thousandth Err Ratio 的 input/parameters > 0.9 同时 output < 0.6， 标记为 error
+    """
+
+    def __init__(self):
+        self.input_threshold = 0.9
+        self.output_threshold = 0.1
+        self.result_level = ResultLevel.ERROR
+        self.err_msg = (f'{self.result_level.value}: The input/parameters of '
+                        f'One Thousandth Err Ratio > 0.9 while the output < 0.6.')
+
+    def run(self, api_data: ApiData, ignore_info: IgnoreInfo):
+        if ignore_info in [IgnoreInfo.ALL_IGNORE, IgnoreInfo.INPUT_IGNORE]:
+            return
+        if not api_data.output_data:
+            return
+
+        min_input_ratio = api_data.get_min_or_max_value(CompareConst.ONE_THOUSANDTH_ERR_RATIO)
+        min_output_ratio = api_data.get_min_or_max_value(CompareConst.ONE_THOUSANDTH_ERR_RATIO, is_input=False)
+
+        if min_input_ratio > self.input_threshold and min_output_ratio < self.output_threshold:
+            api_data.set_result(api_data.output_data[0], self.result_level)
+            api_data.set_err_msg(api_data.output_data[0], self.err_msg)
+
+
+class RequiresGradErrChecker(BaseAlgorithm):
+    """
+    适用于真实数据模式、统计数据模式
+    一个 API 或模块的 Requires_grad Consistent 为 False，标记为 error
+    """
+
+    def __init__(self):
+        self.result_level = ResultLevel.ERROR
+        self.err_msg = f'{self.result_level.value}: The Required_Grad of NPU and Bench are inconsistent'
+
+    def run(self, api_data: ApiData, ignore_info: IgnoreInfo):
+        data_lists = get_data_list_by_ignore_info(api_data, ignore_info)
+        if not data_lists:
+            return
+
+        for data_list in data_lists:
+            # not match
+            bench_name = api_data.get_data_by_header(CompareConst.BENCH_NAME, data_list)
+            if not bench_name or bench_name == CompareConst.N_A:
+                continue
+
+            npu_req_grad = api_data.get_data_by_header(CompareConst.NPU_REQ_GRAD, data_list)
+            bench_req_grad = api_data.get_data_by_header(CompareConst.BENCH_REQ_GRAD, data_list)
+
+            if not npu_req_grad or not bench_req_grad:
+                continue
+
+            if npu_req_grad != bench_req_grad:
+                api_data.set_result(data_list, self.result_level)
+                api_data.set_err_msg(data_list, self.err_msg)
+
+
+class ParametersErrChecker(BaseAlgorithm):
+    """
+    适用于真实数据模式、统计数据模式
+    一个 API 或模块的非 tensor 标量参数，NPU 和 Bench 不一致，标记为 error
+    """
+
+    def __init__(self):
+        self.result_level = ResultLevel.ERROR
+        self.err_msg = f'{self.result_level.value}: The scalar parameters of NPU and Bench are inconsistent.'
+
+    def run(self, api_data: ApiData, ignore_info: IgnoreInfo):
+        if ignore_info in [IgnoreInfo.ALL_IGNORE, IgnoreInfo.INPUT_IGNORE]:
+            return
+
+        for data_list in api_data.input_data:
+            # not match
+            bench_name = api_data.get_data_by_header(CompareConst.BENCH_NAME, data_list)
+            if not bench_name or bench_name == CompareConst.N_A:
+                continue
+
+            npu_dtype = api_data.get_data_by_header(CompareConst.NPU_DTYPE, data_list)
+            bench_dtype = api_data.get_data_by_header(CompareConst.BENCH_DTYPE, data_list)
+            if not npu_dtype or not bench_dtype:
+                continue
+            # 非tensor标量的dtype一定包含'class'，例如int类型的dtype为<class int>
+            if 'class' not in npu_dtype or 'class' not in bench_dtype:
+                continue
+
+            npu_shape = api_data.get_data_by_header(CompareConst.NPU_SHAPE, data_list)
+            # 以shape是否为[]判断其是否为标量
+            if str(npu_shape) != '[]':
+                continue
+            npu_max = api_data.get_data_by_header(CompareConst.NPU_MAX, data_list)
+            bench_max = api_data.get_data_by_header(CompareConst.BENCH_MAX, data_list)
+            if npu_max != bench_max:
+                api_data.set_result(data_list, self.result_level)
+                api_data.set_err_msg(data_list, self.err_msg)
+
+
+class CRC32ErrChecker(BaseAlgorithm):
+    """
+    适用于MD5模式
+    NPU 与标杆的 CRC-32 值不一致，标记为 error
+    NPU 与标杆的参数未匹配上，标记为 warning
+    """
+
+    def __init__(self):
+        self.err_level = ResultLevel.ERROR
+        self.err_msg = f'{self.err_level.value}: The CRC-32 value of NPU differs from that of the bench.'
+        self.warn_level = ResultLevel.WARNING
+        self.warn_msg = f'{self.warn_level.value}: The parameter of NPU does not match the bench.'
+
+    def run(self, api_data: ApiData, ignore_info: IgnoreInfo):
+        data_lists = get_data_list_by_ignore_info(api_data, ignore_info)
+        if not data_lists:
+            return
+
+        null_set = (CompareConst.N_A, CompareConst.NAN)
+        for data_list in data_lists:
+            npu_md5 = api_data.get_data_by_header(CompareConst.NPU_MD5, data_list)
+            bench_md5 = api_data.get_data_by_header(CompareConst.BENCH_MD5, data_list)
+            if npu_md5 != bench_md5:
+                # 参数未匹配上
+                if npu_md5 in null_set or bench_md5 in null_set:
+                    api_data.set_result(data_list, self.warn_level)
+                    api_data.set_err_msg(data_list, self.warn_msg)
+                else:
+                    api_data.set_result(data_list, self.err_level)
+                    api_data.set_err_msg(data_list, self.err_msg)
+
+
+class DTypeErrChecker(BaseAlgorithm):
+    """
+    适用于真实数据模式、统计数据模式
+    一个 API 或模块的 dtype 不一致，标记为 error
+    """
+
+    def __init__(self):
+        self.result_level = ResultLevel.ERROR
+        self.err_msg = f'{self.result_level.value}: The dtype of NPU and Bench are inconsistent.'
+
+    def run(self, api_data: ApiData, ignore_info: IgnoreInfo):
+        data_lists = get_data_list_by_ignore_info(api_data, ignore_info)
+        if not data_lists:
+            return
+
+        for data_list in data_lists:
+            # not match
+            bench_name = api_data.get_data_by_header(CompareConst.BENCH_NAME, data_list)
+            if not bench_name or bench_name == CompareConst.N_A:
+                continue
+
+            npu_dtype = api_data.get_data_by_header(CompareConst.NPU_DTYPE, data_list)
+            bench_dtype = api_data.get_data_by_header(CompareConst.BENCH_DTYPE, data_list)
+
+            if not npu_dtype or not bench_dtype:
+                continue
+
+            if npu_dtype != bench_dtype:
+                api_data.set_result(data_list, self.result_level)
+                api_data.set_err_msg(data_list, self.err_msg)
+
+
+class ShapeErrChecker(BaseAlgorithm):
+    """
+    适用于真实数据模式、统计数据模式
+    一个 API 或模块的 shape 不一致，标记为 error
+    """
+
+    def __init__(self):
+        self.result_level = ResultLevel.ERROR
+        self.err_msg = f'{self.result_level.value}: The shape of NPU and Bench are inconsistent.'
+
+    def run(self, api_data: ApiData, ignore_info: IgnoreInfo):
+        data_lists = get_data_list_by_ignore_info(api_data, ignore_info)
+        if not data_lists:
+            return
+        for data_list in data_lists:
+            # not match
+            bench_name = api_data.get_data_by_header(CompareConst.BENCH_NAME, data_list)
+            if not bench_name or bench_name == CompareConst.N_A:
+                continue
+
+            npu_shape = api_data.get_data_by_header(CompareConst.NPU_SHAPE, data_list)
+            bench_shape = api_data.get_data_by_header(CompareConst.BENCH_SHAPE, data_list)
+
+            if npu_shape is None or bench_shape is None:
+                continue
+
+            if npu_shape != bench_shape:
+                api_data.set_result(data_list, self.result_level)
+                api_data.set_err_msg(data_list, self.err_msg)
+
+
+class RelativeWarnChecker(BaseAlgorithm):
+    """
+    适用于统计数据模式
+    指标需要结合输入和输出共同计算得到
+    一个 API 或模块的 output 相对误差是 input 相对误差的10倍，标记为 warning，默认选取norm观测
+    """
+
+    def __init__(self):
+        self.threshold = 10
+        self.result_level = ResultLevel.WARNING
+        self.err_msg = (f'{self.result_level.value}: The norm relative error of output '
+                        f'is {self.threshold} times that of input.')
+
+    def run(self, api_data: ApiData, ignore_info: IgnoreInfo):
+        if ignore_info in [IgnoreInfo.ALL_IGNORE, IgnoreInfo.INPUT_IGNORE]:
+            return
+
+        if not api_data.output_data:
+            return
+
+        norm_relative_error_max_in = abs(api_data.get_min_or_max_value(CompareConst.NORM_RELATIVE_ERR, is_min=False))
+        norm_relative_error_max_out = abs(
+            api_data.get_min_or_max_value(CompareConst.NORM_RELATIVE_ERR, is_input=False, is_min=False))
+
+        should_set = False
+
+        if norm_relative_error_max_in == 0:
+            if norm_relative_error_max_out > 0.1:
+                should_set = True
+        elif norm_relative_error_max_out / norm_relative_error_max_in > self.threshold:
+            should_set = True
+
+        if should_set:
+            api_data.set_result(api_data.output_data[0], self.result_level)
+            api_data.set_err_msg(api_data.output_data[0], self.err_msg)
+
+
+class CosineWarnChecker(BaseAlgorithm):
+    """
+    适用于真实数据模式
+    指标需要结合输入和输出共同计算得到
+    一个 API 或模块的 Cosine 的 input/parameters > 0.9 且 input/parameters - output > 0.1
+    """
+
+    def __init__(self):
+        self.input_threshold = 0.9
+        self.output_threshold = 0.1
+        self.result_level = ResultLevel.WARNING
+        self.err_msg = (f'{self.result_level.value}: The input/parameters of Cosine > {self.input_threshold}, '
+                        f'and input/parameters - output > {self.output_threshold}')
+
+    def run(self, api_data: ApiData, ignore_info: IgnoreInfo):
+        if ignore_info in [IgnoreInfo.ALL_IGNORE, IgnoreInfo.INPUT_IGNORE]:
+            return
+
+        if not api_data.output_data:
+            return
+
+        min_input_cosine = api_data.get_min_or_max_value(CompareConst.COSINE)
+        min_output_cosine = api_data.get_min_or_max_value(CompareConst.COSINE, is_input=False)
+
+        if min_input_cosine > self.input_threshold and min_input_cosine - min_output_cosine > self.output_threshold:
+            api_data.set_result(api_data.output_data[0], self.result_level)
+            api_data.set_err_msg(api_data.output_data[0], self.err_msg)
+
+
+TENSOR_CHECKERS = [InfNanErrChecker, OneThousandthErrChecker, RequiresGradErrChecker, ParametersErrChecker,
+                   DTypeErrChecker, ShapeErrChecker, CosineWarnChecker]
+STATISTICS_CHECKERS = [InfNanErrChecker, RelativeErrChecker, RequiresGradErrChecker, ParametersErrChecker,
+                       DTypeErrChecker, ShapeErrChecker, RelativeWarnChecker]
+MD5_CHECKERS = [CRC32ErrChecker]
+STATISTICS_CHECKERS_PARALLEL_MERGE = [InfNanErrChecker, RelativeErrChecker, RequiresGradErrChecker,
+                                      ParametersErrChecker, DTypeErrChecker, RelativeWarnChecker]

msprobe/core/compare/indicator_analysis/api_data.py

@@ -0,0 +1,141 @@
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
+#
+# 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://license.coscl.org.cn/MulanPSL2
+#
+# 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.
+# -------------------------------------------------------------------------
+
+from typing import List
+
+from msprobe.core.compare.indicator_analysis.utils import CompareMode, ResultLevel, str2float
+from msprobe.core.common.const import Const, CompareConst
+from msprobe.core.common.log import logger
+from msprobe.core.common.exceptions import MsprobeException
+
+
+class ApiData:
+    header_index_mapping_cache = {}
+
+    def __init__(self, mode, data_lists: List[List]):
+        self.input_data = []
+        self.output_data = []
+        self.mode = mode
+        self.data_lists = data_lists
+        self.header = self._get_header()
+        # 表头与索引映射，可以基于表头拿到索引，从input_data和output_data中获取对应数据
+        self.header_index_mapping = self.get_header_index_mapping()
+        self._init_data()
+
+    def get_header_index_mapping(self):
+        if self.mode in ApiData.header_index_mapping_cache:
+            return ApiData.header_index_mapping_cache[self.mode]
+
+        mapping = {item: index for index, item in enumerate(self.header)}
+        ApiData.header_index_mapping_cache[self.mode] = mapping
+        return mapping
+
+    def get_data_by_header(self, header: str, data_list: List):
+        """
+        基于表头从data list获取数据
+        """
+        index = self.header_index_mapping.get(header)
+        try:
+            data = data_list[index]
+        except Exception as e:
+            logger.error(f'Unable to get data from the data list based on the header: {e}')
+            raise MsprobeException(MsprobeException.INVALID_PARAM_ERROR) from e
+        return data
+
+    def set_data_by_header(self, header: str, data_list: List, new_data):
+        index = self.header_index_mapping.get(header)
+        try:
+            data_list[index] = new_data
+        except Exception as e:
+            logger.error(f'Unable to set data from the data list based on the header: {e}')
+            raise MsprobeException(MsprobeException.INVALID_PARAM_ERROR) from e
+
+    def set_result(self, data_list: List, status: ResultLevel = ResultLevel.PASS):
+        index = self.header_index_mapping.get(CompareConst.RESULT)
+        try:
+            current_status = data_list[index]
+            if not isinstance(current_status, ResultLevel) or status > current_status:
+                data_list[index] = status
+        except Exception as e:
+            logger.error(f'Unable to set status from the data list based on the header: {e}')
+            raise MsprobeException(MsprobeException.INVALID_PARAM_ERROR) from e
+
+    def set_err_msg(self, data_list: List, msg: str = '', init_msg=False):
+        index = self.header_index_mapping.get(CompareConst.ERROR_MESSAGE)
+        try:
+            if init_msg:
+                data_list[index] = []
+            else:
+                current_msg = data_list[index]
+                if not isinstance(current_msg, list):
+                    current_msg = [current_msg] if current_msg else []
+                    data_list[index] = current_msg
+                if msg:
+                    current_msg.append(msg)
+        except Exception as e:
+            logger.error(f'Unable to set err msg from the data list based on the header: {e}')
+            raise MsprobeException(MsprobeException.INVALID_PARAM_ERROR) from e
+
+    def get_min_or_max_value(self, header, is_input=True, is_min=True):
+        """
+        获取多个输入或输出参数中的最小或最大指标
+        """
+        default_value = 1.0 if is_min else 0.0
+        data_lists = self.input_data if is_input else self.output_data
+        for data_list in data_lists:
+            value = self.get_data_by_header(header, data_list)
+
+            if value is None or value in [CompareConst.NAN, CompareConst.N_A]:
+                continue
+
+            if isinstance(value, str) and value.endswith('%'):
+                value = str2float(value)
+
+            if isinstance(value, str):
+                continue
+
+            default_value = min(default_value, value) if is_min else max(default_value, value)
+        return default_value
+
+    def _get_header(self):
+        if self.mode == CompareMode.STATISTICS.value:
+            return CompareConst.SUMMARY_COMPARE_RESULT_HEADER
+        elif self.mode == CompareMode.TENSOR.value:
+            return CompareConst.COMPARE_RESULT_HEADER
+        elif self.mode == CompareMode.MD5.value:
+            return CompareConst.MD5_COMPARE_RESULT_HEADER
+        else:
+            logger.error(f'The parameter "mode" error, '
+                         f'expected {CompareMode.STATISTICS.value}/{CompareMode.TENSOR.value}/{CompareMode.MD5.value}, '
+                         f'actually {self.mode}.')
+            raise MsprobeException(MsprobeException.INVALID_PARAM_ERROR)
+
+    def _init_data(self):
+        for data_list in self.data_lists:
+            if not data_list:
+                continue
+
+            if len(data_list) < len(self.header):
+                data_list = data_list + [''] * (len(self.header) - len(data_list))
+
+            # 初始化result为pass，error message为list
+            self.set_result(data_list)
+            self.set_err_msg(data_list, init_msg=True)
+
+            if f'{Const.SEP}{Const.OUTPUT}{Const.SEP}' in data_list[0]:
+                self.output_data.append(data_list)
+            else:
+                self.input_data.append(data_list)

msprobe/core/compare/indicator_analysis/calculator.py

@@ -0,0 +1,181 @@
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
+#
+# 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://license.coscl.org.cn/MulanPSL2
+#
+# 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 re
+import json
+from typing import List
+
+from msprobe.core.common.const import Const, CompareConst
+from msprobe.core.common.log import logger
+from msprobe.core.compare.indicator_analysis.utils import CompareMode, ResultLevel, divide_result_df, IgnoreInfo
+from msprobe.core.compare.indicator_analysis.algorithm import BaseAlgorithm, TENSOR_CHECKERS, STATISTICS_CHECKERS, \
+    MD5_CHECKERS, STATISTICS_CHECKERS_PARALLEL_MERGE
+from msprobe.core.compare.indicator_analysis.api_data import ApiData
+
+
+class ApiIndicatorCalculator:
+    RANK_SUFFIX_PATTERN = re.compile(r'_rank\d+$')
+
+    def __init__(self, mode, parallel_merge=False):
+        self.mode = mode
+        self.parallel_merge = parallel_merge
+        self.all_ignore_set = {'empty', 'empty_like', 'numpy', 'to', '__setitem__', 'empty_with_format',
+                               'new_empty_strided', 'new_empty', 'empty_strided'}
+        self.input_ignore_set = {'_reduce_scatter_base', '_all_gather_base', 'all_to_all_single', 'batch_isend_irecv'}
+        self.algorithms: List[BaseAlgorithm] = []
+        self._add_algorithm()
+
+    @staticmethod
+    def get_api_indicator_and_msg(api_data: ApiData):
+        """
+        基于all_data_lists（api或模块的所有参数的数据）得到一个api或模块的指标和异常信息
+
+        indicator取所有参数最差的（error）
+        err msg取所有参数汇总
+
+        Return:
+            精度比对指标（pass/warning/error）
+        """
+        all_data_lists = api_data.input_data + api_data.output_data
+        final_indicator = ResultLevel.PASS
+        for data_list in all_data_lists:
+            indicator = api_data.get_data_by_header(CompareConst.RESULT, data_list)
+            if isinstance(indicator, ResultLevel):
+                api_data.set_data_by_header(CompareConst.RESULT, data_list, indicator.value)
+                if indicator > final_indicator:
+                    final_indicator = indicator
+            err_msg = api_data.get_data_by_header(CompareConst.ERROR_MESSAGE, data_list)
+            if isinstance(err_msg, list):
+                api_data.set_data_by_header(CompareConst.ERROR_MESSAGE, data_list, json.dumps(err_msg))
+
+        return final_indicator.value
+
+    def get_api_ignore_info(self, api_data: ApiData):
+        """
+        api是否需要忽略判断规则的情况
+        """
+        if not api_data.input_data:
+            return IgnoreInfo.NO_IGNORE
+        npu_param_name = api_data.get_data_by_header(CompareConst.NPU_NAME, api_data.input_data[0])
+        name_split = npu_param_name.split(Const.SEP)
+        if len(name_split) < 2:
+            return IgnoreInfo.NO_IGNORE
+        api_name = self.RANK_SUFFIX_PATTERN.sub('', name_split[1]) if self.parallel_merge else name_split[1]
+        if api_name in self.all_ignore_set:
+            return IgnoreInfo.ALL_IGNORE
+        elif api_name in self.input_ignore_set:
+            return IgnoreInfo.INPUT_IGNORE
+
+        return IgnoreInfo.NO_IGNORE
+
+    def calculate(self, raw_data_list: List[List]):
+        """
+        计算入口
+        """
+        api_data = ApiData(self.mode, raw_data_list)
+
+        ignore_info = self.get_api_ignore_info(api_data)
+
+        self.execute_all(api_data, ignore_info)
+
+        return self.get_api_indicator_and_msg(api_data)
+
+    def add_algorithm(self, algorithm: BaseAlgorithm):
+        if not isinstance(algorithm, BaseAlgorithm):
+            msg = 'It must be an instance of a subclass of BaseAlgorithm.'
+            logger.error(msg)
+            raise TypeError(msg)
+        self.algorithms.append(algorithm)
+
+    def execute_all(self, api_data: ApiData, ignore_info: IgnoreInfo):
+        for algorithm in self.algorithms:
+            try:
+                algorithm.run(api_data, ignore_info)
+            except Exception as e:
+                msg = f'Run algorithm failed.'
+                logger.error(msg)
+                raise RuntimeError(msg) from e
+
+    def _add_algorithm(self):
+        if self.mode == CompareMode.STATISTICS.value:
+            checkers = STATISTICS_CHECKERS_PARALLEL_MERGE if self.parallel_merge else STATISTICS_CHECKERS
+            for checker in checkers:
+                self.add_algorithm(checker())
+        elif self.mode == CompareMode.TENSOR.value:
+            for checker in TENSOR_CHECKERS:
+                self.add_algorithm(checker())
+        elif self.mode == CompareMode.MD5.value:
+            for checker in MD5_CHECKERS:
+                self.add_algorithm(checker())
+
+
+def calculate_excel_result_df(result_df, mode, chunk_size=1000):
+    """
+    仅适用于excel比对场景，得到表格每行数据的精度比对指标（pass/warning/error）
+
+    Args:
+        result_df: DataFrame数据结构，即转换成excel前的表单结构
+        mode: 比对模式，分为 tensor 模式、统计量模式和 md5 模式
+        chunk_size: 分块赋值参数，默认1000，把 result 分成小块，逐块赋值给 result_df，这样每次只占用小块内存，避免内存峰值过高
+    """
+    result_dict = divide_result_df(result_df)
+    calculator = ApiIndicatorCalculator(mode)
+    calculated_result_lists = []
+    for data_lists in result_dict.values():
+        calculator.calculate(data_lists)
+        calculated_result_lists.extend(data_lists)
+
+    head = CompareConst.HEAD_OF_COMPARE_MODE.get(mode)
+    if not head:
+        logger.error(f'Unable to obtain header based on compare mode: {mode}')
+        raise RuntimeError()
+    # 配置列映射关系：[(result_df的目标列名, result子列表的列索引)]
+    try:
+        cols_mapping = [
+            (CompareConst.RESULT, head.index(CompareConst.RESULT)),
+            (CompareConst.ERROR_MESSAGE, head.index(CompareConst.ERROR_MESSAGE))
+        ]
+    except ValueError as e:
+        logger.error(f'The {CompareConst.RESULT} or {CompareConst.ERROR_MESSAGE} does not exist in the header: {e}')
+        raise e
+
+    total_rows = len(calculated_result_lists)
+
+    # 分块逐批赋值，降低内存瞬时峰值
+    for i in range(0, total_rows, chunk_size):
+        end_idx = min(i + chunk_size, total_rows)
+        current_result_chunk = calculated_result_lists[i:end_idx]
+
+        for df_col_name, result_col_idx in cols_mapping:
+            col_data = [sublist[result_col_idx] for sublist in current_result_chunk]
+            df_col_idx = result_df.columns.get_loc(df_col_name)
+            result_df.iloc[i:end_idx, df_col_idx] = col_data
+
+
+def calculate_result(result, mode, parallel_merge=False):
+    """
+    得到一个api或模块的指标和异常信息
+
+    Args:
+        result: List[List]数据结构，每个list元素代表api或模块参数的具体信息
+        mode: 比对模式，分为 tensor 模式、统计量模式和 md5 模式
+        parallel_merge: 是否为不同切分策略图合并比对场景，默认False
+
+    Return:
+        精度比对指标（pass/warning/error）
+    """
+    calculator = ApiIndicatorCalculator(mode, parallel_merge)
+    return calculator.calculate(result)