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

msprobe/pytorch/api_accuracy_checker/{run_ut → acc_check}/data_generate.py

@@ -1,28 +1,37 @@
 #!/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
 import math
 import torch
 import numpy
 
-from msprobe.pytorch.api_accuracy_checker.run_ut.run_ut_utils import hf_32_standard_api
+try:
+    import torch_npu
+except ImportError:
+    IS_GPU = True
+else:
+    IS_GPU = False
+
+from msprobe.pytorch.api_accuracy_checker.acc_check.acc_check_utils import hf_32_standard_api
 from msprobe.pytorch.api_accuracy_checker.common.utils import check_object_type, get_full_data_path, \
-    CompareException, get_module_and_atttribute_name, get_attribute
+    CompareException, get_module_and_atttribute_name, get_attribute, is_dtype_fp8, is_dtype_hif8, is_hifloat8_tensor, \
+    is_dtype_fp8_or_hif8
 from msprobe.core.common.file_utils import FileChecker, load_npy
 from msprobe.pytorch.common.log import logger
 from msprobe.pytorch.common.utils import load_pt
@@ -38,7 +47,10 @@ FLOAT_TYPE = [
             'torch.double', 
             'torch.float16',
             'torch.half', 
-            'torch.bfloat16'
+            'torch.bfloat16',
+            'torch.float8_e4m3fn',
+            'torch.float8_e5m2',
+            'torch_npu.HiFloat8Tensor'
             ]
 NUMPY_TYPE = [
             "numpy.int8", "numpy.int16", "numpy.int32", "numpy.int64", "numpy.uint8", "numpy.uint16", "numpy.uint32",
@@ -61,6 +73,9 @@ def gen_data(info, api_name, need_grad, convert_type, real_data_path=None):
     data_type = info.get('type')
     data_path = info.get('datapath', info.get('data_name'))
     data_path = get_full_data_path(data_path, real_data_path)
+    dtype = info.get('dtype')
+    if is_dtype_fp8_or_hif8(dtype) and IS_GPU:
+        raise CompareException("GPU does not need to support float8 data type")
     if data_type in TENSOR_DATA_LIST:
         if data_path:
             data = gen_real_tensor(data_path, convert_type)
@@ -69,10 +84,20 @@ def gen_data(info, api_name, need_grad, convert_type, real_data_path=None):
         if api_name in hf_32_standard_api and data.dtype == torch.float32:
             data = fp32_to_hf32_to_fp32(data)
         if info.get('requires_grad') and need_grad:
+            if is_hifloat8_tensor(data):
+                origin_dtype = info.get('dtype')
+            else:
+                origin_dtype = data.dtype
+            if is_dtype_fp8(origin_dtype):
+                data = data.to(torch.float32)
             data.requires_grad_(True)
             temp_data = data * 1
             data = temp_data.type_as(data)
             data.retain_grad()
+            if is_dtype_fp8(origin_dtype):
+                data = data.to(origin_dtype)
+            if is_dtype_hif8(origin_dtype):
+                data = torch_npu.HiFloat8Tensor.to_hifloat8(data)
     elif data_type.startswith("numpy"):
         if data_type not in NUMPY_TYPE:
             raise Exception("{} is not supported now".format(data_type))
@@ -196,8 +221,13 @@ def gen_common_tensor(low_info, high_info, shape, data_dtype, convert_type):
             tensor = torch.full(shape, high, dtype=dtype)
             tensor[-1] = low
             return tensor
+        
         low_scale, high_scale = low, high
-        dtype_finfo = torch.finfo(dtype)
+        if is_dtype_hif8(dtype):
+            finfo_dtype = torch.float32
+        else:
+            finfo_dtype = dtype
+        dtype_finfo = torch.finfo(finfo_dtype)
         #适配老版json high和low为inf或-inf的情况，取dtype的最大值或最小值进行放缩
         if high == float(CompareConst.INF):
             high_scale = dtype_finfo.max
@@ -209,7 +239,11 @@ def gen_common_tensor(low_info, high_info, shape, data_dtype, convert_type):
             low_scale = dtype_finfo.min
 
         scale = high_scale - low_scale
-        rand01 = torch.rand(shape, dtype=dtype)
+        if is_dtype_fp8(dtype) or is_dtype_hif8(dtype):
+            generate_dtype = torch.float32
+        else:
+            generate_dtype = dtype
+        rand01 = torch.rand(shape, dtype=generate_dtype)
         tensor = rand01 * scale + low_scale
     elif 'int' in data_dtype or 'long' in data_dtype:
         low, high = int(low), int(high)
@@ -236,6 +270,12 @@ def gen_common_tensor(low_info, high_info, shape, data_dtype, convert_type):
         if low_origin in [float(CompareConst.INF), float(CompareConst.NEG_INF)]:
             tmp_tensor[0] = low_origin
     data = tmp_tensor.reshape(shape)
+    if is_dtype_fp8(dtype):
+        data = data.to(dtype)
+    if is_dtype_hif8(dtype):
+        if IS_GPU:
+            raise CompareException("GPU does not support torch_npu.HiFloat8Tensor")
+        data = torch_npu.HiFloat8Tensor.to_hifloat8(data)
     return data
 
 

msprobe/pytorch/api_accuracy_checker/{run_ut/multi_run_ut.py → acc_check/multi_acc_check.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 subprocess
 import json
@@ -26,8 +27,8 @@ import threading
 from collections import namedtuple
 from itertools import cycle
 from tqdm import tqdm
-from msprobe.pytorch.api_accuracy_checker.run_ut.run_ut import _run_ut_parser, preprocess_forward_content
-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 import _acc_check_parser, preprocess_forward_content
+from msprobe.pytorch.api_accuracy_checker.acc_check.acc_check_utils import get_validated_result_csv_path, \
     get_validated_details_csv_path
 from msprobe.pytorch.api_accuracy_checker.compare.compare import Comparator
 from msprobe.pytorch.common import parse_json_info_forward_backward
@@ -39,12 +40,7 @@ from msprobe.core.common.const import FileCheckConst, Const
 from msprobe.core.common.utils import CompareException
 
 
-def split_json_file(input_file, num_splits, filter_api, device_id):
-    max_processes = len(device_id) * 8
-    if num_splits > max_processes:
-        logger.warning(f"A device supports a maximum of 8 processes. "
-                       f"The total number of processes exceeds the limit, and it is set to {max_processes}.")
-        num_splits = max_processes
+def split_json_file(input_file, num_splits, filter_api):
     forward_data, backward_data, real_data_path = parse_json_info_forward_backward(input_file)
     input_dir = os.path.dirname(os.path.abspath(input_file))
     if filter_api:
@@ -81,19 +77,10 @@ def split_json_file(input_file, num_splits, filter_api, device_id):
             }
         }
         split_filename = os.path.join(input_dir, f"temp_part{i}.json")
+        save_json(split_filename, temp_data)
         split_files.append(split_filename)
-        try:
-            save_json(split_filename, temp_data)
-        except Exception as e:
-            logger.error(f"An error occurred while saving split file: {e}")
-            for file in split_files:
-                try:
-                    remove_path(file)
-                except Exception:
-                    logger.error(f"File not found or could not be deleted: {file}")
-            msg = 'ERROR: Split json file failed, please check the input file and try again.'
-            raise CompareException(CompareException.PARSE_FILE_ERROR, msg) from e
-    return split_files, total_items, num_splits
+
+    return split_files, total_items
 
 
 def signal_handler(signum, frame):
@@ -110,15 +97,15 @@ def run_parallel_ut(config):
     processes = []
     device_id_cycle = cycle(config.device_id)
     if config.save_error_data_flag:
-        logger.info("UT task error data will be saved")
-    logger.info(f"Starting parallel UT with {config.num_splits} processes")
+        logger.info("acc_check task error data will be saved")
+    logger.info(f"Starting parallel acc_check with {config.num_splits} processes")
     progress_bar = tqdm(total=config.total_items, desc="Total items", unit="items")
 
     def create_cmd(api_info, dev_id):
         dirname, filename = os.path.split(os.path.abspath(__file__))
-        run_ut_path = os.path.join(dirname, "run_ut.py")
+        acc_check_path = os.path.join(dirname, "acc_check.py")
         cmd = [
-            sys.executable, run_ut_path,
+            sys.executable, acc_check_path,
             '-api_info', api_info,
             *(['-o', config.out_path] if config.out_path else []),
             '-d', str(dev_id),
@@ -132,8 +119,7 @@ def run_parallel_ut(config):
     def read_process_output(process):
         try:
             while True:
-                # 子进程标准输出流与进程本身状态是分开的，因此增加判断。子进程返回值非None表示子进程结束，标准输出为None表示结束。
-                if process.poll() is not None or process.stdout is None:
+                if process.poll() is not None:
                     break
                 output = process.stdout.readline()
                 if output == '':
@@ -181,7 +167,7 @@ def run_parallel_ut(config):
 
     try:
         for process in processes:
-            process.wait()  # wait仅阻塞，不捕获标准输出和标准错误，原communicate不仅阻塞，而且捕获标准输出和标准错误
+            process.communicate(timeout=None)
     except KeyboardInterrupt:
         logger.warning("Interrupted by user, terminating processes and cleaning up...")
     except Exception as e:
@@ -193,8 +179,9 @@ def run_parallel_ut(config):
             completed_items = len(result_file)
             progress_bar.update(completed_items - progress_bar.n)
         if progress_bar.n < config.total_items:
-            logger.warning("The UT task has not been completed. The parameter '-csv_path' along with the path to " \
-                           "the result CSV file will be utilized to resume the UT task.")
+            logger.warning("The acc_check task has not been completed. The parameter '-csv_path' along with the "
+                           "path to " 
+                           "the result CSV file will be utilized to resume the acc_check task.")
         clean_up()
         progress_bar_thread.join()
     try:
@@ -230,9 +217,7 @@ def prepare_config(args):
     create_directory(out_path)
     out_path_checker = FileChecker(out_path, FileCheckConst.DIR, ability=FileCheckConst.WRITE_ABLE)
     out_path = out_path_checker.common_check()
-    split_files, total_items, modified_num_splits = split_json_file(api_info, args.num_splits,
-                                                                    args.filter_api, args.device_id)
-    args.num_splits = modified_num_splits
+    split_files, total_items = split_json_file(api_info, args.num_splits, args.filter_api)
     config_path = args.config_path if args.config_path else None
     if config_path:
         config_path_checker = FileChecker(config_path, FileCheckConst.FILE,
@@ -246,8 +231,8 @@ def prepare_config(args):
     else:
         result_csv_path = get_validated_result_csv_path(args.result_csv_path, 'result')
         details_csv_path = get_validated_details_csv_path(result_csv_path)
-    logger.info(f"UT task result will be saved in {result_csv_path}")
-    logger.info(f"UT task details will be saved in {details_csv_path}")
+    logger.info(f"acc_check task result will be saved in {result_csv_path}")
+    logger.info(f"acc_check task details will be saved in {details_csv_path}")
     return ParallelUTConfig(split_files, out_path, args.num_splits, args.save_error_data,
                             args.jit_compile, args.device_id, result_csv_path,
                             total_items, config_path)
@@ -256,8 +241,8 @@ def prepare_config(args):
 def main():
     signal.signal(signal.SIGINT, signal_handler)
     signal.signal(signal.SIGTERM, signal_handler)
-    parser = argparse.ArgumentParser(description='Run UT in parallel')
-    _run_ut_parser(parser)
+    parser = argparse.ArgumentParser(description='Run acc_check in parallel')
+    _acc_check_parser(parser)
     parser.add_argument('-n', '--num_splits', type=int, choices=range(1, 65), default=8,
                         help='Number of splits for parallel processing. Range: 1-64')
     args = parser.parse_args()

msprobe/pytorch/api_accuracy_checker/{run_ut → acc_check}/run_overflow_check.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 os
@@ -29,8 +30,8 @@ else:
     current_device = "npu"
 import torch
 from tqdm import tqdm
-from msprobe.pytorch.api_accuracy_checker.run_ut.run_ut import generate_device_params, get_api_info
-from msprobe.pytorch.api_accuracy_checker.run_ut.run_ut_utils import exec_api, is_unsupported_api, ExecParams
+from msprobe.pytorch.api_accuracy_checker.acc_check.acc_check import generate_device_params, get_api_info
+from msprobe.pytorch.api_accuracy_checker.acc_check.acc_check_utils import exec_api, is_unsupported_api, ExecParams
 from msprobe.core.common.file_utils import check_link, FileChecker
 from msprobe.pytorch.api_accuracy_checker.common.utils import extract_basic_api_segments
 from msprobe.core.common.const import FileCheckConst, Const
@@ -89,7 +90,7 @@ def is_bool_output(x):
 
 
 def run_overflow_check(forward_file):
-    logger.info("start UT test")
+    logger.info("start acc_check test")
     forward_content, _, real_data_path = parse_json_info_forward_backward(forward_file)
     if real_data_path:
         dump_path = os.path.dirname(forward_file)
@@ -112,7 +113,7 @@ def run_overflow_check(forward_file):
                 logger.warning(f"API {api_name} not support matmul primitive in CPU due to pytorch bug, "
                                "so it will be skipped.")
             else:
-                logger.error(f"Run {api_full_name} UT Error: %s" % str(err))
+                logger.error(f"Run {api_full_name} acc_check Error: %s" % str(err))
 
 
 def run_torch_api(api_full_name, api_info_dict, real_data_path):
@@ -125,7 +126,7 @@ def run_torch_api(api_full_name, api_info_dict, real_data_path):
     device_info_kwargs = kwargs.get(Const.DEVICE)
     if device_info_kwargs and device_info_kwargs.get(Const.VALUE):
         kwargs[Const.DEVICE] = current_device
-    npu_args, npu_kwargs = generate_device_params(args, kwargs, False, api_name)
+    npu_args, npu_kwargs, _ = generate_device_params(args, kwargs, False, api_name)
     if kwargs.get(Const.DEVICE):
         del kwargs[Const.DEVICE]
     cpu_exec_params = ExecParams(api_type, api_name, Const.CPU_LOWERCASE, args, kwargs, False, None)
@@ -156,7 +157,7 @@ def _run_overflow_check_parser(parser):
                         required=True)
     parser.add_argument("-j", "--jit_compile", dest="jit_compile", help="<optional> whether to turn on jit compile",
                         default=False, required=False)
-    parser.add_argument("-d", "--device", dest="device_id", type=int, help="<optional> set NPU device id to run ut",
+    parser.add_argument("-d", "--device", dest="device_id", type=int, help="<optional> set NPU device id to acc_check",
                         default=0, required=False)
 
 
@@ -166,7 +167,7 @@ def _run_overflow_check(parser=None):
     _run_overflow_check_parser(parser)
     args = parser.parse_args(sys.argv[1:])
     _run_overflow_check_command(args)
-    logger.info("UT task completed.")
+    logger.info("acc_check task completed.")
 
 
 def _run_overflow_check_command(args):

msprobe/pytorch/api_accuracy_checker/common/config.py

@@ -1,29 +1,31 @@
 #!/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
 from collections import namedtuple
 from msprobe.core.common.file_utils import load_yaml, check_file_or_directory_path
 from msprobe.core.common.utils import is_int
-from msprobe.pytorch.pt_config import RunUTConfig
+from msprobe.pytorch.dump.pt_config import ACCCheckConfig
 
 
-RunUtConfig = namedtuple('RunUtConfig', ['forward_content', 'backward_content', 'result_csv_path', 'details_csv_path',
-                                         'save_error_data', 'is_continue_run_ut', 'real_data_path', 'white_list',
+AccCheckConfig = namedtuple('AccCheckConfig', ['forward_content', 'backward_content',
+                                               'result_csv_path', 'details_csv_path',
+                                         'save_error_data', 'is_continue_acc_check', 'real_data_path', 'white_list',
                                          'black_list', 'error_data_path'])
 
 
@@ -56,11 +58,11 @@ class Config:
         if key == 'precision' and (value < 0 or value > 20):
             raise ValueError("precision must be greater than or equal to 0 and less than 21")
         if key == 'white_list':
-            RunUTConfig.check_filter_list_config(key, value)
+            ACCCheckConfig.check_filter_list_config(key, value)
         if key == 'black_list':
-            RunUTConfig.check_filter_list_config(key, value)
+            ACCCheckConfig.check_filter_list_config(key, value)
         if key == 'error_data_path':
-            RunUTConfig.check_error_data_path_config(value)
+            ACCCheckConfig.check_error_data_path_config(value)
         return value
 
 
@@ -84,14 +86,14 @@ class CheckerConfig:
         self.error_data_path = task_config.error_data_path
     
 
-    def get_run_ut_config(self, **config_params):
-        return RunUtConfig(
+    def get_acc_check_config(self, **config_params):
+        return AccCheckConfig(
             forward_content=config_params.get('forward_content'),
             backward_content=config_params.get('backward_content'),
             result_csv_path=config_params.get('result_csv_path'),
             details_csv_path=config_params.get('details_csv_path'),
             save_error_data=config_params.get('save_error_data'),
-            is_continue_run_ut=config_params.get('is_continue_run_ut'),
+            is_continue_acc_check=config_params.get('is_continue_acc_check'),
             real_data_path=config_params.get('real_data_path'),
             white_list=self.white_list.copy() if self.white_list else [],
             black_list=self.black_list.copy() if self.black_list else [],

msprobe/pytorch/api_accuracy_checker/common/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 os
 import re
@@ -162,10 +163,10 @@ class UtDataProcessor:
             self.index += 1
         elif isinstance(element, (list, tuple)):
             for item in element:
-                self._save_recursive(api_name, item, depth=depth+1)
+                self._save_recursive(api_name, item, depth=depth + 1)
         elif isinstance(element, dict):
             for value in element.values():
-                self._save_recursive(api_name, value, depth=depth+1)
+                self._save_recursive(api_name, value, depth=depth + 1)
         else:
             self.index += 1
 
@@ -259,3 +260,61 @@ def get_attribute(module_name, attribute_name):
         logger.error(f"Failed to get attribute {attribute_name} from module {module_name}: {e}")
         raise CompareException(CompareException.INVALID_ATTRIBUTE_ERROR) from e
     return attribute
+
+
+def is_dtype_fp8(dtype):
+    """
+    Function Description:
+        Check if the data type is float8.
+    Parameter:
+        dtype: Data type (torch.dtype or string).
+    Return:
+        True or False.
+    """
+    # 处理字符串类型的 dtype
+    if isinstance(dtype, str):
+        return dtype in ["torch.float8_e4m3fn", "torch.float8_e5m2"]
+
+    # 处理 torch.dtype 类型
+    return dtype in [torch.float8_e4m3fn, torch.float8_e5m2]
+
+
+def is_dtype_hif8(dtype):
+    """
+    Function Description:
+        Check if the data type is HiFloat8Tensor.
+    Parameter:
+        dtype: Data type (string).
+    Return:
+        True or False.
+    """
+    # 处理字符串类型的 dtype
+    if isinstance(dtype, str):
+        dtype_str = dtype
+    # 处理类对象或 dtype 对象
+    else:
+        dtype_str = str(dtype)
+
+    # 检查是否匹配 HiFloat8Tensor 的字符串表示
+    return (
+            dtype_str == "<class 'torch_npu.utils.hif8_tensor.HiFloat8Tensor'>" or
+            dtype_str == "torch_npu.HiFloat8Tensor"
+    )
+
+
+def is_dtype_fp8_or_hif8(dtype):
+    """
+    Function Description:
+        Check if the data type is FP8 (native or HiFloat8 variant).
+    Parameters:
+        dtype: Data type (torch.dtype, class, or string).
+    Returns:
+        True if dtype is FP8 or HiFloat8, False otherwise.
+    """
+    return is_dtype_fp8(dtype) or is_dtype_hif8(dtype)
+
+
+def is_hifloat8_tensor(tensor):
+    if not IS_GPU and hasattr(torch_npu, "HiFloat8Tensor") and isinstance(tensor, torch_npu.HiFloat8Tensor):
+        return True
+    return False

msprobe/pytorch/api_accuracy_checker/compare/algorithm.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
@@ -22,6 +23,7 @@ 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.pytorch.api_accuracy_checker.common.utils import is_dtype_fp8
 from msprobe.core.common.const import CompareConst
 
 
@@ -212,6 +214,8 @@ def check_norm_value(normal_value_mask, rel_err, rtol):
 
 
 def get_ulp_err(bench_output, device_output, dtype):
+    if is_dtype_fp8(dtype):
+        return calc_ulp_err_fp8(bench_output, device_output)
     parameters = ULP_PARAMETERS.get(dtype)
     min_eb = parameters.get('min_eb')[0]
     exponent_num = parameters.get('exponent_num')[0]
@@ -227,6 +231,32 @@ def get_ulp_err(bench_output, device_output, dtype):
     return ulp_err
 
 
+def calc_ulp_err_fp8(bench_output, device_output):
+    # compute ulp error of FP8
+    x = np.float64(bench_output)
+    hi_fp8 = np.float64(device_output)
+
+    ex = np.log2(abs(x) + 2**(-1000))
+    ex[ex < -22] = -22
+    exponent = np.floor(ex)  # Exponent
+
+    eabs = np.abs(exponent)
+    wm = np.zeros_like(x)                       # Mantissa width Init
+    wm[eabs <= 15] = 1
+    wm[eabs <= 7] = 2
+    wm[eabs <= 3] = 3
+    ulp_err = (hi_fp8 - x) * 2 ** (-exponent + wm)         # for wm = 1~3
+
+    s_ex = ex * np.where(x >= 0, 1, -1)         
+    eh = np.log2(abs(hi_fp8) + 2**(-1000))
+    
+    s_eh = eh * np.where(hi_fp8 >= 0, 1, -1)
+    ulp_err1 = s_eh - s_ex                      # for wm = 0
+
+    ulp_err[wm == 0] = ulp_err1[wm == 0]        # Merge 2 cases
+    return ulp_err
+
+
 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)