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

msprobe/pytorch/api_accuracy_checker/precision_standard/base_standard.py

@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0  (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from abc import ABC, abstractmethod
+import numpy as np
+from msprobe.pytorch.api_accuracy_checker.compare.compare_utils import convert_str_to_float
+from msprobe.pytorch.api_accuracy_checker.compare.algorithm import get_abs_bench_with_eps, get_abs_err, \
+    get_finite_and_infinite_mask, get_small_value_mask
+from msprobe.pytorch.api_accuracy_checker.precision_standard.standard_config import StandardConfig
+
+
+class BaseCompare(ABC):
+    """
+    Base comparison class for benchmarking and device output.
+
+    This class provides a foundation for comparing benchmark outputs with device outputs.
+    It encapsulates the common logic for calculating accuracy metrics and
+    provides a framework for subclasses to implement specific comparison logic.
+
+    Attributes:
+        bench_output (np.ndarray): The output from the benchmark.
+        device_output (np.ndarray): The output from the device.
+        compare_column (object): The column object to store comparison results.
+        dtype (torch.dtype): The data type of the outputs.
+
+    Methods:
+        get_small_value_threshold(): Retrieves the small value threshold for the given data type.
+        stat_abs_bench_with_eps(): Calculates the absolute benchmark output with epsilon.
+        stat_abs_error(): Calculates the absolute error between the benchmark and device outputs.
+        stat_finite_and_infinite_mask(): Generates masks for finite and infinite/NaN values.
+        stat_small_value_mask(abs_bench, both_finite_mask, small_value): Creates a mask for small values.
+        compare(): Performs the comparison and computes metrics.
+        _pre_compare(): Pre-comparison hook for subclass-specific initialization.
+        _compute_metrics(): Computes the comparison metrics.
+        _post_compare(metrics): Post-comparison hook to update comparison results.
+
+    Note:
+        This class assumes that the input data is an instance of InputData containing the benchmark output,
+        device output, comparison column, and data type. Subclasses should implement the _pre_compare,
+        _compute_metrics, and _post_compare methods to provide specific comparison logic.
+
+    See Also:
+        InputData: The class containing input data for comparison.
+        StandardConfig: The class containing standard configuration values.
+    """
+    def __init__(self, input_data):
+        self.bench_output = input_data.bench_output
+        self.device_output = input_data.device_output
+        self.compare_column = input_data.compare_column
+        self.dtype = input_data.dtype
+        self.compare_algorithm = None
+
+    @staticmethod
+    def stat_small_value_mask(abs_bench, both_finite_mask, small_value):
+        small_value_mask = get_small_value_mask(abs_bench, both_finite_mask, small_value)
+        return small_value_mask
+    
+    @staticmethod
+    def _get_rel_err(abs_err, abs_bench_with_eps):
+        rel_err = abs_err / abs_bench_with_eps
+        return rel_err
+    
+    @staticmethod
+    def _get_normal_value_mask(both_finite_mask, small_value_mask):
+        return np.logical_and(both_finite_mask, np.logical_not(small_value_mask))
+
+    @abstractmethod
+    def _pre_compare(self):
+        raise NotImplementedError
+
+    def get_small_value_threshold(self):
+        small_value = StandardConfig.get_small_value(self.dtype, self.compare_algorithm)
+        small_value_atol = StandardConfig.get_small_value_atol(self.dtype, self.compare_algorithm)
+        return small_value, small_value_atol
+    
+    def stat_abs_bench_with_eps(self):
+        abs_bench, abs_bench_with_eps = get_abs_bench_with_eps(self.bench_output, self.dtype)
+        return abs_bench, abs_bench_with_eps
+    
+    def stat_abs_error(self):
+        abs_err = get_abs_err(self.bench_output, self.device_output)
+        return abs_err
+    
+    def stat_finite_and_infinite_mask(self):
+        both_finite_mask, inf_nan_mask = get_finite_and_infinite_mask(self.bench_output, self.device_output)
+        return both_finite_mask, inf_nan_mask
+
+    def compare(self):
+        self._pre_compare()
+        metrics = self._compute_metrics()
+        self._post_compare(metrics)
+
+    def _compute_metrics(self):
+        return {}
+    
+    def _post_compare(self, metrics):
+        self.compare_column.update(metrics)
+
+
+class BasePrecisionCompare:
+    def __init__(self, input_data):
+        self.row_npu = input_data.row_npu
+        self.row_gpu = input_data.row_gpu
+        self.dtype = input_data.dtype
+        self.compare_column = input_data.compare_column
+        self.compare_algorithm = None
+    
+    @abstractmethod
+    def _get_status(self, metrics, inf_nan_consistency):
+        pass
+
+    @abstractmethod
+    def _compute_ratio(self):
+        pass
+
+    def compare(self):
+        metrics, inf_nan_consistency = self._compute_ratio()
+        compare_result = self._post_compare(metrics, inf_nan_consistency)
+        return compare_result
+    
+    def _get_and_convert_values(self, column_name):
+        npu_value = self.row_npu.get(column_name)
+        gpu_value = self.row_gpu.get(column_name)
+        if npu_value is None:
+            raise ValueError(f"NPU value for column '{column_name}' is None.")
+        if gpu_value is None:
+            raise ValueError(f"GPU value for column '{column_name}' is None.")
+        npu_value = convert_str_to_float(npu_value)
+        gpu_value = convert_str_to_float(gpu_value)
+        return npu_value, gpu_value
+
+    def _post_compare(self, metrics, inf_nan_consistency):
+        metrics = self._get_status(metrics, inf_nan_consistency)
+        metrics.update({'compare_algorithm': self.compare_algorithm})
+        self.compare_column.update(metrics)
+        compare_result = metrics.get('compare_result')
+        return compare_result

msprobe/pytorch/api_accuracy_checker/precision_standard/benchmark_compare.py

@@ -0,0 +1,226 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0  (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import math
+from collections import namedtuple
+import numpy as np
+
+from msprobe.pytorch.api_accuracy_checker.precision_standard.standard_config import StandardConfig
+from msprobe.pytorch.api_accuracy_checker.precision_standard.base_standard import BaseCompare, BasePrecisionCompare
+from msprobe.pytorch.api_accuracy_checker.compare.algorithm import calc_ratio, get_small_value_err_ratio, get_rel_err, \
+    get_rmse, get_error_balance, get_max_rel_err, get_mean_rel_err
+from msprobe.pytorch.api_accuracy_checker.compare.compare_utils import ApiPrecisionCompareColumn, check_inf_or_nan, \
+    is_inf_or_nan
+from msprobe.core.common.const import CompareConst
+
+
+BenchmarkInfNanConsistency = namedtuple('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 BenchmarkCompare(BaseCompare):
+    """
+    Benchmark comparison class for calculating accuracy metrics.
+
+    This class is designed to compare the output of a benchmark test with the output of a device.
+    It calculates various metrics such as small value error ratio, RMSE, error balance, max relative error,
+    and mean relative error to assess the accuracy of the device output against the benchmark output.
+
+    Attributes:
+        bench_output (np.ndarray): The output from the benchmark.
+        device_output (np.ndarray): The output from the device.
+        dtype (torch.dtype): The data type of the outputs.
+        abs_bench (np.ndarray): The absolute value of the benchmark output.
+        abs_bench_with_eps (np.ndarray): The absolute value of the benchmark output with epsilon.
+        both_finite_mask (np.ndarray): A mask indicating where both outputs are finite.
+        inf_nan_mask (np.ndarray): A mask indicating where either output is infinite or NaN.
+        abs_err (np.ndarray): The absolute error between the benchmark and device outputs.
+        small_value (float): The small value threshold for comparison.
+        small_value_atol (float): The absolute tolerance for small values.
+        small_value_mask (np.ndarray): A mask indicating where values are small.
+        rel_err (np.ndarray): The relative error between the benchmark and device outputs.
+        abs_err_greater_mask (np.ndarray): A mask indicating where absolute error is greater than the small value 
+        tolerance.
+
+    Methods:
+        _get_abs_err_greater_mask(small_value_atol): Calculates a mask where absolute error is greater than the small 
+        value tolerance.
+        _compute_rel_err(): Computes the relative error between the benchmark and device outputs.
+        _pre_compare(): Prepares the comparison by calculating various metrics.
+        _compute_metrics(): Computes the accuracy metrics.
+
+    Note:
+        This class assumes that the input data is a dictionary containing 'bench_output', 'device_output', 
+        'compare_column' and 'dtype'. 
+        The data type should be a PyTorch data type.
+
+    See Also:
+        BaseCompare: The base class for comparison classes.
+        InputData: The class containing input data for comparison.
+    """
+
+    def __init__(self, input_data):
+        super(BenchmarkCompare, self).__init__(input_data)
+        self.compare_algorithm = CompareConst.BENCHMARK
+
+    def _get_abs_err_greater_mask(self, small_value_atol):
+        abs_err_greater_mask = np.greater(self.abs_err, small_value_atol)
+        return abs_err_greater_mask
+    
+    def _compute_rel_err(self):
+        rel_err = get_rel_err(self.abs_err, self.abs_bench_with_eps, self.small_value_mask, self.inf_nan_mask)
+        return rel_err
+    
+    def _pre_compare(self):
+        self.abs_bench, self.abs_bench_with_eps = self.stat_abs_bench_with_eps()
+        self.both_finite_mask, self.inf_nan_mask = self.stat_finite_and_infinite_mask()
+        self.abs_err = self.stat_abs_error()
+        self.small_value, self.small_value_atol = self.get_small_value_threshold()
+        self.small_value_mask = self.stat_small_value_mask(self.abs_bench, self.both_finite_mask, self.small_value)
+        self.rel_err = self._compute_rel_err()
+        self.abs_err_greater_mask = self._get_abs_err_greater_mask(self.small_value_atol)
+
+    def _compute_metrics(self):
+        """
+        Computes a comprehensive set of error metrics for the comparison between benchmark and device outputs.
+
+        This method calculates five key metrics:
+        1. Small Value Error Ratio: The proportion of errors associated with small values.
+        2. Root Mean Square Error (RMSE): The square root of the mean of the squared errors.
+        3. Error Balance (EB): A measure of the balance between the errors in the benchmark and device outputs.
+        4. Maximum Relative Error: The maximum relative error between the benchmark and device outputs.
+        5. Mean Relative Error: The mean relative error between the benchmark and device outputs.
+        
+        Returns:
+        dict: A dictionary containing the computed error metrics.
+            The dictionary has the following keys:
+            - "small_value_err_ratio": The proportion of errors associated with small values.
+            - "max_rel_error": The maximum relative error.
+            - "mean_rel_error": The mean relative error.
+            - "rmse": The root mean square error.
+            - "eb": The error balance.
+        """
+        small_value_err_ratio = get_small_value_err_ratio(self.small_value_mask, self.abs_err_greater_mask)
+        rmse = get_rmse(self.abs_err, np.logical_or(self.inf_nan_mask, self.small_value_mask))
+        eb = get_error_balance(self.bench_output, self.device_output)
+        max_rel_error = get_max_rel_err(self.rel_err)
+        mean_rel_error = get_mean_rel_err(self.rel_err)
+
+        return {
+            "small_value_err_ratio": small_value_err_ratio,
+            "max_rel_error": max_rel_error,
+            "mean_rel_error": mean_rel_error,
+            "rmse": rmse,
+            "eb": eb
+        }
+
+
+class BenchmarkPrecisionCompare(BasePrecisionCompare):
+    def __init__(self, input_data):
+        super().__init__(input_data)
+        self.compare_algorithm = CompareConst.BENCHMARK_COMPARE_ALGORITHM_NAME
+
+    @staticmethod
+    def get_final_status(status_list):
+        compare_result = CompareConst.PASS
+        if CompareConst.ERROR in status_list:
+            compare_result = CompareConst.ERROR
+        elif CompareConst.WARNING in status_list:
+            compare_result = CompareConst.WARNING
+        return compare_result
+    
+    def _calc_ratio(self, column_name):
+        npu_value, gpu_value = self._get_and_convert_values(column_name)
+        if is_inf_or_nan(npu_value) or is_inf_or_nan(gpu_value):
+            return check_inf_or_nan(npu_value, gpu_value, column_name)
+        else:
+            return calc_ratio(npu_value, gpu_value, str(self.dtype)), True, ""
+
+    def _compute_ratio(self):
+        compare_message = ""
+        small_value_err_ratio, small_value_inf_nan_consistency, small_value_message = \
+            self._calc_ratio(ApiPrecisionCompareColumn.SMALL_VALUE_ERROR_RATE)
+        compare_message += small_value_message
+        rmse_ratio, rmse_inf_nan_consistency, rmse_message = self._calc_ratio(ApiPrecisionCompareColumn.RMSE)
+        compare_message += rmse_message
+        max_rel_err_ratio, max_rel_inf_nan_consistency, max_rel_message = \
+            self._calc_ratio(ApiPrecisionCompareColumn.MAX_REL_ERR)
+        compare_message += max_rel_message
+        mean_rel_err_ratio, mean_rel_inf_nan_consistency, mean_rel_message = \
+            self._calc_ratio(ApiPrecisionCompareColumn.MEAN_REL_ERR)
+        compare_message += mean_rel_message
+        eb_ratio, eb_inf_nan_consistency, eb_message = self._calc_ratio(ApiPrecisionCompareColumn.EB)
+        compare_message += eb_message
+        
+        metrics = {
+            CompareConst.SMALL_VALUE_ERR_RATIO: small_value_err_ratio,
+            CompareConst.RMSE_RATIO: rmse_ratio,
+            CompareConst.MAX_REL_ERR_RATIO: max_rel_err_ratio,
+            CompareConst.MEAN_REL_ERR_RATIO: mean_rel_err_ratio,
+            CompareConst.EB_RATIO: eb_ratio,
+            CompareConst.COMPARE_MESSAGE: compare_message
+        }
+        
+        return metrics, \
+               BenchmarkInfNanConsistency(small_value_inf_nan_consistency, rmse_inf_nan_consistency, 
+                                          max_rel_inf_nan_consistency, mean_rel_inf_nan_consistency,
+                                          eb_inf_nan_consistency)
+
+    def _get_threshold(self, metric):
+        error_threshold = StandardConfig.get_benchmark_threshold(metric)
+        return error_threshold
+
+    def _get_single_metric_status(self, ratio, metric):
+        if is_inf_or_nan(ratio):
+            return CompareConst.PASS
+        error_threshold = self._get_threshold(metric)
+        if ratio > error_threshold:
+            return CompareConst.ERROR
+        return CompareConst.PASS
+
+    def _get_status(self, metrics, inf_nan_consistency):
+        small_value_err_ratio = metrics.get(CompareConst.SMALL_VALUE_ERR_RATIO)
+        rmse_ratio = metrics.get(CompareConst.RMSE_RATIO)
+        max_rel_err_ratio = metrics.get(CompareConst.MAX_REL_ERR_RATIO)
+        mean_rel_err_ratio = metrics.get(CompareConst.MEAN_REL_ERR_RATIO)
+        eb_ratio = metrics.get(CompareConst.EB_RATIO)
+        
+        small_value_err_status = self._get_single_metric_status(small_value_err_ratio, CompareConst.SMALL_VALUE) \
+                                        if inf_nan_consistency.small_value_inf_nan_consistency else CompareConst.ERROR
+        rmse_status = self._get_single_metric_status(rmse_ratio, CompareConst.RMSE)  \
+                                        if inf_nan_consistency.rmse_inf_nan_consistency else CompareConst.ERROR
+        max_rel_err_status = self._get_single_metric_status(max_rel_err_ratio, CompareConst.MAX_REL_ERR) \
+                                        if inf_nan_consistency.max_rel_inf_nan_consistency else CompareConst.ERROR
+        mean_rel_err_status = self._get_single_metric_status(mean_rel_err_ratio, CompareConst.MEAN_REL_ERR) \
+                                        if inf_nan_consistency.mean_rel_inf_nan_consistency else CompareConst.ERROR
+        eb_status = self._get_single_metric_status(eb_ratio, CompareConst.EB) \
+                                        if inf_nan_consistency.eb_inf_nan_consistency else CompareConst.ERROR
+        status_list = [small_value_err_status, rmse_status, max_rel_err_status, mean_rel_err_status]
+        compare_result = self.get_final_status(status_list)
+        status_dict = {
+            CompareConst.SMALL_VALUE_ERR_STATUS: small_value_err_status,
+            CompareConst.RMSE_STATUS: rmse_status,
+            CompareConst.MAX_REL_ERR_STATUS: max_rel_err_status,
+            CompareConst.MEAN_REL_ERR_STATUS: mean_rel_err_status,
+            CompareConst.EB_STATUS: eb_status
+        }
+        metrics.update(status_dict)
+        metrics.update({CompareConst.COMPARE_RESULT: compare_result})
+        return metrics

msprobe/pytorch/api_accuracy_checker/precision_standard/binary_consistency.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0  (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from msprobe.pytorch.api_accuracy_checker.compare.algorithm import compare_bool_tensor
+from msprobe.pytorch.api_accuracy_checker.precision_standard.base_standard import BaseCompare
+
+
+class BinaryCompare(BaseCompare):
+    """
+    Binary comparison class for comparing boolean tensors.
+
+    This class is designed to compare the output of a binary operation between a benchmark and a device.
+    It calculates the error rate of the comparison and provides a simple metric for assessing the accuracy.
+
+    Attributes:
+        bench_output (np.ndarray): The output from the benchmark.
+        device_output (np.ndarray): The output from the device.
+        compare_column (object): The column object to store comparison results.
+        dtype (torch.dtype): The data type of the outputs.
+
+    Methods:
+        _compute_metrics(): Computes the comparison metrics, specifically the error rate.
+
+    Note:
+        This class assumes that the input data is an instance of InputData containing the benchmark output,
+        device output, comparison column, and data type. The outputs are expected to be boolean tensors.
+
+    See Also:
+        BaseCompare: The base class for comparison classes.
+        compare_bool_tensor: The function used to compare boolean tensors.
+    """
+    def __init__(self, input_data):
+        super(BinaryCompare, self).__init__(input_data)
+
+    def _pre_compare(self):
+        pass
+
+    def _compute_metrics(self):
+        """
+        Computes the error rate metric for the comparison between benchmark and device outputs.
+
+        This method calculates the proportion of mismatches between the benchmark output and the device output.
+        It uses the `compare_bool_tensor` function to compare the two tensors and extract the error rate.
+
+        Returns:
+        dict: A dictionary containing the computed error rate metric.
+            The dictionary has the following key:
+            - "error_rate": The proportion of mismatches between the benchmark and device outputs.
+        """
+        error_rate, _, _ = compare_bool_tensor(self.bench_output, self.device_output)
+
+        return {
+            "error_rate": error_rate
+        }

msprobe/pytorch/api_accuracy_checker/precision_standard/standard_config.py

@@ -0,0 +1,218 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0  (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import torch
+
+from msprobe.core.common.const import CompareConst
+
+
+class StandardConfig:
+    """
+    Standard configuration class for managing precision and comparison thresholds.
+
+    This class provides a centralized way to manage the small value thresholds, absolute tolerances,
+    and relative tolerances (rtol) used in precision comparisons. It allows for different thresholds
+    based on the data type, with default values provided for common data types.
+
+    Attributes:
+        _small_value (dict): A dictionary mapping data types to their corresponding small value thresholds.
+        _small_value_atol (dict): A dictionary mapping data types to their corresponding absolute tolerances.
+        _rtol (dict): A dictionary mapping data types to their corresponding relative tolerances.
+
+    Methods:
+        get_small_value(dtype): Retrieves the small value threshold for the given data type.
+        get_small_value_atol(dtype): Retrieves the absolute tolerance for the given data type.
+        get_rtol(dtype): Retrieves the relative tolerance for the given data type.
+
+    Example:
+        >>> small_value = StandardConfig.get_small_value(torch.float32)
+        >>> atol = StandardConfig.get_small_value_atol(torch.float32)
+        >>> rtol = StandardConfig.get_rtol(torch.float32)
+        >>> print(small_value, atol, rtol)
+        1e-6 1e-9 1e-6
+
+    Note:
+        The data type is expected to be a PyTorch data type. If the data type is not found in the dictionary,
+        the default value is returned.
+
+    See Also:
+        torch.dtype: PyTorch data types.
+    """
+    _small_value = {
+        torch.float16: 2**-10,
+        torch.bfloat16: 2**-10,
+        torch.float32: 2**-20,
+        "default": 2**-20
+    }
+    _threshold_small_value_atol = {
+        torch.float16: 2**-16,
+        torch.bfloat16: 1e-16,
+        torch.float32: 2**-30,
+        "default": 2**-30
+    }
+    _benchmark_small_value_atol = {
+        torch.float16: 1e-16,
+        torch.bfloat16: 1e-16,
+        torch.float32: 2**-30,
+        "default": 2**-30
+    }
+    _rtol = {
+        torch.float16: 2**-10,
+        torch.bfloat16: 2**-8,
+        torch.float32: 2**-20,
+        "default": 2**-20
+    }
+    _accumulative_error_bound = {
+        torch.float16: 2**-8,
+        torch.bfloat16: 2**-7,
+        torch.float32: 2**-11,
+        "default": 2**-11
+    }
+    _small_value_threshold = {
+        'error_threshold': 2,
+        'warning_threshold': 1,
+        "default": 1
+    }
+    _rmse_threshold = {
+        'error_threshold': 2,
+        'warning_threshold': 1,
+        "default": 1
+    }
+    _max_rel_err_threshold = {
+        'error_threshold': 10,
+        'warning_threshold': 1,
+        "default": 1
+    }
+    _mean_rel_err_threshold = {
+        'error_threshold': 2,
+        'warning_threshold': 1,
+        "default": 1
+    }
+    _eb_threshold = {
+        'error_threshold': 2,
+        'warning_threshold': 1,
+        "default": 1
+    }
+    _minmum_err = {
+        'torch.float16': 2**-11,
+        'torch.bfloat16': 2**-8,
+        'torch.float32': 2**-14,
+        'default': 2**-14
+    }
+    _accumulative_error_eb_threshold = {
+        'torch.float16': 2**-20,
+        'torch.bfloat16': 2**-7,
+        'torch.float32': 2**-14,
+        'default': 2**-14
+    }
+    
+    _fp32_mean_ulp_err_threshold = 64
+    ulp_err_proportion_ratio = 1
+    _fp32_ulp_err_proportion = 0.05
+    _fp16_ulp_err_proportion = 0.001
+    _special_samll_value = 1
+    
+    @classmethod
+    def get_small_value(cls, dtype, standard):
+        if standard == CompareConst.ACCUMULATIVE_ERROR_COMPARE:
+            return cls._special_samll_value
+        return cls._small_value.get(dtype, cls._small_value["default"])
+    
+    @classmethod
+    def get_small_value_atol(cls, dtype, standard):
+        standard_dict = {
+            CompareConst.ABSOLUTE_THRESHOLD: cls._threshold_small_value_atol,
+            CompareConst.BENCHMARK: cls._benchmark_small_value_atol
+        }
+        small_value_atol_standard = standard_dict.get(standard, cls._benchmark_small_value_atol)
+        return small_value_atol_standard.get(dtype, small_value_atol_standard["default"])
+    
+    @classmethod
+    def get_rtol(cls, dtype):
+        return cls._rtol.get(dtype, cls._rtol["default"])
+    
+    @classmethod
+    def get_small_value_threshold(cls, threshold_type):
+        return cls._small_value_threshold.get(threshold_type, cls._small_value_threshold["default"])
+    
+    @classmethod
+    def get_rmse_threshold(cls, threshold_type):
+        return cls._rmse_threshold.get(threshold_type, cls._rmse_threshold["default"])
+    
+    @classmethod
+    def get_max_rel_err_threshold(cls, threshold_type):
+        return cls._max_rel_err_threshold.get(threshold_type, cls._max_rel_err_threshold["default"])
+    
+    @classmethod
+    def get_mean_rel_err_threshold(cls, threshold_type):
+        return cls._mean_rel_err_threshold.get(threshold_type, cls._mean_rel_err_threshold["default"])
+    
+    @classmethod
+    def get_eb_threshold(cls, threshold_type):
+        return cls._eb_threshold.get(threshold_type, cls._eb_threshold["default"])
+    
+    @classmethod
+    def get_benchmark_threshold(cls, metric):
+        metric_threshold_functions = {
+            'small_value': StandardConfig.get_small_value_threshold,
+            'rmse': StandardConfig.get_rmse_threshold,
+            'max_rel_err': StandardConfig.get_max_rel_err_threshold,
+            'mean_rel_err': StandardConfig.get_mean_rel_err_threshold,
+            'eb': StandardConfig.get_eb_threshold
+        }
+        
+        threshold_func = metric_threshold_functions.get(metric)
+        return threshold_func('error_threshold')
+
+    @classmethod
+    def get_fp32_mean_ulp_err_threshold(cls):
+        return cls._fp32_mean_ulp_err_threshold
+
+    @classmethod
+    def get_ulp_err_proportion_ratio_threshold(cls):
+        return cls.ulp_err_proportion_ratio
+
+    @classmethod
+    def get_fp32_ulp_err_proportion_threshold(cls):
+        return cls._fp32_ulp_err_proportion
+
+    @classmethod
+    def get_fp16_ulp_err_proportion_threshold(cls):
+        return cls._fp16_ulp_err_proportion
+    
+    @classmethod
+    def get_ulp_threshold(cls, dtype):
+        ulp_err_proportion_ratio_threshold = StandardConfig.get_ulp_err_proportion_ratio_threshold()
+        if dtype == torch.float32:
+            mean_ulp_err_threshold = StandardConfig.get_fp32_mean_ulp_err_threshold()
+            ulp_err_proportion_threshold = StandardConfig.get_fp32_ulp_err_proportion_threshold()
+            return mean_ulp_err_threshold, ulp_err_proportion_threshold, ulp_err_proportion_ratio_threshold
+        else:
+            ulp_err_proportion_threshold = StandardConfig.get_fp16_ulp_err_proportion_threshold()
+            return None, ulp_err_proportion_threshold, ulp_err_proportion_ratio_threshold
+
+    @classmethod
+    def get_minmum_err(cls, dtype):
+        return cls._minmum_err.get(dtype, cls._minmum_err["default"])
+    
+    @classmethod
+    def get_accumulative_error_bound(cls, dtype):
+        return cls._accumulative_error_bound.get(dtype, cls._accumulative_error_bound["default"])
+    
+    @classmethod
+    def get_accumulative_error_eb_threshold(cls, dtype):
+        return cls._accumulative_error_eb_threshold.get(dtype, cls._accumulative_error_eb_threshold["default"])