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

msprobe/pytorch/api_accuracy_checker/common/utils.py

@@ -72,38 +72,53 @@ def check_need_convert(api_name):
     return convert_type
 
 
-def api_info_preprocess(api_name, api_info_dict):
+def cross_entropy_process(api_info_dict):
     """
     Function Description:
-        Preprocesses the API information.
+        Preprocesses the cross_entropy API information.
     Parameter:
-        api_name: Name of the API.
         api_info_dict: argument of the API.
     Return api_info_dict:
-        convert_type: Type of conversion.
         api_info_dict: Processed argument of the API.
     """
-    convert_type = check_need_convert(api_name)
-    if api_name == 'cross_entropy':
-        api_info_dict = cross_entropy_process(api_info_dict)
-    return convert_type, api_info_dict
+    if 'input_args' in api_info_dict and len(api_info_dict['input_args']) > 1 \
+        and 'Min' in api_info_dict['input_args'][1]:
+        if api_info_dict['input_args'][1]['Min'] <= 0:
+            # The second argument in cross_entropy should be -100 or not less than 0
+            api_info_dict['input_args'][1]['Min'] = 0
+    return api_info_dict
 
 
-def cross_entropy_process(api_info_dict):
+def histc_process(api_info_dict):
+    input_args = api_info_dict['input_args']
+    if input_args and input_args[0].get('dtype'):
+        dtype = input_args[0]['dtype']
+        if dtype in Const.TORCH_INT_DTYPE:
+            api_info_dict['input_args'][0]['dtype'] = Const.TORCH_FLOAT32
+    return api_info_dict
+
+
+API_PROCESS_MAP = {
+    'cross_entropy': cross_entropy_process,
+    'histc': histc_process
+}
+
+
+def api_info_preprocess(api_name, api_info_dict):
     """
     Function Description:
-        Preprocesses the cross_entropy API information.
+        Preprocesses the API information.
     Parameter:
+        api_name: Name of the API.
         api_info_dict: argument of the API.
     Return api_info_dict:
+        convert_type: Type of conversion.
         api_info_dict: Processed argument of the API.
     """
-    if 'input_args' in api_info_dict and len(api_info_dict['input_args']) > 1 \
-        and 'Min' in api_info_dict['input_args'][1]:
-        if api_info_dict['input_args'][1]['Min'] <= 0:
-            # The second argument in cross_entropy should be -100 or not less than 0
-            api_info_dict['input_args'][1]['Min'] = 0
-    return api_info_dict
+    convert_type = check_need_convert(api_name)
+    if api_name in API_PROCESS_MAP:
+        api_info_dict = API_PROCESS_MAP[api_name](api_info_dict)
+    return convert_type, api_info_dict
 
 
 def initialize_save_path(save_path, dir_name):

msprobe/pytorch/api_accuracy_checker/compare/algorithm.py

@@ -16,10 +16,12 @@
 # limitations under the License.
 
 # 定义比对算法及比对标准
+import math
 import torch
 import numpy as np
 
 from msprobe.pytorch.api_accuracy_checker.compare.compare_utils import ULP_PARAMETERS
+from msprobe.pytorch.api_accuracy_checker.precision_standard.standard_config import StandardConfig
 from msprobe.core.common.const import CompareConst
 
 
@@ -179,13 +181,13 @@ def check_inf_nan_value(inf_nan_mask, bench_output, device_output, dtype, rtol):
 
 def check_small_value(abs_err, small_value_mask, small_value_atol):
     '''
-    新精度标准的相对阈值法中，检查npu和golden小值域输出的相对误差是否满足阈值
+    新精度标准的绝对阈值法中，检查npu和golden正常值输出的绝对误差是否满足阈值
     输入：
-        rel_err：npu输出和golden输出的相对误差
+        abs_err：npu输出和golden输出的绝对误差
         normal_value_mask：npu输出和golden输出的正常值mask
-        rtol：相对误差的阈值
+        atol：绝对误差的阈值
     输出： 
-        rel_err_ratio：npu输出和golden输出的相对误差不满足阈值的比例
+        abs_err_ratio：npu输出和golden输出的绝对误差不满足阈值的比例
     '''
     greater_mask = np.greater(abs_err, small_value_atol)
     err_mask = np.logical_and(greater_mask, small_value_mask)
@@ -195,13 +197,13 @@ def check_small_value(abs_err, small_value_mask, small_value_atol):
 
 def check_norm_value(normal_value_mask, rel_err, rtol):
     '''
-    新精度标准的绝对阈值法中，检查npu和golden正常值输出的绝对误差是否满足阈值
+    新精度标准的相对阈值法中，检查npu和golden小值域输出的相对误差是否满足阈值
     输入：
-        abs_err：npu输出和golden输出的绝对误差
+        rel_err：npu输出和golden输出的相对误差
         normal_value_mask：npu输出和golden输出的正常值mask
-        atol：绝对误差的阈值
+        rtol：相对误差的阈值
     输出： 
-        abs_err_ratio：npu输出和golden输出的绝对误差不满足阈值的比例
+        rel_err_ratio：npu输出和golden输出的相对误差不满足阈值的比例
     '''
     err_mask = np.greater(rel_err, rtol)
     err_mask = np.logical_and(err_mask, normal_value_mask)
@@ -228,3 +230,34 @@ def get_ulp_err(bench_output, device_output, dtype):
 def calc_ulp_err(bench_output, device_output, eb, exponent_num, data_type):
     return (device_output.astype(data_type) - bench_output).astype(data_type) * \
             np.exp2(-eb + exponent_num).astype(data_type)
+
+
+def calc_ratio(x, y, dtype):
+    """
+    Calculate the ratio between NPU and GPU statistical values.
+
+    Args:
+        x (float): Statistical value from the NPU side
+        y (float): Statistical value from the GPU side
+        dtype: Data type used to determine the minimum error value
+
+    Returns:
+        float: The ratio of NPU to GPU statistical values
+
+    Notes:
+        - Takes absolute values of both x and y for calculation
+        - Uses StandardConfig.get_minmum_err(dtype) to get minimum error for the specified dtype
+        - Prevents division by zero by ensuring denominator is not less than minimum error
+        - Returns |x| / max(|y|, minimum_error)
+    """
+    x, y = abs(x), abs(y)
+    minmum_err = StandardConfig.get_minmum_err(dtype)
+    err_y = max(y, minmum_err)
+    return x / err_y
+
+
+def compare_bool_tensor(bench_output, device_output):
+    error_nums = (bench_output != device_output).sum()
+    error_rate = float(error_nums / bench_output.size)
+    result = CompareConst.PASS if error_rate == 0 else CompareConst.ERROR
+    return error_rate, result, ""

msprobe/pytorch/api_accuracy_checker/compare/api_precision_compare.py

@@ -29,11 +29,15 @@ from msprobe.pytorch.api_accuracy_checker.common.config import msCheckerConfig
 from msprobe.pytorch.api_accuracy_checker.compare.compare_utils import API_PRECISION_COMPARE_RESULT_FILE_NAME, \
     API_PRECISION_COMPARE_DETAILS_FILE_NAME, BENCHMARK_COMPARE_SUPPORT_LIST, API_PRECISION_COMPARE_UNSUPPORT_LIST, \
     ApiPrecisionCompareColumn, absolute_standard_api, binary_standard_api, ulp_standard_api, thousandth_standard_api, \
-    BINARY_COMPARE_UNSUPPORT_LIST, ULP_COMPARE_SUPPORT_LIST, convert_str_to_float, CompareMessage, is_inf_or_nan, \
-    check_inf_or_nan
+    BINARY_COMPARE_UNSUPPORT_LIST, ULP_COMPARE_SUPPORT_LIST, convert_str_to_float, CompareMessage
+from msprobe.pytorch.api_accuracy_checker.compare.compare_input import PrecisionCompareInput
+from msprobe.pytorch.api_accuracy_checker.precision_standard.standard_register import StandardRegistry
+from msprobe.pytorch.api_accuracy_checker.precision_standard.ulp_compare import UlpPrecisionCompare
+from msprobe.pytorch.api_accuracy_checker.precision_standard.benchmark_compare import BenchmarkPrecisionCompare
+from msprobe.pytorch.api_accuracy_checker.precision_standard.standard_config import StandardConfig
 from msprobe.pytorch.api_accuracy_checker.compare.compare_column import ApiPrecisionOutputColumn
 from msprobe.pytorch.api_accuracy_checker.run_ut.run_ut_utils import get_validated_result_csv_path
-from msprobe.pytorch.api_accuracy_checker.common.utils import extract_detailed_api_segments
+from msprobe.pytorch.api_accuracy_checker.common.utils import extract_detailed_api_segments, extract_basic_api_segments
 from msprobe.core.common.file_utils import FileChecker, change_mode, create_directory
 from msprobe.pytorch.common.log import logger
 from msprobe.core.common.utils import CompareException
@@ -47,30 +51,6 @@ BenchmarkInfNanConsistency = namedtuple('BenchmarkInfNanConsistency', ['small_va
                                                                            'eb_inf_nan_consistency'])
 UNSUPPORTED_MESSAGE = 'This data type does not support benchmark compare.'
 
-DEFAULT_THRESHOLD = 1
-
-benchmark_algorithms_thresholds = {
-    'small_value': {
-        'error_threshold': 2,
-        'warning_threshold': 1
-    },
-    'rmse': {
-        'error_threshold': 2,
-        'warning_threshold': 1
-    },
-    'max_rel_err': {
-        'error_threshold': 10,
-        'warning_threshold': 1
-    },
-    'mean_rel_err': {
-        'error_threshold': 2,
-        'warning_threshold': 1
-    },
-    'eb': {
-        'error_threshold': 2,
-        'warning_threshold': 1
-    }
-}
 
 benchmark_message = {
     "small_value_err_status": {
@@ -92,189 +72,6 @@ benchmark_message = {
 }
 
 
-class Standard:
-    @staticmethod
-    def _calc_ratio(column_name, x, y, default_value):
-        '''
-        计算npu侧和gpu侧统计量的比值
-        输入：
-            column_name：统计量名称
-            x：npu侧统计量
-            y：gpu侧统计量
-            default：当x不接近0，y接近0，设置的比值默认值
-        输出： 
-            ratio：统计量x和y的比值
-            inf_nan_consistency：不出现inf或nan时为True，出现inf或nan时必须同时为inf或-inf或nan才为True，否则为False
-            message：当出现inf或nan时的提示信息
-        '''
-        x, y = convert_str_to_float(x), convert_str_to_float(y)
-
-        if is_inf_or_nan(x) or is_inf_or_nan(y):
-            return check_inf_or_nan(x, y, column_name)
-
-        inf_nan_consistency = True
-        message = ""
-        if math.isclose(y, 0.0):
-            if math.isclose(x, 0.0):
-                return 1.0, inf_nan_consistency, message
-            else:
-                return default_value, inf_nan_consistency, message
-        else:
-            return abs(x / y), inf_nan_consistency, message
-
-
-class BenchmarkStandard(Standard):
-    def __init__(self, api_name, npu_precision, gpu_precision):
-        self.api_name = api_name
-        self.npu_precision = npu_precision
-        self.gpu_precision = gpu_precision
-        self.small_value_err_ratio = 1
-        self.rmse_ratio = 1
-        self.max_rel_err_ratio = 1
-        self.mean_rel_err_ratio = 1
-        self.eb_ratio = 1
-        self.small_value_err_status = CompareConst.PASS
-        self.rmse_status = CompareConst.PASS
-        self.max_rel_err_status = CompareConst.PASS
-        self.mean_rel_err_status = CompareConst.PASS
-        self.eb_status = CompareConst.PASS
-        self.check_result_list = []
-        self.final_result = CompareConst.PASS
-        self.compare_message = ""
-
-    def __str__(self):
-        return "%s" % (self.api_name)
-
-    @staticmethod
-    def _get_status(ratio, algorithm):
-        if math.isnan(ratio) or math.isinf(ratio):
-            return CompareConst.PASS
-        error_threshold = benchmark_algorithms_thresholds.get(algorithm, {}).get('error_threshold', DEFAULT_THRESHOLD)
-        warning_threshold = benchmark_algorithms_thresholds.get(algorithm, {}).get('warning_threshold',
-                                                                                   DEFAULT_THRESHOLD)
-        if ratio > error_threshold:
-            return CompareConst.ERROR
-        elif ratio > warning_threshold:
-            return CompareConst.WARNING
-        return CompareConst.PASS
-
-    def get_result(self):
-        inf_nan_consistency = self._compare_ratio()
-        small_value_inf_nan_consistency = inf_nan_consistency.small_value_inf_nan_consistency
-        rmse_inf_nan_consistency = inf_nan_consistency.rmse_inf_nan_consistency
-        max_rel_inf_nan_consistency = inf_nan_consistency.max_rel_inf_nan_consistency
-        mean_rel_inf_nan_consistency = inf_nan_consistency.mean_rel_inf_nan_consistency
-        eb_inf_nan_consistency = inf_nan_consistency.eb_inf_nan_consistency
-        self.small_value_err_status = self._get_status(self.small_value_err_ratio, 'small_value') if \
-            small_value_inf_nan_consistency else CompareConst.ERROR
-        self.check_result_list.append(self.small_value_err_status)
-        self.rmse_status = self._get_status(self.rmse_ratio, 'rmse') if rmse_inf_nan_consistency \
-            else CompareConst.ERROR
-        self.check_result_list.append(self.rmse_status)
-        self.max_rel_err_status = self._get_status(
-             self.max_rel_err_ratio, 'max_rel_err') if max_rel_inf_nan_consistency else CompareConst.ERROR
-        self.check_result_list.append(self.max_rel_err_status)
-        self.mean_rel_err_status = self._get_status(
-            self.mean_rel_err_ratio, 'mean_rel_err') if mean_rel_inf_nan_consistency else CompareConst.ERROR
-        self.check_result_list.append(self.mean_rel_err_status)
-        self.eb_status = self._get_status(self.eb_ratio, 'eb')
-        if CompareConst.ERROR in self.check_result_list:
-            self.final_result = CompareConst.ERROR
-        elif CompareConst.WARNING in self.check_result_list:
-            self.final_result = CompareConst.WARNING
-
-    def to_column_value(self):
-        return [self.small_value_err_ratio, self.small_value_err_status, self.rmse_ratio,
-                self.rmse_status, self.max_rel_err_ratio, self.max_rel_err_status, self.mean_rel_err_ratio,
-                self.mean_rel_err_status, self.eb_ratio, self.eb_status]
-
-    def _compare_ratio(self):
-        
-        self.small_value_err_ratio, small_value_inf_nan_consistency, small_value_message = self._calc_ratio(
-                                    ApiPrecisionCompareColumn.SMALL_VALUE_ERROR_RATE,
-                                    self.npu_precision.get(ApiPrecisionCompareColumn.SMALL_VALUE_ERROR_RATE),
-                                    self.gpu_precision.get(ApiPrecisionCompareColumn.SMALL_VALUE_ERROR_RATE), 10000.0)
-        self.compare_message += small_value_message
-        self.rmse_ratio, rmse_inf_nan_consistency, rmse_message = self._calc_ratio(ApiPrecisionCompareColumn.RMSE,
-                                        self.npu_precision.get(ApiPrecisionCompareColumn.RMSE),
-                                        self.gpu_precision.get(ApiPrecisionCompareColumn.RMSE), 10000.0)
-        self.compare_message += rmse_message
-        self.max_rel_err_ratio, max_rel_inf_nan_consistency, max_rel_message = self._calc_ratio(
-                                        ApiPrecisionCompareColumn.MAX_REL_ERR,
-                                        self.npu_precision.get(ApiPrecisionCompareColumn.MAX_REL_ERR),
-                                        self.gpu_precision.get(ApiPrecisionCompareColumn.MAX_REL_ERR), 10000.0)
-        self.compare_message += max_rel_message
-        self.mean_rel_err_ratio, mean_rel_inf_nan_consistency, mean_rel_message = self._calc_ratio(
-                                        ApiPrecisionCompareColumn.MEAN_REL_ERR,
-                                        self.npu_precision.get(ApiPrecisionCompareColumn.MEAN_REL_ERR),
-                                        self.gpu_precision.get(ApiPrecisionCompareColumn.MEAN_REL_ERR), 10000.0)
-        self.compare_message += mean_rel_message
-        self.eb_ratio, eb_inf_nan_consistency, eb_message = self._calc_ratio(ApiPrecisionCompareColumn.EB,
-                                        self.npu_precision.get(ApiPrecisionCompareColumn.EB),
-                                        self.gpu_precision.get(ApiPrecisionCompareColumn.EB), 10000.0)
-        self.compare_message += eb_message
-        
-        return BenchmarkInfNanConsistency(small_value_inf_nan_consistency, rmse_inf_nan_consistency, 
-                                          max_rel_inf_nan_consistency, mean_rel_inf_nan_consistency,
-                                          eb_inf_nan_consistency)
-
-
-class ULPStandard(Standard):
-    def __init__(self, api_name, npu_precision, gpu_precision):
-        self.api_name = api_name
-        self.npu_precision = npu_precision
-        self.gpu_precision = gpu_precision
-        self.mean_ulp_err = 0
-        self.ulp_err_proportion = 0
-        self.ulp_err_proportion_ratio = 1
-        self.ulp_err_status = CompareConst.PASS
-        self.compare_message = ""
-
-    def __str__(self):
-        return f"{self.api_name}"
-
-    def get_result(self):
-        self.mean_ulp_err = convert_str_to_float(self.npu_precision.get(ApiPrecisionCompareColumn.MEAN_ULP_ERR))
-        gpu_mean_ulp_err = convert_str_to_float(self.gpu_precision.get(ApiPrecisionCompareColumn.MEAN_ULP_ERR))
-        inf_nan_consistency = True
-        if is_inf_or_nan(self.mean_ulp_err) or is_inf_or_nan(gpu_mean_ulp_err):
-            _, inf_nan_consistency, message = check_inf_or_nan(self.mean_ulp_err, gpu_mean_ulp_err,
-                                                                 ApiPrecisionCompareColumn.MEAN_ULP_ERR)
-            self.compare_message += message
-        self.ulp_err_proportion = convert_str_to_float(
-                                                self.npu_precision.get(ApiPrecisionCompareColumn.ULP_ERR_PROPORTION))
-        self.ulp_err_proportion_ratio, ulp_inf_nan_consistency, message = self._calc_ratio(
-                    ApiPrecisionCompareColumn.ULP_ERR_PROPORTION,
-                    self.npu_precision.get(ApiPrecisionCompareColumn.ULP_ERR_PROPORTION),
-                    self.gpu_precision.get(ApiPrecisionCompareColumn.ULP_ERR_PROPORTION), 10000.0)
-        inf_nan_consistency = inf_nan_consistency and ulp_inf_nan_consistency
-        self.compare_message += message
-        if inf_nan_consistency:
-            self.ulp_err_status = self._get_ulp_status(self.npu_precision.get(ApiPrecisionCompareColumn.DEVICE_DTYPE))
-        else:
-            self.ulp_err_status = CompareConst.ERROR
-    
-    def _get_ulp_status(self, dtype):
-        if dtype == torch.float32:
-            if self.mean_ulp_err < 64:
-                return CompareConst.PASS
-            elif self.ulp_err_proportion < 0.05:
-                return CompareConst.PASS
-            elif self.ulp_err_proportion_ratio < 1:
-                return CompareConst.PASS
-            else:
-                self.compare_message += "ERROR: ULP误差不满足标准\n"
-                return CompareConst.ERROR
-        else:
-            if self.ulp_err_proportion < 0.001:
-                return CompareConst.PASS
-            elif self.ulp_err_proportion_ratio < 1:
-                return CompareConst.PASS
-            else:
-                self.compare_message += "ERROR: ULP误差不满足标准\n"
-                return CompareConst.ERROR
-
-
 def write_detail_csv(content, save_path):
     rows = []
     content = ["{:.{}f}".format(item, msCheckerConfig.precision) \
@@ -283,6 +80,17 @@ def write_detail_csv(content, save_path):
     write_csv(rows, save_path)
 
 
+def register_compare_func():
+    registry = StandardRegistry()
+    registry.register(CompareConst.ABSOLUTE_THRESHOLD, record_absolute_threshold_result)
+    registry.register(CompareConst.BINARY_CONSISTENCY, record_binary_consistency_result)
+    registry.register(CompareConst.ULP_COMPARE, record_ulp_compare_result)
+    registry.register(CompareConst.THOUSANDTH_STANDARD, record_thousandth_threshold_result)
+    registry.register(CompareConst.BENCHMARK, record_benchmark_compare_result)
+    registry.register(CompareConst.ACCUMULATIVE_ERROR_COMPARE, record_accumulative_error_compare_result)
+    return registry
+
+
 def api_precision_compare(config):
     logger.info("Start compare task")
     logger.info(f"Compare task result will be saved in {config.result_csv_path}")
@@ -337,6 +145,8 @@ def analyse_csv(npu_data, gpu_data, config):
     forward_status, backward_status = [], []
     last_api_name, last_api_dtype, last_api_full_name = None, None, None
     last_api_skip_message = ''
+    registry = register_compare_func()
+    
     for _, row_npu in npu_data.iterrows():
         message = ''
         compare_column = ApiPrecisionOutputColumn()
@@ -362,7 +172,7 @@ def analyse_csv(npu_data, gpu_data, config):
         row_gpu = row_gpu.iloc[0]
         new_status = CompareConst.SPACE
         try:
-            new_status = get_api_status(row_npu, row_gpu, api_name, compare_column)
+            new_status = get_api_status(row_npu, row_gpu, api_name, compare_column, registry)
         except Exception as err:
             logger.error(f"Get api status error: {str(err)}")
             compare_column.api_name = full_api_name_with_direction_status
@@ -383,7 +193,8 @@ def analyse_csv(npu_data, gpu_data, config):
             else:
                 forward_result = get_api_checker_result(forward_status)
                 backward_result = get_api_checker_result(backward_status)
-                message += CompareMessage.get(last_api_name, "") if forward_result == CompareConst.ERROR else ""
+                _, base_api_name = extract_basic_api_segments(last_api_name)
+                message += CompareMessage.get(base_api_name, "") if forward_result == CompareConst.ERROR else ""
                 message += last_api_skip_message if forward_result == CompareConst.SKIP else ""
                 write_csv([[last_api_name, forward_result, backward_result, message]], config.result_csv_path)
                 print_test_success(last_api_name, forward_result, backward_result)
@@ -415,37 +226,30 @@ def analyse_csv(npu_data, gpu_data, config):
         else:
             forward_result = get_api_checker_result(forward_status)
             backward_result = get_api_checker_result(backward_status)
-            message += CompareMessage.get(last_api_name, "") if forward_result == CompareConst.ERROR else ""
+            _, base_api_name = extract_basic_api_segments(last_api_name)
+            message += CompareMessage.get(base_api_name, "") if forward_result == CompareConst.ERROR else ""
             message += last_api_skip_message if forward_result == CompareConst.SKIP else ""
             write_csv([[last_api_name, forward_result, backward_result, message]], config.result_csv_path)
             print_test_success(last_api_name, forward_result, backward_result)
             last_api_skip_message = ''
 
 
-def get_api_status(row_npu, row_gpu, api_name, compare_column):
+def get_api_status(row_npu, row_gpu, api_name, compare_column, registry):
     full_api_name_with_direction_status = row_npu[ApiPrecisionCompareColumn.API_NAME]
     # 当前API的输出为空（例如反向过程中requires_grad=False）,跳过比对
-    if row_npu[ApiPrecisionCompareColumn.DEVICE_DTYPE].isspace():
+    if row_npu[ApiPrecisionCompareColumn.DEVICE_DTYPE].isspace() or \
+        row_npu[ApiPrecisionCompareColumn.DEVICE_DTYPE] in API_PRECISION_COMPARE_UNSUPPORT_LIST or \
+        row_npu[ApiPrecisionCompareColumn.SHAPE] == CompareConst.ZERO_SHAPE:
         compare_column.api_name = full_api_name_with_direction_status
         compare_column.compare_result = CompareConst.SKIP
         compare_column.compare_message = row_npu[ApiPrecisionCompareColumn.MESSAGE]
         new_status = CompareConst.SKIP
     else:
         compare_column.api_name = full_api_name_with_direction_status
-        if api_name in thousandth_standard_api:
-            new_status = record_thousandth_threshold_result(compare_column, row_npu)
-        elif row_npu[ApiPrecisionCompareColumn.DEVICE_DTYPE] not in BINARY_COMPARE_UNSUPPORT_LIST or \
-            api_name in binary_standard_api:
-            new_status = record_binary_consistency_result(api_name, compare_column, row_npu)
-        elif api_name in absolute_standard_api:
-            new_status = record_absolute_threshold_result(compare_column, row_npu)
-        elif api_name in ulp_standard_api and \
-            row_npu[ApiPrecisionCompareColumn.DEVICE_DTYPE] in ULP_COMPARE_SUPPORT_LIST:
-            us = ULPStandard(full_api_name_with_direction_status, row_npu, row_gpu)
-            new_status = record_ulp_compare_result(compare_column, us)
-        elif row_npu[ApiPrecisionCompareColumn.DEVICE_DTYPE] in BENCHMARK_COMPARE_SUPPORT_LIST:
-            bs = BenchmarkStandard(full_api_name_with_direction_status, row_npu, row_gpu)
-            new_status = record_benchmark_compare_result(compare_column, bs)
+        dtype = row_npu[ApiPrecisionCompareColumn.DEVICE_DTYPE]
+        input_data = PrecisionCompareInput(row_npu, row_gpu, dtype, compare_column)
+        comparison_func = registry.get_comparison_function(api_name, dtype)
+        new_status = comparison_func(input_data)
     return new_status
 
 
@@ -505,21 +309,24 @@ def check_csv_columns(columns, csv_type):
         raise CompareException(CompareException.INVALID_DATA_ERROR, msg)
 
 
-def record_binary_consistency_result(api_name, compare_column, row_npu):
+def record_binary_consistency_result(input_data):
+    row_npu = input_data.row_npu
+    compare_column = input_data.compare_column
     new_status = check_error_rate(row_npu[ApiPrecisionCompareColumn.ERROR_RATE])
     compare_column.error_rate = row_npu[ApiPrecisionCompareColumn.ERROR_RATE]
     compare_column.error_rate_status = new_status
     compare_column.compare_result = new_status
-    compare_column.compare_algorithm = "二进制一致法"
+    compare_column.compare_algorithm = CompareConst.BINARY_CONSISTENCY_ALGORITHM_NAME
     message = ''
     if compare_column.error_rate_status == CompareConst.ERROR:
         message += "ERROR: 二进制一致错误率超过阈值\n"
-        message += CompareMessage.get(api_name, "")
     compare_column.compare_message = message
     return new_status
 
 
-def record_absolute_threshold_result(compare_column, row_npu):
+def record_absolute_threshold_result(input_data):
+    row_npu = input_data.row_npu
+    compare_column = input_data.compare_column
     absolute_threshold_result = get_absolute_threshold_result(row_npu)
     compare_column.inf_nan_error_ratio = absolute_threshold_result.get("inf_nan_error_ratio")
     compare_column.inf_nan_error_ratio_status = absolute_threshold_result.get("inf_nan_result")
@@ -528,62 +335,88 @@ def record_absolute_threshold_result(compare_column, row_npu):
     compare_column.abs_err_ratio = absolute_threshold_result.get("abs_err_ratio")
     compare_column.abs_err_ratio_status = absolute_threshold_result.get("abs_err_result")
     compare_column.compare_result = absolute_threshold_result.get("absolute_threshold_result")
-    compare_column.compare_algorithm = "绝对阈值法"
+    compare_column.compare_algorithm = CompareConst.ABSOLUTE_THRESHOLD_ALGORITHM_NAME
     message = ''
     if compare_column.inf_nan_error_ratio_status == CompareConst.ERROR:
-        message += "ERROR: inf/nan错误率超过阈值\n"
+        message += "ERROR: inf/nan错误率超过阈值"
     if compare_column.rel_err_ratio_status == CompareConst.ERROR:
-        message += "ERROR: 相对误差错误率超过阈值\n"
+        message += "ERROR: 相对误差错误率超过阈值"
     if compare_column.abs_err_ratio_status == CompareConst.ERROR:
-        message += "ERROR: 绝对误差错误率超过阈值\n"
+        message += "ERROR: 绝对误差错误率超过阈值"
     compare_column.compare_message = message
     return compare_column.compare_result
 
 
-def record_benchmark_compare_result(compare_column, bs):
-    bs.get_result()
-    compare_column.small_value_err_ratio = bs.small_value_err_ratio
-    compare_column.small_value_err_status = bs.small_value_err_status
-    compare_column.rmse_ratio = bs.rmse_ratio
-    compare_column.rmse_status = bs.rmse_status
-    compare_column.max_rel_err_ratio = bs.max_rel_err_ratio
-    compare_column.max_rel_err_status = bs.max_rel_err_status
-    compare_column.mean_rel_err_ratio = bs.mean_rel_err_ratio
-    compare_column.mean_rel_err_status = bs.mean_rel_err_status
-    compare_column.eb_ratio = bs.eb_ratio
-    compare_column.eb_status = bs.eb_status
-    compare_column.compare_result = bs.final_result
-    compare_column.compare_algorithm = "标杆比对法"
-    compare_column.compare_message = bs.compare_message
+def record_benchmark_compare_result(input_data):
+    bs = BenchmarkPrecisionCompare(input_data)
+    compare_result = bs.compare()
     for status_attr, messages in benchmark_message.items():
-        status_value = getattr(compare_column, status_attr)
+        status_value = getattr(input_data.compare_column, status_attr)
         if status_value in messages:
-            compare_column.compare_message += messages[status_value]
-    return compare_column.compare_result
+            input_data.compare_column.compare_message += messages[status_value]
+    return compare_result
+
+
+def record_ulp_compare_result(input_data):
+    us = UlpPrecisionCompare(input_data)
+    compare_result = us.compare()
+    return compare_result
 
 
-def record_ulp_compare_result(compare_column, us):
-    us.get_result()
-    compare_column.mean_ulp_err = us.mean_ulp_err
-    compare_column.ulp_err_proportion = us.ulp_err_proportion
-    compare_column.ulp_err_proportion_ratio = us.ulp_err_proportion_ratio
-    compare_column.ulp_err_status = us.ulp_err_status
-    compare_column.compare_result = us.ulp_err_status
-    compare_column.compare_algorithm = "ULP误差比对法"
-    compare_column.compare_message = us.compare_message
+def record_accumulative_error_compare_result(input_data):
+    row_npu = input_data.row_npu
+    compare_column = input_data.compare_column
+    absolute_threshold_result = get_absolute_threshold_result(row_npu)
+    threshold_result = absolute_threshold_result.get("absolute_threshold_result")
+    eb, eb_result = check_eb(row_npu)
+    accumulative_error_compare_result = CompareConst.PASS
+    if CompareConst.ERROR in [threshold_result, eb_result]:
+        accumulative_error_compare_result = CompareConst.ERROR
+    
+    compare_column.inf_nan_error_ratio = absolute_threshold_result.get("inf_nan_error_ratio")
+    compare_column.inf_nan_error_ratio_status = absolute_threshold_result.get("inf_nan_result")
+    compare_column.rel_err_ratio = absolute_threshold_result.get("rel_err_ratio")
+    compare_column.rel_err_ratio_status = absolute_threshold_result.get("rel_err_result")
+    compare_column.abs_err_ratio = absolute_threshold_result.get("abs_err_ratio")
+    compare_column.abs_err_ratio_status = absolute_threshold_result.get("abs_err_result")
+    compare_column.eb_ratio = eb
+    compare_column.eb_status = eb_result
+    compare_column.compare_result = accumulative_error_compare_result
+    compare_column.compare_algorithm = CompareConst.ACCUMULATIVE_ERROR_COMPARE_ALGORITHM_NAME
+    message = []
+    if compare_column.inf_nan_error_ratio_status == CompareConst.ERROR:
+        message.append("ERROR: inf/nan错误率超过阈值\n")
+    if compare_column.rel_err_ratio_status == CompareConst.ERROR:
+        message.append("ERROR: 相对误差错误率超过阈值\n")
+    if compare_column.abs_err_ratio_status == CompareConst.ERROR:
+        message.append("ERROR: 绝对误差错误率超过阈值\n")
+    if compare_column.eb_status == CompareConst.ERROR:
+        message.append("ERROR: 误差均衡性超过阈值\n")
+    compare_column.compare_message = "\n".join(message)
     return compare_column.compare_result
 
 
+def check_eb(row_npu):
+    eb = convert_str_to_float(row_npu[ApiPrecisionCompareColumn.EB])
+    dtype = row_npu[ApiPrecisionCompareColumn.DEVICE_DTYPE]
+    eb_threshold = StandardConfig.get_accumulative_error_eb_threshold(dtype)
+    eb_result = CompareConst.PASS if eb <= eb_threshold else CompareConst.ERROR
+    return eb, eb_result
+
+
 def check_thousandth_rate(thousandth_rate):
-    return CompareConst.PASS if convert_str_to_float(thousandth_rate) >= 0.999 else CompareConst.ERROR
+    return CompareConst.PASS if convert_str_to_float(thousandth_rate) >= CompareConst.THOUSANDTH_PASS_VALUE \
+        else CompareConst.ERROR
 
 
-def record_thousandth_threshold_result(compare_column, row_npu):
+def record_thousandth_threshold_result(input_data):
+    row_npu = input_data.row_npu
+    compare_column = input_data.compare_column
     new_status = check_thousandth_rate(row_npu[ApiPrecisionCompareColumn.REL_ERR_THOUSANDTH])
     compare_column.rel_err_thousandth = row_npu[ApiPrecisionCompareColumn.REL_ERR_THOUSANDTH]
     compare_column.rel_err_thousandth_status = new_status
     compare_column.compare_result = new_status
-    compare_column.compare_algorithm = "双千指标法"
+    compare_column.compare_algorithm = CompareConst.THOUSANDTH_STANDARD_ALGORITHM_NAME
     message = ''
     if compare_column.rel_err_thousandth_status == CompareConst.ERROR:
         message += "ERROR: 双千指标不达标\n"

msprobe/pytorch/api_accuracy_checker/compare/api_precision_standard.yaml

@@ -66,6 +66,7 @@ BinaryCompareStandard:
   - greater_
   - greater_equal
   - greater_equal_
+  - histc
   - isfinite
   - isnan
   - less
@@ -130,4 +131,6 @@ ULPStandard:
 ThousandthStandard:
   - conv1d
   - conv2d
-  
+
+AccumulativeErrorStandard:
+  - test_api