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

msprobe/pytorch/api_accuracy_checker/compare/api_precision_compare.py

@@ -1,19 +1,20 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
-# All rights reserved.
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
 #
-# Licensed under the Apache License, Version 2.0  (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
 #
-# http://www.apache.org/licenses/LICENSE-2.0
+#          http://license.coscl.org.cn/MulanPSL2
 #
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
 
 import argparse
 import math
@@ -36,7 +37,7 @@ from msprobe.pytorch.api_accuracy_checker.precision_standard.ulp_compare import
 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.acc_check.acc_check_utils import get_validated_result_csv_path
 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
@@ -224,12 +225,20 @@ def get_api_status(row_npu, row_gpu, api_name, compare_column, registry):
     else:
         compare_column.api_name = full_api_name_with_direction_status
         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)
+        input_data = PrecisionCompareInput(row_npu, row_gpu, dtype, compare_column, api_name=api_name)
+        in_dtype = get_in_dtype(row_npu)
+        comparison_func = registry.get_comparison_function(api_name, dtype, in_dtype)
         new_status = comparison_func(input_data)
     return new_status
 
 
+def get_in_dtype(row_npu):
+    if row_npu[ApiPrecisionCompareColumn.REL_ERR_RATIO].isspace():
+        return "torch.float32"
+    else:
+        return "torch.float8_e4m3fn"
+
+
 def print_test_success(api_full_name, forward_result, backward_result):
     is_fwd_success = (forward_result == CompareConst.PASS)
     is_bwd_success = (backward_result == CompareConst.PASS or backward_result == CompareConst.SPACE)

msprobe/pytorch/api_accuracy_checker/compare/compare.py

@@ -1,19 +1,20 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
-# All rights reserved.
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
 #
-# Licensed under the Apache License, Version 2.0  (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
 #
-# http://www.apache.org/licenses/LICENSE-2.0
+#          http://license.coscl.org.cn/MulanPSL2
 #
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
 
 # 进行比对及结果展示
 import os
@@ -60,7 +61,8 @@ class Comparator:
     COLUMN_BACKWARD_SUCCESS = "Backward Test Success"
     COLUMN_STACK_INFO = "Traceback callstack info"
 
-    def __init__(self, result_csv_path, details_csv_path, is_continue_run_ut, stack_info_json_path=None, config=None):
+    def __init__(self, result_csv_path, details_csv_path, is_continue_acc_check,
+                 stack_info_json_path=None, config=None):
         self.save_path_str = result_csv_path
         self.detail_save_path_str = details_csv_path
         self.save_path_list = [result_csv_path]
@@ -68,7 +70,7 @@ class Comparator:
 
         self.registry = self._register_compare_func()
 
-        if not is_continue_run_ut:
+        if not is_continue_acc_check:
             self.write_csv_title()
         if stack_info_json_path:
             self.stack_info = get_json_contents(stack_info_json_path)
@@ -81,7 +83,7 @@ class Comparator:
 
     @staticmethod
     def print_pretest_result():
-        logger.info("Successfully completed run_ut/multi_run_ut.")
+        logger.info("Successfully completed acc_check/multi_acc_check.")
 
     @staticmethod
     def _compare_dropout(bench_output, device_output):
@@ -104,8 +106,8 @@ class Comparator:
         return CompareConst.PASS, compare_column, ""
 
     @staticmethod
-    def _get_run_ut_detail(test_result):
-        """get run_ut detail before write to csv, called by online run_ut"""
+    def _get_acc_check_detail(test_result):
+        """get acc_check detail before write to csv, called by online acc_check"""
         test_rows = []
         try:
             subject_prefix = test_result[0]
@@ -173,7 +175,7 @@ class Comparator:
                 write_csv(DETAIL_TEST_ROWS, detail_save_path)
 
     @recursion_depth_decorator("compare_core")
-    def _compare_core(self, api_name, bench_output, device_output):
+    def _compare_core(self, api_name, bench_output, device_output, is_fp8):
         compare_column = CompareColumn()
         if not isinstance(bench_output, type(device_output)):
             status = CompareConst.ERROR
@@ -185,7 +187,7 @@ class Comparator:
                 message = "bench and npu output dict keys are different."
             else:
                 status, compare_column, message = self._compare_core(api_name, list(bench_output.values()),
-                                                                     list(device_output.values()))
+                                                                     list(device_output.values()), is_fp8)
         elif isinstance(bench_output, torch.Tensor):
             copy_bench_out = bench_output.detach().clone()
             copy_device_output = device_output.detach().clone()
@@ -193,7 +195,7 @@ class Comparator:
             compare_column.npu_type = str(copy_device_output.dtype)
             compare_column.shape = tuple(device_output.shape)
             status, compare_column, message = self._compare_torch_tensor(api_name, copy_bench_out, copy_device_output,
-                                                                         compare_column)
+                                                                         compare_column, is_fp8)
         elif isinstance(bench_output, (bool, int, float, str)):
             compare_column.bench_type = str(type(bench_output))
             compare_column.npu_type = str(type(device_output))
@@ -227,7 +229,7 @@ class Comparator:
         write_csv(test_rows, save_path)
 
     def write_detail_csv(self, test_result):
-        test_rows = self._get_run_ut_detail(test_result)
+        test_rows = self._get_acc_check_detail(test_result)
         detail_save_path = self.get_path_from_rank(test_result[-1],
                                                    self.detail_save_path_list,
                                                    self.detail_save_path_str)
@@ -247,11 +249,12 @@ class Comparator:
         bench_output, device_output = data_info.bench_output, data_info.device_output
         bench_grad, device_grad = data_info.bench_grad, data_info.device_grad
         backward_message = data_info.backward_message
+        is_fp8 = data_info.is_fp8
         if "dropout" in full_api_name:
             fwd_success_status, fwd_compare_alg_results = self._compare_dropout(bench_output, device_output)
         else:
             fwd_success_status, fwd_compare_alg_results = self._compare_core_wrapper(api_name, bench_output,
-                                                                                     device_output)
+                                                                                     device_output, is_fp8)
         if not (bench_grad and device_grad):
             bwd_success_status, bwd_compare_alg_results = (CompareConst.SPACE, [])
         else:
@@ -259,7 +262,7 @@ class Comparator:
                 bwd_success_status, bwd_compare_alg_results = self._compare_dropout(bench_grad[0], device_grad[0])
             else:
                 bwd_success_status, bwd_compare_alg_results = self._compare_core_wrapper(api_name, bench_grad,
-                                                                                         device_grad)
+                                                                                         device_grad, is_fp8)
         if backward_message:
             backward_column = CompareColumn()
             bwd_compare_alg_results = [backward_column.to_column_value(CompareConst.SKIP, backward_message)]
@@ -272,7 +275,6 @@ class Comparator:
                                  fwd_compare_alg_results,
                                  bwd_compare_alg_results,
                                  data_info.rank)
-
         self.record_results(result_info)
         return fwd_success_status == CompareConst.PASS, bwd_success_status == CompareConst.PASS \
                or bwd_success_status == CompareConst.SPACE
@@ -287,7 +289,7 @@ class Comparator:
         registry.register(CompareConst.ACCUMULATIVE_ERROR_COMPARE, self._accumulative_error_compare)
         return registry
 
-    def _compare_core_wrapper(self, api_name, bench_output, device_output):
+    def _compare_core_wrapper(self, api_name, bench_output, device_output, is_fp8):
         detailed_result_total = []
         test_final_success = CompareConst.PASS
         if isinstance(bench_output, (list, tuple)):
@@ -298,12 +300,12 @@ class Comparator:
             else:
                 device_output = device_output[:len(bench_output)]
                 for b_out_i, n_out_i in zip(bench_output, device_output):
-                    status_i, compare_result_i, message_i = self._compare_core(api_name, b_out_i, n_out_i)
+                    status_i, compare_result_i, message_i = self._compare_core(api_name, b_out_i, n_out_i, is_fp8)
                     status.append(status_i)
                     compare_result.append(compare_result_i)
                     message.append(message_i)
         else:
-            status, compare_result, message = self._compare_core(api_name, bench_output, device_output)
+            status, compare_result, message = self._compare_core(api_name, bench_output, device_output, is_fp8)
         if not isinstance(status, list):
             detailed_result_total.append(compare_result.to_column_value(status, message))
             if status == CompareConst.ERROR:
@@ -319,10 +321,15 @@ class Comparator:
                     test_final_success = CompareConst.WARNING
         return test_final_success, detailed_result_total
 
-    def _compare_torch_tensor(self, api_name, bench_output, device_output, compare_column):
+    def _compare_torch_tensor(self, api_name, bench_output, device_output, compare_column, is_fp8):
         cpu_shape = bench_output.shape
         npu_shape = device_output.shape
+        
         npu_dtype = device_output.dtype
+        if is_fp8:
+            in_dtype = torch.float8_e4m3fn
+        else:
+            in_dtype = torch.float32
         if npu_dtype == torch.bfloat16:
             bench_output = bench_output.to(torch.float32)
             device_output = device_output.to(torch.float32)
@@ -346,22 +353,28 @@ class Comparator:
             compare_column.error_rate = err_rate
             return status, compare_column, message
         else:
+            in_and_out_dtype = {
+                'dtype': npu_dtype,
+                'in_dtype': in_dtype
+            }
             status, compare_column, message = self._compare_float_tensor(api_name, bench_output, device_output,
-                                                                         compare_column, npu_dtype)
+                                                                         compare_column, in_and_out_dtype)
             return status, compare_column, message
 
-    def _perform_comparison(self, api_name, input_data):
-        comparison_func = self.registry.get_comparison_function(api_name, None)
+    def _perform_comparison(self, api_name, input_data, dtype, in_dtype):
+        comparison_func = self.registry.get_comparison_function(api_name, dtype, in_dtype)
         comparison_func(input_data)
             
-    def _compare_float_tensor(self, api_name, bench_output, device_output, compare_column, dtype):
+    def _compare_float_tensor(self, api_name, bench_output, device_output, compare_column, in_and_out_dtype):
+        dtype = in_and_out_dtype.get('dtype')
+        in_dtype = in_and_out_dtype.get('in_dtype')
         message = ""
         _, abs_bench_with_eps = get_abs_bench_with_eps(bench_output, dtype)
         abs_err = get_abs_err(bench_output, device_output)
         rel_err_orign = get_rel_err_origin(abs_err, abs_bench_with_eps)
         input_data = CompareInput(bench_output, device_output, compare_column, dtype, rel_err_orign)
         if str(dtype) in BENCHMARK_COMPARE_SUPPORT_LIST:
-            self._perform_comparison(api_name, input_data)
+            self._perform_comparison(api_name, input_data, dtype, in_dtype)
         else:
             message += f"The data type {dtype} is not supported for new precision standard."
 

msprobe/pytorch/api_accuracy_checker/compare/compare_column.py

@@ -1,19 +1,20 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
-# All rights reserved.
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
 #
-# Licensed under the Apache License, Version 2.0  (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
 #
-# http://www.apache.org/licenses/LICENSE-2.0
+#          http://license.coscl.org.cn/MulanPSL2
 #
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
 
 from msprobe.core.common.const import CompareConst
 from msprobe.pytorch.common.log import logger

msprobe/pytorch/api_accuracy_checker/compare/compare_input.py

@@ -1,19 +1,20 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
-# All rights reserved.
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
 #
-# Licensed under the Apache License, Version 2.0  (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
 #
-# http://www.apache.org/licenses/LICENSE-2.0
+#          http://license.coscl.org.cn/MulanPSL2
 #
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
 
 import numpy as np
 
@@ -44,8 +45,9 @@ class CompareInput:
 
 
 class PrecisionCompareInput:
-    def __init__(self, row_npu, row_gpu, dtype, compare_column):
+    def __init__(self, row_npu, row_gpu, dtype, compare_column, api_name=None):
         self.row_npu = row_npu
         self.row_gpu = row_gpu
         self.dtype = dtype
         self.compare_column = compare_column
+        self.api_name = api_name

msprobe/pytorch/api_accuracy_checker/compare/compare_utils.py

@@ -1,19 +1,20 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
-# All rights reserved.
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
 #
-# Licensed under the Apache License, Version 2.0  (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
 #
-# http://www.apache.org/licenses/LICENSE-2.0
+#          http://license.coscl.org.cn/MulanPSL2
 #
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
 
 import time
 import os
@@ -30,7 +31,8 @@ from msprobe.pytorch.common.log import logger
 current_time = time.strftime("%Y%m%d%H%M%S")
 API_PRECISION_COMPARE_RESULT_FILE_NAME = "api_precision_compare_result_" + current_time + ".csv"
 API_PRECISION_COMPARE_DETAILS_FILE_NAME = "api_precision_compare_details_" + current_time + ".csv"
-BENCHMARK_COMPARE_SUPPORT_LIST = ['torch.float16', 'torch.bfloat16', 'torch.float32']
+BENCHMARK_COMPARE_SUPPORT_LIST = ['torch.float16', 'torch.bfloat16', 'torch.float32', "torch.float8_e4m3fn", 
+                                  "torch.float8_e5m2"]
 API_PRECISION_COMPARE_UNSUPPORT_LIST = ['torch.float64', 'torch.complex64', 'torch.complex128']
 ULP_COMPARE_SUPPORT_LIST = ['torch.float16', 'torch.bfloat16', 'torch.float32']
 BINARY_COMPARE_UNSUPPORT_LIST = BENCHMARK_COMPARE_SUPPORT_LIST + API_PRECISION_COMPARE_UNSUPPORT_LIST

msprobe/pytorch/api_accuracy_checker/precision_standard/absolute_threshold.py

@@ -1,19 +1,20 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
-# All rights reserved.
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
 #
-# Licensed under the Apache License, Version 2.0  (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
 #
-# http://www.apache.org/licenses/LICENSE-2.0
+#          http://license.coscl.org.cn/MulanPSL2
 #
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
 
 import numpy as np
 

msprobe/pytorch/api_accuracy_checker/precision_standard/accumulative_error_compare.py

@@ -1,19 +1,20 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
-# All rights reserved.
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
 #
-# Licensed under the Apache License, Version 2.0  (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
 #
-# http://www.apache.org/licenses/LICENSE-2.0
+#          http://license.coscl.org.cn/MulanPSL2
 #
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
 
 import numpy as np
 

msprobe/pytorch/api_accuracy_checker/precision_standard/base_standard.py

@@ -1,19 +1,20 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
-# All rights reserved.
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
 #
-# Licensed under the Apache License, Version 2.0  (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
 #
-# http://www.apache.org/licenses/LICENSE-2.0
+#          http://license.coscl.org.cn/MulanPSL2
 #
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
 
 from abc import ABC, abstractmethod
 import numpy as np
@@ -119,6 +120,13 @@ class BasePrecisionCompare:
         self.compare_column = input_data.compare_column
         self.compare_algorithm = None
     
+    @staticmethod
+    def _get_and_convert_value(row_data, column_name, device_type):
+        value = row_data.get(column_name)
+        if value is None:
+            raise ValueError(f"{device_type} value for column '{column_name}' is None.")
+        return convert_str_to_float(value)
+
     @abstractmethod
     def _get_status(self, metrics, inf_nan_consistency):
         pass
@@ -133,14 +141,8 @@ class BasePrecisionCompare:
         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)
+        npu_value = self._get_and_convert_value(self.row_npu, column_name, "NPU")
+        gpu_value = self._get_and_convert_value(self.row_gpu, column_name, "GPU")
         return npu_value, gpu_value
 
     def _post_compare(self, metrics, inf_nan_consistency):

msprobe/pytorch/api_accuracy_checker/precision_standard/benchmark_compare.py

@@ -1,19 +1,20 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
-# All rights reserved.
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
 #
-# Licensed under the Apache License, Version 2.0  (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
 #
-# http://www.apache.org/licenses/LICENSE-2.0
+#          http://license.coscl.org.cn/MulanPSL2
 #
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
 
 import math
 from collections import namedtuple
@@ -136,6 +137,7 @@ class BenchmarkPrecisionCompare(BasePrecisionCompare):
     def __init__(self, input_data):
         super().__init__(input_data)
         self.compare_algorithm = CompareConst.BENCHMARK_COMPARE_ALGORITHM_NAME
+        self.api_name = getattr(input_data, "api_name", None)
 
     @staticmethod
     def get_final_status(status_list):
@@ -184,8 +186,7 @@ class BenchmarkPrecisionCompare(BasePrecisionCompare):
                                           eb_inf_nan_consistency)
 
     def _get_threshold(self, metric):
-        error_threshold = StandardConfig.get_benchmark_threshold(metric)
-        return error_threshold
+        return StandardConfig.get_benchmark_ratio_threshold(metric, api_name=self.api_name)
 
     def _get_single_metric_status(self, ratio, metric):
         if is_inf_or_nan(ratio):

msprobe/pytorch/api_accuracy_checker/precision_standard/binary_consistency.py

@@ -1,19 +1,20 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
-# All rights reserved.
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
 #
-# Licensed under the Apache License, Version 2.0  (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
 #
-# http://www.apache.org/licenses/LICENSE-2.0
+#          http://license.coscl.org.cn/MulanPSL2
 #
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
 
 from msprobe.pytorch.api_accuracy_checker.compare.algorithm import compare_bool_tensor
 from msprobe.pytorch.api_accuracy_checker.precision_standard.base_standard import BaseCompare