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

msprobe/pytorch/aclgraph_dump/__init__.py

@@ -0,0 +1,45 @@
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
+#
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#          http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
+
+
+import torch
+import torch_npu
+
+# Import the C++ extension to register TORCH_LIBRARY implementations.
+try:
+    from msprobe.lib import aclgraph_dump_ext  # noqa: F401
+except Exception as exc:
+    raise RuntimeError(f"Failed to import msprobe.lib.aclgraph_dump_ext: {exc}")
+
+# Register Python fake implementation for meta tensors.
+from ._meta import _register_meta  # noqa: E402
+_register_meta()
+
+from torch.fx.node import has_side_effect
+has_side_effect(torch.ops.my_ns.acl_save.default)
+
+def acl_save(x: torch.Tensor, path: str) -> torch.Tensor:
+    """
+    acl_save(tensor, path) -> tensor
+
+    Copy tensor to CPU and save to a .pt file.
+    The file name is generated as {base}_{seq}.pt in the same directory.
+    For NPU input, the save runs on the current NPU stream; synchronize if needed.
+    """
+    return torch.ops.my_ns.acl_save(x, path)
+
+
+__all__ = ["acl_save"]

msprobe/pytorch/aclgraph_dump/_meta.py

@@ -0,0 +1,26 @@
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
+#
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#          http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
+
+
+import torch
+
+def _register_meta():
+    try:
+        @torch.library.register_fake("my_ns.acl_save")
+        def _fake_acl_save(x: torch.Tensor, path: str):
+            return torch.empty_strided(x.size(), x.stride(), dtype=x.dtype, device="meta")
+    except Exception:
+        pass

msprobe/pytorch/api_accuracy_checker/{run_ut/run_ut.py → acc_check/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 argparse
 import os
@@ -35,9 +36,9 @@ else:
 import torch
 from tqdm import tqdm
 
-from msprobe.pytorch.api_accuracy_checker.run_ut.run_ut_utils import BackwardMessage, UtDataInfo, \
+from msprobe.pytorch.api_accuracy_checker.acc_check.acc_check_utils import BackwardMessage, UtDataInfo, \
     get_validated_result_csv_path, get_validated_details_csv_path, exec_api, record_skip_info, is_unsupported_api
-from msprobe.pytorch.api_accuracy_checker.run_ut.data_generate import gen_api_params, gen_args
+from msprobe.pytorch.api_accuracy_checker.acc_check.data_generate import gen_api_params, gen_args
 from msprobe.pytorch.api_accuracy_checker.common.utils import api_info_preprocess, \
     initialize_save_path, UtDataProcessor, extract_basic_api_segments, ApiData
 from msprobe.pytorch.api_accuracy_checker.compare.compare import Comparator
@@ -47,11 +48,12 @@ from msprobe.pytorch.common.parse_json import parse_json_info_forward_backward
 from msprobe.core.common.file_utils import FileChecker, change_mode, \
     create_directory, get_json_contents, read_csv, check_file_or_directory_path
 from msprobe.pytorch.common.log import logger
-from msprobe.pytorch.pt_config import parse_json_config
+from msprobe.pytorch.dump.pt_config import parse_json_config
 from msprobe.core.common.const import Const, FileCheckConst, CompareConst
 from msprobe.core.common.utils import safe_get_value, CompareException, is_int, check_op_str_pattern_valid
 from msprobe.pytorch.common.utils import seed_all
-from msprobe.pytorch.api_accuracy_checker.run_ut.run_ut_utils import generate_cpu_params, generate_device_params, \
+from msprobe.pytorch.api_accuracy_checker.acc_check.acc_check_utils import generate_cpu_params,\
+    generate_device_params, \
     ExecParams
 
 
@@ -86,15 +88,15 @@ tqdm_params = {
 seed_all()
 
 
-def run_ut(config):
-    logger.info("start UT test")
+def acc_check(config):
+    logger.info("start acc_check test")
 
-    logger.info(f"UT task result will be saved in {config.result_csv_path}")
-    logger.info(f"UT task details will be saved in {config.details_csv_path}")
+    logger.info(f"acc_check task result will be saved in {config.result_csv_path}")
+    logger.info(f"acc_check task details will be saved in {config.details_csv_path}")
 
     if config.save_error_data:
-        logger.info(f"UT task error_data will be saved in {config.error_data_path}")
-    compare = Comparator(config.result_csv_path, config.details_csv_path, config.is_continue_run_ut, config=config)
+        logger.info(f"acc_check task error_data will be saved in {config.error_data_path}")
+    compare = Comparator(config.result_csv_path, config.details_csv_path, config.is_continue_acc_check, config=config)
 
 
     csv_df = read_csv(config.result_csv_path)
@@ -107,8 +109,8 @@ def run_ut(config):
     for result_csv_path, details_csv_path in zip(compare.save_path_list, compare.detail_save_path_list):
         change_mode(result_csv_path, FileCheckConst.DATA_FILE_AUTHORITY)
         change_mode(details_csv_path, FileCheckConst.DATA_FILE_AUTHORITY)
-        logger.info(f"UT task result csv is saved in {result_csv_path}")
-        logger.info(f"UT task details csv is saved in {details_csv_path}")
+        logger.info(f"acc_check task result csv is saved in {result_csv_path}")
+        logger.info(f"acc_check task details csv is saved in {details_csv_path}")
     compare.print_pretest_result()
 
 
@@ -119,13 +121,13 @@ def run_api_offline(config, compare, api_name_set):
         if api_full_name in api_name_set:
             continue
         if is_unsupported_api(api_full_name):
-            skip_message = f"API {api_full_name} not support for run ut. SKIP."
+            skip_message = f"API {api_full_name} not support for acc_check. SKIP."
             compare_alg_results = err_column.to_column_value(CompareConst.SKIP, skip_message)
             record_skip_info(api_full_name, compare, compare_alg_results)
             continue
         _, api_name = extract_basic_api_segments(api_full_name)
         if not api_name:
-            err_message = f"API {api_full_name} not support for run ut. SKIP."
+            err_message = f"API {api_full_name} not support for acc_check. SKIP."
             logger.error(err_message)
             compare_alg_results = err_column.to_column_value(CompareConst.SKIP, err_message)
             record_skip_info(api_full_name, compare, compare_alg_results)
@@ -146,7 +148,7 @@ def run_api_offline(config, compare, api_name_set):
                 logger.warning(f"API {api_name} not support int32 tensor in CPU, please add {api_name} to CONVERT_API "
                                "'int32_to_int64' list in accuracy_tools/msprobe/core/common/const.py file.")
             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))
             compare_alg_results = err_column.to_column_value(CompareConst.SKIP, str(err))
             record_skip_info(api_full_name, compare, compare_alg_results)
         finally:
@@ -208,7 +210,7 @@ def run_torch_api(api_full_name, real_data_path, backward_content, api_info_dict
     device_info_kwargs = kwargs.get(Const.DEVICE)
     if device_info_kwargs and device_info_kwargs.get(Const.VALUE):
         kwargs[Const.DEVICE] = current_device
-    device_args, device_kwargs = generate_device_params(args, kwargs, need_backward, api_name)
+    device_args, device_kwargs, is_fp8 = generate_device_params(args, kwargs, need_backward, api_name)
     if kwargs.get(Const.DEVICE):
         del kwargs[Const.DEVICE]
     cpu_params = generate_cpu_params(args, kwargs, need_backward, api_name)
@@ -223,6 +225,8 @@ def run_torch_api(api_full_name, real_data_path, backward_content, api_info_dict
     device_exec_params = ExecParams(api_type, api_name, current_device, device_args, device_kwargs, is_autocast,
                                      autocast_dtype)
     device_out = exec_api(device_exec_params)
+    if is_fp8 and isinstance(device_out, torch.Tensor) and device_out.dtype == torch.float32:
+        device_out = device_out.to(torch.float16)
     current_path = os.path.dirname(os.path.realpath(__file__))
     ut_setting_path = os.path.join(current_path, "torch_ut_setting.json")
     api_setting_dict = get_json_contents(ut_setting_path)
@@ -251,7 +255,8 @@ def run_torch_api(api_full_name, real_data_path, backward_content, api_info_dict
         out = safe_get_value(out, 0, "out")
         device_out = safe_get_value(device_out, 0, "device_out")
 
-    return UtDataInfo(bench_grad_out, device_grad_out, device_out, out, bench_grad, in_fwd_data_list, backward_message)
+    return UtDataInfo(bench_grad_out, device_grad_out, device_out, out, bench_grad, in_fwd_data_list, backward_message,
+                      rank=0, is_fp8=is_fp8)
 
 
 def check_need_grad(api_info_dict):
@@ -300,7 +305,7 @@ def extract_tensors_grad(args, depth=0):
         if isinstance(arg, torch.Tensor):
             grads.append(arg.grad)
         elif isinstance(arg, (list, tuple)):
-            grads.extend(extract_tensors_grad(arg, depth+1))
+            grads.extend(extract_tensors_grad(arg, depth + 1))
     return grads
 
 
@@ -313,13 +318,13 @@ def initialize_save_error_data(error_data_path):
     return error_data_path
 
 
-def _run_ut_parser(parser):
+def _acc_check_parser(parser):
     parser.add_argument("-api_info", "--api_info_file", dest="api_info_file", default="", type=str,
                         help="<Optional> The api param tool result file: generate from api param tool, "
                              "a json file.",
                         required=False)
     parser.add_argument("-o", "--out_path", dest="out_path", default="", type=str,
-                        help="<optional> The ut task result out path.",
+                        help="<optional> The acc_check task result out path.",
                         required=False)
     parser.add_argument('-save_error_data', dest="save_error_data", action="store_true",
                         help="<optional> Save compare failed api output.", required=False)
@@ -337,11 +342,11 @@ def _run_ut_parser(parser):
             setattr(namespace, self.dest, values)
 
     parser.add_argument("-d", "--device", dest="device_id", nargs='+', type=int,
-                        help="<optional> set device id to run ut, must be unique and in range 0-7",
+                        help="<optional> set device id to acc_check, must be unique and in range 0-7",
                         default=[0], required=False, action=UniqueDeviceAction)
     parser.add_argument("-csv_path", "--result_csv_path", dest="result_csv_path", default="", type=str,
                         help="<optional> The path of accuracy_checking_result_{timestamp}.csv, "
-                             "when run ut is interrupted, enter the file path to continue run ut.",
+                             "when acc_check is interrupted, enter the file path to continue acc_check.",
                         required=False)
     parser.add_argument("-f", "--filter_api", dest="filter_api", action="store_true",
                         help="<optional> Whether to filter the api in the api_info_file.", required=False)
@@ -389,27 +394,27 @@ def preprocess_forward_content(forward_content):
     return processed_content
 
 
-def _run_ut(parser=None):
+def _acc_check(parser=None):
     if not parser:
         parser = argparse.ArgumentParser()
-    _run_ut_parser(parser)
+    _acc_check_parser(parser)
     args = parser.parse_args(sys.argv[1:])
-    run_ut_command(args)
+    acc_check_command(args)
 
 
-def run_ut_command(args):
+def acc_check_command(args):
     if args.config_path:
         config_path_checker = FileChecker(args.config_path, FileCheckConst.FILE, 
                                           FileCheckConst.READ_ABLE, FileCheckConst.JSON_SUFFIX)
         checked_config_path = config_path_checker.common_check()
-        _, task_config = parse_json_config(checked_config_path, Const.RUN_UT)
+        _, task_config = parse_json_config(checked_config_path, Const.ACC_CHECK)
         checker_config = CheckerConfig(task_config)
     else:
         checker_config = CheckerConfig()
     
     if not args.api_info_file:
-        logger.error("Please provide api_info_file for offline run ut.")
-        raise Exception("Please provide api_info_file for offline run ut.")
+        logger.error("Please provide api_info_file for offline acc_check.")
+        raise Exception("Please provide api_info_file for offline acc_check.")
 
     if not is_gpu:
         torch.npu.set_compile_mode(jit_compile=args.jit_compile)
@@ -476,14 +481,14 @@ def run_ut_command(args):
         'result_csv_path': result_csv_path,
         'details_csv_path': details_csv_path,
         'save_error_data': save_error_data,
-        'is_continue_run_ut': args.result_csv_path,
+        'is_continue_acc_check': args.result_csv_path,
         'real_data_path': real_data_path,
         'error_data_path': error_data_path
     }
-    run_ut_config = checker_config.get_run_ut_config(**config_params)
-    run_ut(run_ut_config)
-    logger.info("UT task completed.")
+    acc_check_config = checker_config.get_acc_check_config(**config_params)
+    acc_check(acc_check_config)
+    logger.info("acc_check task completed.")
 
 
 if __name__ == '__main__':
-    _run_ut()
+    _acc_check()

msprobe/pytorch/api_accuracy_checker/{run_ut/run_ut_utils.py → acc_check/acc_check_utils.py}

@@ -1,38 +1,41 @@
-# Copyright (c) 2024-2025, 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
 import re
-
+import numpy as np
 import torch
 try:
     import torch_npu
 except ImportError:
     current_device = "cuda"
     from torch.cuda.amp import autocast
+    IS_GPU = True
 else:
     current_device = "npu"
     from torch_npu.npu.amp import autocast
+    IS_GPU = False
 
 from msprobe.core.common.const import FileCheckConst, Const, CompareConst
 from msprobe.core.common.file_utils import FileChecker
 from msprobe.core.common.log import logger
 from msprobe.core.common.utils import CompareException
-from msprobe.pytorch.hook_module.api_register import ApiTemplate, get_api_register
-from msprobe.pytorch.hook_module.wrap_aten import AtenOPTemplate
+from msprobe.pytorch.dump.api_dump.api_register import ApiTemplate, get_api_register
+from msprobe.pytorch.api_accuracy_checker.common.utils import is_dtype_fp8, is_hifloat8_tensor
 
 
 hf_32_standard_api = ["conv1d", "conv2d"]
@@ -61,7 +64,7 @@ class BackwardMessage:
 
 class UtDataInfo:
     def __init__(self, bench_grad, device_grad, device_output, bench_output, grad_in, in_fwd_data_list,
-                 backward_message, rank=0):
+                 backward_message, rank=0, is_fp8=False):
         self.bench_grad = bench_grad
         self.device_grad = device_grad
         self.device_output = device_output
@@ -70,6 +73,7 @@ class UtDataInfo:
         self.in_fwd_data_list = in_fwd_data_list
         self.backward_message = backward_message
         self.rank = rank
+        self.is_fp8 = is_fp8
 
 
 def get_validated_result_csv_path(result_csv_path, mode):
@@ -82,7 +86,7 @@ def get_validated_result_csv_path(result_csv_path, mode):
         result_csv_name = os.path.basename(validated_result_csv_path)
         pattern = r"^accuracy_checking_result_\d{14}\.csv$"
         if not re.match(pattern, result_csv_name):
-            raise ValueError("When continue run ut, please do not modify the result csv name.")
+            raise ValueError("When continue acc_check, please do not modify the result csv name.")
     return validated_result_csv_path
 
 
@@ -117,15 +121,12 @@ def exec_api(exec_params):
     ):
         return out
 
-    if api_type == Const.ATEN_API_TYPE_PREFIX:
-        torch_api = AtenOPTemplate(api_name, None, False)
-    else:
-        api_register = get_api_register()
-        api_register.initialize_hook(None)
-        api_func_type = list(prefix_map.keys())[list(prefix_map.values()).index(api_type)]
-        api_func = api_register.ori_api_attr.get(Const.PT_FRAMEWORK + Const.SEP + api_func_type, {}).get(api_name)
+    api_register = get_api_register()
+    api_register.initialize_hook(None)
+    api_func_type = list(prefix_map.keys())[list(prefix_map.values()).index(api_type)]
+    api_func = api_register.ori_api_attr.get(Const.PT_FRAMEWORK + Const.SEP + api_func_type, {}).get(api_name)
 
-        torch_api = ApiTemplate(api_name, api_func, api_type, None, need_hook=False, device=device)
+    torch_api = ApiTemplate(api_name, api_func, api_type, None, need_hook=False, device=device)
     if is_autocast:
         with autocast(dtype=autocast_dtype):
             out = torch_api.forward(*args, **kwargs)
@@ -148,6 +149,10 @@ def raise_bench_data_dtype(api_name, arg, raise_dtype=None):
     输出： 
         arg: 转换dtype的标杆输入
     '''
+    if is_hifloat8_tensor(arg):
+        return hif8_to_fp32(arg)
+    if is_dtype_fp8(arg.dtype):
+        return fp8_to_fp32(arg)
     if api_name in hf_32_standard_api and arg.dtype == torch.float32:
         return arg
     if raise_dtype is None or arg.dtype not in PRECISION_MAPPING or raise_dtype == arg.dtype:
@@ -156,13 +161,18 @@ def raise_bench_data_dtype(api_name, arg, raise_dtype=None):
 
 
 def generate_device_params(input_args, input_kwargs, need_backward, api_name):
+    is_fp8 = False
+    
     def recursive_arg_to_device(arg_in, to_detach, depth=0):
+        nonlocal is_fp8
         if depth > Const.MAX_DEPTH:
             logger.error("The depth of arg_in is too large, please check the arg_in.")
             raise CompareException(CompareException.RECURSION_LIMIT_ERROR)
         if isinstance(arg_in, (list, tuple)):
-            return type(arg_in)(recursive_arg_to_device(arg, to_detach, depth=depth+1) for arg in arg_in)
+            return type(arg_in)(recursive_arg_to_device(arg, to_detach, depth=depth + 1) for arg in arg_in)
         elif isinstance(arg_in, torch.Tensor):
+            if is_dtype_fp8(arg_in.dtype) or is_hifloat8_tensor(arg_in):
+                is_fp8 = True
             if need_backward and arg_in.requires_grad:
                 arg_in = deal_detach(arg_in.clone(), to_detach).to(current_device).requires_grad_()
                 temp_arg_in = arg_in * 1
@@ -178,7 +188,7 @@ def generate_device_params(input_args, input_kwargs, need_backward, api_name):
     device_args = recursive_arg_to_device(input_args, is_detach)
     device_kwargs = \
         {key: recursive_arg_to_device(value, key != "out" and is_detach) for key, value in input_kwargs.items()}
-    return device_args, device_kwargs
+    return device_args, device_kwargs, is_fp8
 
 
 def generate_cpu_params(input_args, input_kwargs, need_backward, api_name):
@@ -187,7 +197,7 @@ def generate_cpu_params(input_args, input_kwargs, need_backward, api_name):
             logger.error("The depth of arg_in is too large, please check the arg_in.")
             raise CompareException(CompareException.RECURSION_LIMIT_ERROR)
         if isinstance(arg_in, (list, tuple)):
-            return type(arg_in)(recursive_arg_to_cpu(arg, to_detach, raise_dtype=raise_dtype, depth=depth+1) 
+            return type(arg_in)(recursive_arg_to_cpu(arg, to_detach, raise_dtype=raise_dtype, depth=depth + 1)
                                 for arg in arg_in)
         elif isinstance(arg_in, torch.Tensor):
             if need_backward and arg_in.requires_grad:
@@ -214,12 +224,12 @@ def generate_cpu_params(input_args, input_kwargs, need_backward, api_name):
             logger.error("The depth of arg_in is too large, please check the arg_in.")
             raise CompareException(CompareException.RECURSION_LIMIT_ERROR)
         if isinstance(arg_in, (list, tuple)):
-            return set().union(*tuple(recursive_find_dtypes(arg, kwargs, check_kwargs=check_kwargs, depth=depth+1) for
+            return set().union(*tuple(recursive_find_dtypes(arg, kwargs, check_kwargs=check_kwargs, depth=depth + 1) for
                                       arg in arg_in))
         elif isinstance(arg_in, torch.Tensor) and is_tensor_with_raise_precision(arg_in, check_kwargs):
             return set([arg_in.dtype])
         elif isinstance(arg_in, dict) and check_kwargs:
-            return set().union(*tuple(recursive_find_dtypes(v, kwargs, check_kwargs=True, depth=depth+1) for
+            return set().union(*tuple(recursive_find_dtypes(v, kwargs, check_kwargs=True, depth=depth + 1) for
                                       v in arg_in.values()))
         return set()
 
@@ -258,5 +268,166 @@ def is_unsupported_api(api_name, is_overflow_check=False):
     unsupport_type_list = [Const.DISTRIBUTED, Const.MINDSPEED_API_TYPE_PREFIX]
     flag = (split_name in unsupport_type_list) or (is_overflow_check and split_name == Const.NPU)
     if flag:
-        logger.info(f"{split_name} api is not supported for run ut. SKIP.")
+        logger.info(f"{split_name} api is not supported for acc_check. SKIP.")
     return flag
+
+
+def fp8_to_fp32(x):
+    """
+    将FP8格式的张量转换为FP32格式，保持原始FP8的表示范围
+    使用纯PyTorch操作替代NumPy位运算
+    
+    参数:
+    x: 输入的FP8张量，可以是torch.float8_e4m3fn或torch.float8_e5m2类型
+    
+    返回:
+    torch.Tensor: 转换后的FP32张量，保持原始FP8的表示范围
+    """
+    if x.dtype == torch.float8_e4m3fn:
+        # E4M3FN格式：1符号+4指数+3尾数，偏置7
+        # 位布局：SEEEEEMM
+        
+        # 将FP8值视为无符号整数进行位操作
+        x_int = x.view(torch.uint8)
+        
+        # 提取符号位、指数位和尾数位
+        sign_bits = (x_int & 0x80) >> 7  # 最高位是符号位
+        exp_bits = (x_int & 0x78) >> 3   # 接下来4位是指数位
+        mantissa_bits = x_int & 0x07     # 最后3位是尾数位
+        
+        # 处理规格化数和非规格化数
+        is_normal = exp_bits != 0
+        
+        # 计算FP32的指数部分（偏置127）
+        fp32_exp = torch.where(
+            is_normal,
+            (exp_bits - 7 + 127).to(torch.int32),  # 规格化数：指数 = 原始指数 + 120
+            torch.tensor(0, dtype=torch.int32, device=x.device)  # 非规格化数：指数为0
+        )
+        
+        # 计算FP32的尾数部分
+        # 规格化数：隐含1，尾数 = 1.0 + 原始尾数 * 2^(-3)
+        # 非规格化数：无隐含1，尾数 = 0.0 + 原始尾数 * 2^(-3)
+        fp32_mantissa = torch.where(
+            is_normal,
+            1.0 + mantissa_bits.to(torch.float32) / 8.0,  # 2^(-3) = 1/8
+            mantissa_bits.to(torch.float32) / 8.0
+        )
+        
+        # 计算符号值 (-1)^sign
+        sign_value = torch.pow(-1.0, sign_bits.to(torch.float32))
+        
+        # 计算最终FP32值
+        # 规格化数：value = (-1)^sign * (1.0 + mantissa/8) * 2^(exp - 7)
+        # 非规格化数：value = (-1)^sign * (mantissa/8) * 2^(-6)
+        fp32_result = sign_value * fp32_mantissa * torch.pow(2.0, fp32_exp - 127)
+        
+        return fp32_result
+    
+    elif x.dtype == torch.float8_e5m2:
+        # E5M2格式：1符号+5指数+2尾数，偏置15
+        # 位布局：SEEEEEEM
+        
+        # 将FP8值视为无符号整数进行位操作
+        x_int = x.view(torch.uint8)
+        
+        # 提取符号位、指数位和尾数位
+        sign_bits = (x_int & 0x80) >> 7  # 最高位是符号位
+        exp_bits = (x_int & 0x7C) >> 2   # 接下来5位是指数位
+        mantissa_bits = x_int & 0x03     # 最后2位是尾数位
+        
+        # 处理规格化数和非规格化数
+        is_normal = exp_bits != 0
+        
+        # 计算FP32的指数部分（偏置127）
+        fp32_exp = torch.where(
+            is_normal,
+            (exp_bits - 15 + 127).to(torch.int32),  # 规格化数：指数 = 原始指数 + 112
+            torch.tensor(0, dtype=torch.int32, device=x.device)  # 非规格化数：指数为0
+        )
+        
+        # 计算FP32的尾数部分
+        # 规格化数：隐含1，尾数 = 1.0 + 原始尾数 * 2^(-2)
+        # 非规格化数：无隐含1，尾数 = 0.0 + 原始尾数 * 2^(-2)
+        fp32_mantissa = torch.where(
+            is_normal,
+            1.0 + mantissa_bits.to(torch.float32) / 4.0,  # 2^(-2) = 1/4
+            mantissa_bits.to(torch.float32) / 4.0
+        )
+        
+        # 计算符号值 (-1)^sign
+        sign_value = torch.pow(-1.0, sign_bits.to(torch.float32))
+        
+        # 计算最终FP32值
+        fp32_result = sign_value * fp32_mantissa * torch.pow(2.0, fp32_exp - 127)
+        
+        return fp32_result
+    
+    else:
+        raise ValueError(f"Unsupported dtype: {x.dtype}. Expected torch.float8_e4m3fn or torch.float8_e5m2.")
+
+
+def hif8_to_fp32(x):
+    """
+    将HiFloat8格式的张量转换为FP32格式，保持原始HiFloat8的表示范围
+    使用纯PyTorch操作替代NumPy位运算    
+    
+    参数:
+    x: 输入的HiFloat8张量，可以是torch_npu.HiFloat8Tensor类型
+    
+    返回:
+    torch.Tensor: 转换后的FP32张量，保持原始HiFloat8的表示范围
+    """
+    requires_grad = x.requires_grad
+    x = x.cpu().detach().numpy()
+    x = np.array(x)  # 确保输入是numpy数组
+    
+    # 创建结果数组，保持与输入相同的形状
+    res = np.zeros_like(x, dtype=np.float32)
+    
+    # 获取输入张量的所有维度
+    dimensions = x.shape
+    # 计算总元素数量
+    total_elements = np.prod(dimensions)
+    
+    # 遍历每个元素
+    for idx in range(total_elements):
+        # 将一维索引转换为多维索引
+        multi_indices = np.unravel_index(idx, dimensions)
+        z = x[multi_indices]
+        
+        # 处理特殊值
+        if np.isnan(z) or np.isinf(z):
+            res[multi_indices] = z
+            continue
+            
+        # 提取符号位
+        s = 1.0 if z >= 0 else -1.0
+        tmp = abs(z)
+        
+        # 处理零值
+        if tmp == 0:
+            res[multi_indices] = 0.0
+            continue
+            
+        # 确定指数范围和尾数位数
+        exponent = np.floor(np.log2(tmp + 1e-100))  # 添加小常量避免log2(0)
+        eabs = abs(exponent)
+        
+        # 根据指数范围确定尾数位数和还原规则
+        if eabs <= 3:       # 3-bit Mantissa
+            mantissa = (tmp / (2.0 ** exponent)) * 8.0  # 还原尾数部分
+            res[multi_indices] = s * (mantissa / 8.0) * (2.0 ** exponent)
+        elif eabs <= 7:     # 2-bit Mantissa
+            mantissa = (tmp / (2.0 ** exponent)) * 4.0
+            res[multi_indices] = s * (mantissa / 4.0) * (2.0 ** exponent)
+        elif eabs <= 15:    # 1-bit Mantissa
+            mantissa = (tmp / (2.0 ** exponent)) * 2.0
+            res[multi_indices] = s * (mantissa / 2.0) * (2.0 ** exponent)
+        else:               # 0-bit Mantissa
+            res[multi_indices] = s * (2.0 ** exponent)
+    
+    res = torch.from_numpy(res)
+    if requires_grad:
+        res = res.requires_grad_()
+    return res