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

msprobe/pytorch/api_accuracy_checker/run_ut/run_overflow_check.py

@@ -23,16 +23,19 @@ try:
     import torch_npu
 except ImportError:
     is_gpu = True
+    current_device = "cuda"
 else:
     is_gpu = False
+    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
-from msprobe.core.common.file_utils import check_link
+from msprobe.pytorch.api_accuracy_checker.run_ut.run_ut_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
 from msprobe.pytorch.common.log import logger
 from msprobe.pytorch.common.parse_json import parse_json_info_forward_backward
-from msprobe.core.common.const import Const
 
 
 def check_tensor_overflow(x):
@@ -60,52 +63,80 @@ def check_tensor_overflow(x):
         return False
 
 
-def check_data_overflow(x):
-    if isinstance(x, (tuple, list)) and x:
-        for _, item in enumerate(x):
-            if check_data_overflow(item):
-                return True
-        return False
+def check_data_overflow(x, device):
+    if isinstance(x, (tuple, list)):
+        if not x:
+            return False
+        return any(check_data_overflow(item, device) for item in x)
     else:
-        return check_tensor_overflow(x)
+        if device == Const.CPU_LOWERCASE:
+            return check_tensor_overflow(x)
+        else:
+            return torch_npu.npu.utils.npu_check_overflow(x)
+
+
+def is_bool_output(x):
+    if isinstance(x, (tuple, list)):
+        if not x:
+            return False
+        return any(is_bool_output(item) for item in x)
+    else:
+        return isinstance(x, bool)
 
 
 def run_overflow_check(forward_file):
     logger.info("start UT test")
     forward_content, _, real_data_path = parse_json_info_forward_backward(forward_file)
+    if real_data_path:
+        dump_path = os.path.dirname(forward_file)
+        real_data_path = os.path.join(dump_path, Const.DUMP_TENSOR_DATA)
     for api_full_name, api_info_dict in tqdm(forward_content.items()):
+        if is_unsupported_api(api_full_name, is_overflow_check=True):
+            continue
         try:
             run_torch_api(api_full_name, api_info_dict, real_data_path)
         except Exception as err:
             _, api_name, _ = api_full_name.split(Const.SEP)
             if "not implemented for 'Half'" in str(err):
-                logger.warning(f"API {api_name} not support half tensor in CPU, please add {api_name} to CONVERT_API "
-                               f"'fp16_to_fp32' list in accuracy_tools/api_accuracy_check/common/utils.py file.")
+                logger.warning(f"API {api_name} not support half tensor in CPU. This API does not support overflow "
+                               "check, so it will be skipped.")
             elif "expected scalar type Long" in str(err):
                 logger.warning(f"API {api_name} not support int32 tensor in CPU, please add {api_name} to CONVERT_API "
-                               f"'int32_to_int64' list in accuracy_tools/api_accuracy_check/common/utils.py file.")
+                               "'int32_to_int64' list in accuracy_tools/msprobe/core/common/const.py file.")
+            elif "could not create a primitive descriptor for a matmul primitive" in str(err):
+                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))
 
 
 def run_torch_api(api_full_name, api_info_dict, real_data_path):
     torch.npu.clear_npu_overflow_flag()
-    api_type, api_name, _ = api_full_name.split(Const.SEP)
+    api_type, api_name = extract_basic_api_segments(api_full_name)
     args, kwargs, need_grad = get_api_info(api_info_dict, api_name, real_data_path)
     if not need_grad:
         logger.warning("%s function with out=... arguments don't support automatic differentiation, skip backward." 
                        % api_full_name)
+    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)
-    if kwargs.get("device"):
-        del kwargs["device"]
-    out = exec_api(api_type, api_name, Const.CPU_LOWERCASE, args, kwargs)
-    npu_out = exec_api(api_type, api_name, Const.NPU_LOWERCASE, npu_args, npu_kwargs)
+    if kwargs.get(Const.DEVICE):
+        del kwargs[Const.DEVICE]
+    cpu_exec_params = ExecParams(api_type, api_name, Const.CPU_LOWERCASE, args, kwargs, False, None)
+    device_exec_params = ExecParams(api_type, api_name, Const.NPU_LOWERCASE, npu_args, npu_kwargs, False, None)
+    out = exec_api(cpu_exec_params)
+    npu_out = exec_api(device_exec_params)
     if out is None and npu_out is None:
         logger.warning("The %s overflow is a normal overflow, out and npu_out is None." % api_full_name)
         return
+    if is_bool_output(out) or is_bool_output(npu_out):
+        logger.warning("The output of %s is bool type.This dtype not support overflow, so it will be skipped."
+                       % api_full_name)
+        return
 
-    cpu_overflow = check_data_overflow(out)
-    npu_overflow = torch_npu.npu.utils.npu_check_overflow(npu_out)
+    cpu_overflow = check_data_overflow(out, Const.CPU_LOWERCASE)
+    npu_overflow = check_data_overflow(npu_out, Const.NPU_LOWERCASE)
     if cpu_overflow == npu_overflow:
         logger.warning("The %s overflow is a normal overflow." % api_full_name)
     else:
@@ -135,8 +166,9 @@ def _run_overflow_check(parser=None):
 def _run_overflow_check_command(args):
     torch.npu.set_compile_mode(jit_compile=args.jit_compile)
     npu_device = "npu:" + str(args.device_id)
-    check_link(args.api_info_file)
-    api_info = os.path.realpath(args.api_info_file)
+    api_info_file_checker = FileChecker(file_path=args.api_info_file, path_type=FileCheckConst.FILE, 
+                                            ability=FileCheckConst.READ_ABLE, file_type=FileCheckConst.JSON_SUFFIX)
+    api_info = api_info_file_checker.common_check()
     try:
         torch.npu.set_device(npu_device)
     except Exception as error:

msprobe/pytorch/api_accuracy_checker/run_ut/run_ut.py

@@ -17,7 +17,7 @@
 
 import argparse
 import os
-import csv
+import re
 import sys
 import time
 import gc
@@ -31,39 +31,40 @@ except ImportError:
 else:
     is_gpu = False
     current_device = "npu"
+
 import torch
 from tqdm import tqdm
 
 from msprobe.pytorch.api_accuracy_checker.run_ut.run_ut_utils import BackwardMessage, UtDataInfo, \
-    get_validated_result_csv_path, get_validated_details_csv_path, exec_api, record_skip_info
+    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.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
 from msprobe.pytorch.api_accuracy_checker.compare.compare_column import CompareColumn
-from msprobe.pytorch.api_accuracy_checker.common.config import msCheckerConfig
+from msprobe.pytorch.api_accuracy_checker.common.config import CheckerConfig
 from msprobe.pytorch.common.parse_json import parse_json_info_forward_backward
-from msprobe.core.common.file_utils import FileChecker, change_mode, check_path_before_create, \
-    create_directory, get_json_contents, read_csv
+from msprobe.core.common.file_utils import FileChecker, change_mode, \
+    create_directory, get_json_contents, read_csv, check_file_or_directory_path, check_crt_valid
 from msprobe.pytorch.common.log import logger
 from msprobe.pytorch.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
+from msprobe.pytorch.common.utils import seed_all
 from msprobe.pytorch.api_accuracy_checker.tensor_transport_layer.attl import ATTL, ATTLConfig, move2device_exec
 from msprobe.pytorch.api_accuracy_checker.tensor_transport_layer.device_dispatch import ConsumerDispatcher
-from msprobe.pytorch.api_accuracy_checker.run_ut.run_ut_utils import generate_cpu_params, generate_device_params
+from msprobe.pytorch.api_accuracy_checker.run_ut.run_ut_utils import generate_cpu_params, generate_device_params, \
+    ExecParams
 
 
 current_time = time.strftime("%Y%m%d%H%M%S")
 UT_ERROR_DATA_DIR = 'ut_error_data' + current_time
 RESULT_FILE_NAME = "accuracy_checking_result_" + current_time + ".csv"
 DETAILS_FILE_NAME = "accuracy_checking_details_" + current_time + ".csv"
-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',
-                                         'black_list', 'error_data_path', 'online_config'])
 
-OnlineConfig = namedtuple('OnlineConfig', ['is_online', 'nfs_path', 'host', 'port', 'rank_list', 'tls_path'])
 
 not_backward_list = ['repeat_interleave']
+unsupported_backward_list = ['masked_select']
 
 
 tqdm_params = {
@@ -99,7 +100,11 @@ def run_ut(config):
         run_api_online(config, compare)
     else:
         csv_df = read_csv(config.result_csv_path)
-        api_name_set = {row[0] for row in csv_df.itertuples(index=False, name=None)}
+        try:
+            api_name_set = {row[0] for row in csv_df.itertuples(index=False, name=None)}
+        except IndexError:
+            logger.error(f"Read {config.result_csv_path} error, api_name_set is empty.")
+            api_name_set = set()
         run_api_offline(config, compare, api_name_set)
     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)
@@ -140,7 +145,7 @@ def run_api_offline(config, compare, api_name_set):
         except Exception as err:
             if "expected scalar type Long" in str(err):
                 logger.warning(f"API {api_name} not support int32 tensor in CPU, please add {api_name} to CONVERT_API "
-                               f"'int32_to_int64' list in accuracy_tools/api_accuracy_check/common/utils.py file.")
+                               "'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))
             compare_alg_results = err_column.to_column_value(CompareConst.SKIP, str(err))
@@ -220,14 +225,6 @@ def blacklist_and_whitelist_filter(api_name, black_list, white_list):
     return False
 
 
-def is_unsupported_api(api_name):
-    split_name = api_name.split(Const.SEP)[0]
-    flag = split_name == Const.DISTRIBUTED
-    if flag:
-        logger.info(f"{split_name} api is not supported for run ut. SKIP.")
-    return flag
-
-
 def do_save_error_data(api_full_name, data_info, error_data_path, is_fwd_success, is_bwd_success):
     if not is_fwd_success or not is_bwd_success:
         processor = UtDataProcessor(error_data_path)
@@ -244,7 +241,8 @@ def run_torch_api(api_full_name, real_data_path, backward_content, api_info_dict
     in_fwd_data_list = []
     backward_message = ''
     api_type, api_name = extract_basic_api_segments(api_full_name)
-    args, kwargs, need_grad = get_api_info(api_info_dict, api_name, real_data_path)
+    args, kwargs, output_dtype = get_api_info(api_info_dict, api_name, real_data_path)
+    need_grad = check_need_grad(api_info_dict)
     in_fwd_data_list.append(args)
     in_fwd_data_list.append(kwargs)
     need_backward = api_full_name in backward_content
@@ -253,16 +251,32 @@ def run_torch_api(api_full_name, real_data_path, backward_content, api_info_dict
         backward_message += BackwardMessage.UNSUPPORT_BACKWARD_MESSAGE
     if api_name in not_backward_list:
         need_grad = False
-        logger.warning("%s %s" % (api_full_name, BackwardMessage.NO_BACKWARD_RESULT_MESSAGE))
+        logger.info("%s %s" % (api_full_name, BackwardMessage.NO_BACKWARD_RESULT_MESSAGE))
         backward_message += BackwardMessage.NO_BACKWARD_RESULT_MESSAGE
+    if api_name in unsupported_backward_list:
+        need_grad = False
+        logger.info("%s %s" % (api_full_name, BackwardMessage.UNSUPPORT_API_MESSAGE))
+        backward_message += BackwardMessage.UNSUPPORT_API_MESSAGE
     need_backward = need_backward and need_grad
-    if kwargs.get("device"):
-        del kwargs["device"]
-    cpu_args, cpu_kwargs = generate_cpu_params(args, kwargs, need_backward, api_name)
+    
+    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)
+    if kwargs.get(Const.DEVICE):
+        del kwargs[Const.DEVICE]
+    cpu_params = generate_cpu_params(args, kwargs, need_backward, api_name)
+    cpu_args, cpu_kwargs = cpu_params.cpu_args, cpu_params.cpu_kwargs
+    autocast_dtype, is_autocast = cpu_params.autocast_dtype, cpu_params.is_autocast
+    if not is_autocast and output_dtype:
+        is_autocast = autocast_dtype != output_dtype
+        autocast_dtype = output_dtype
     bench_grad_out, device_grad_out = None, None
-    out = exec_api(api_type, api_name, Const.CPU_LOWERCASE, cpu_args, cpu_kwargs)
-    device_out = exec_api(api_type, api_name, current_device, device_args, device_kwargs)
+    cpu_exec_params = ExecParams(api_type, api_name, Const.CPU_LOWERCASE, cpu_args, cpu_kwargs, False, autocast_dtype)
+    out = exec_api(cpu_exec_params)
+    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)
     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)
@@ -278,16 +292,18 @@ def run_torch_api(api_full_name, real_data_path, backward_content, api_info_dict
             func_options = {
                 'real_data_path': real_data_path
             }
-            grad = gen_args(backward_args, api_name, func_options)[0]
-            bench_grad, _ = generate_cpu_params(grad, {}, False, api_name)
+            grad = gen_args(backward_args, api_name, func_options)
+            grad = safe_get_value(grad, 0, "grad")
+            grad_params = generate_cpu_params(grad, {}, False, api_name)
+            bench_grad = grad_params.cpu_args
             bench_grad_out = run_backward(cpu_args, bench_grad, grad_index, out)
             device_grad = grad.clone().detach().to(current_device)
             device_grad_out = run_backward(device_args, device_grad, grad_index, device_out)
         else:
             backward_message += BackwardMessage.MULTIPLE_BACKWARD_MESSAGE
     if api_name == "npu_fusion_attention":
-        out = out[0]
-        device_out = device_out[0]
+        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)
 
@@ -306,13 +322,18 @@ def run_torch_api_online(api_full_name, api_data, backward_content):
     return UtDataInfo(None, None, out, device_out, None, in_fwd_data_list, None, rank=api_data.rank)
 
 
-def get_api_info(api_info_dict, api_name, real_data_path):
-    convert_type, api_info_dict = api_info_preprocess(api_name, api_info_dict)
+def check_need_grad(api_info_dict):
     need_grad = True
-    if api_info_dict.get("input_kwargs") and "out" in api_info_dict.get("input_kwargs"):
+    if api_info_dict.get(Const.INPUT_KWARGS) and "out" in api_info_dict.get(Const.INPUT_KWARGS):
         need_grad = False
-    args, kwargs = gen_api_params(api_info_dict, api_name, need_grad, convert_type, real_data_path)
-    return args, kwargs, need_grad
+    return need_grad
+
+
+def get_api_info(api_info_dict, api_name, real_data_path):
+    convert_type, api_info_dict = api_info_preprocess(api_name, api_info_dict)
+    need_grad = check_need_grad(api_info_dict)
+    args, kwargs, output_dtype = gen_api_params(api_info_dict, api_name, need_grad, convert_type, real_data_path)
+    return args, kwargs, output_dtype
 
 
 def need_to_backward(grad_index, out):
@@ -323,20 +344,32 @@ def need_to_backward(grad_index, out):
 
 def run_backward(args, grad, grad_index, out):
     if grad_index is not None:
+        if grad_index >= len(out):
+            logger.error(f"Run backward error when grad_index is {grad_index}")
+            raise IndexError(f"Run backward error when grad_index is {grad_index}")
         out[grad_index].backward(grad)
     else:
         out.backward(grad)
-    args_grad = []
-    for arg in args:
-        if isinstance(arg, torch.Tensor):
-            args_grad.append(arg.grad)
-    grad_out = args_grad
+
+    grad_out = extract_tensors_grad(args)
 
     return grad_out
 
 
+def extract_tensors_grad(args, depth=0):
+    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)
+    grads = []
+    for arg in args:
+        if isinstance(arg, torch.Tensor):
+            grads.append(arg.grad)
+        elif isinstance(arg, (list, tuple)):
+            grads.extend(extract_tensors_grad(arg, depth+1))
+    return grads
+
+
 def initialize_save_error_data(error_data_path):
-    check_path_before_create(error_data_path)
     create_directory(error_data_path)
     error_data_path_checker = FileChecker(error_data_path, FileCheckConst.DIR,
                                           ability=FileCheckConst.WRITE_ABLE)
@@ -438,9 +471,55 @@ def _run_ut(parser=None):
     run_ut_command(args)
 
 
+def checked_online_config(online_config):
+    if not online_config.is_online:
+        return
+    if not isinstance(online_config.is_online, bool):
+        raise ValueError("is_online must be bool type")
+    # rank_list
+    if not isinstance(online_config.rank_list, list):
+        raise ValueError("rank_list must be a list")
+    if online_config.rank_list and not all(isinstance(rank, int) for rank in online_config.rank_list):
+        raise ValueError("All elements in rank_list must be integers")
+
+    # nfs_path
+    if online_config.nfs_path:
+        check_file_or_directory_path(online_config.nfs_path, isdir=True)
+        return
+    # tls_path
+    if online_config.tls_path:
+        check_file_or_directory_path(online_config.tls_path, isdir=True)
+        check_file_or_directory_path(os.path.join(online_config.tls_path, "server.key"))
+        check_file_or_directory_path(os.path.join(online_config.tls_path, "server.crt"))
+        check_crt_valid(os.path.join(online_config.tls_path, "server.crt"))
+
+    # host and port
+    if not isinstance(online_config.host, str) or not re.match(Const.ipv4_pattern, online_config.host):
+        raise Exception(f"host: {online_config.host} is invalid.")
+    if not isinstance(online_config.port, int) or not (0 < online_config.port <= 65535):
+        raise Exception(f"port: {online_config.port} is invalid, port range 0-65535.")
+
+
 def run_ut_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)
+        checker_config = CheckerConfig(task_config)
+    else:
+        checker_config = CheckerConfig()
+    
+    if not checker_config.is_online and 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.")
+
     if not is_gpu:
         torch.npu.set_compile_mode(jit_compile=args.jit_compile)
+        if args.jit_compile:
+            torch.npu.config.allow_internal_format = True
+        else:
+            torch.npu.config.allow_internal_format = False
     used_device = current_device + ":" + str(args.device_id[0])
     try:
         if is_gpu:
@@ -459,13 +538,15 @@ def run_ut_command(args):
                                             ability=FileCheckConst.READ_ABLE, file_type=FileCheckConst.JSON_SUFFIX)
         checked_api_info = api_info_file_checker.common_check()
         forward_content, backward_content, real_data_path = parse_json_info_forward_backward(checked_api_info)
+        if real_data_path:
+            dump_path = os.path.dirname(checked_api_info)
+            real_data_path = os.path.join(dump_path, Const.DUMP_TENSOR_DATA)
         if args.filter_api:
             logger.info("Start filtering the api in the api_info_file.")
             forward_content = preprocess_forward_content(forward_content)
             logger.info("Finish filtering the api in the api_info_file.")
 
-    out_path = os.path.realpath(args.out_path) if args.out_path else "./"
-    check_path_before_create(out_path)
+    out_path = args.out_path if args.out_path else Const.DEFAULT_PATH
     create_directory(out_path)
     out_path_checker = FileChecker(out_path, FileCheckConst.DIR, ability=FileCheckConst.WRITE_ABLE)
     out_path = out_path_checker.common_check()
@@ -476,43 +557,31 @@ def run_ut_command(args):
     if args.result_csv_path:
         result_csv_path = get_validated_result_csv_path(args.result_csv_path, 'result')
         details_csv_path = get_validated_details_csv_path(result_csv_path)
-    white_list = msCheckerConfig.white_list
-    black_list = msCheckerConfig.black_list
-    error_data_path = msCheckerConfig.error_data_path
-    is_online = msCheckerConfig.is_online
-    nfs_path = msCheckerConfig.nfs_path
-    host = msCheckerConfig.host
-    port = msCheckerConfig.port
-    rank_list = msCheckerConfig.rank_list
-    tls_path = msCheckerConfig.tls_path
-    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)
-        white_list = task_config.white_list
-        black_list = task_config.black_list
-        error_data_path = task_config.error_data_path
-        is_online = task_config.is_online
-        nfs_path = task_config.nfs_path
-        host = task_config.host
-        port = task_config.port
-        rank_list = task_config.rank_list
-        tls_path = task_config.tls_path
 
+    error_data_path = checker_config.error_data_path
     if save_error_data:
         if args.result_csv_path:
             time_info = result_csv_path.split('.')[0].split('_')[-1]
             global UT_ERROR_DATA_DIR
             UT_ERROR_DATA_DIR = 'ut_error_data' + time_info
         error_data_path = initialize_save_error_data(error_data_path)
-    online_config = OnlineConfig(is_online, nfs_path, host, port, rank_list, tls_path)
-    run_ut_config = RunUTConfig(forward_content, backward_content, result_csv_path, details_csv_path, save_error_data,
-                                args.result_csv_path, real_data_path, set(white_list), set(black_list), error_data_path,
-                                online_config)
+    online_config = checker_config.get_online_config()
+    checked_online_config(online_config)
+    config_params = {
+        'forward_content': forward_content,
+        'backward_content': backward_content,
+        '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,
+        '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)
 
 
 if __name__ == '__main__':
+    seed_all()
     _run_ut()
     logger.info("UT task completed.")

msprobe/pytorch/api_accuracy_checker/run_ut/run_ut_utils.py

@@ -16,6 +16,7 @@
 # limitations under the License.
 
 import os
+from collections import namedtuple
 import re
 import torch
 
@@ -23,8 +24,10 @@ try:
     import torch_npu
 except ImportError:
     current_device = "cuda"
+    from torch.cuda.amp import autocast
 else:
     current_device = "npu"
+    from torch_npu.npu.amp import autocast
 
 from msprobe.core.common.const import FileCheckConst, Const, CompareConst
 from msprobe.core.common.file_utils import FileChecker
@@ -47,11 +50,17 @@ PRECISION_MAPPING = {
 }
 
 
+CpuParams = namedtuple("CpuArgs", ["cpu_args", "cpu_kwargs", "autocast_dtype", "is_autocast"])
+ExecParams = namedtuple("ExecParams", ["api_type", "api_name", "device", "args", "kwargs", 
+                                       "is_autocast", "autocast_dtype"])
+
+
 class BackwardMessage:
     MULTIPLE_BACKWARD_MESSAGE = "Multiple backward is not supported."
     UNSUPPORT_BACKWARD_MESSAGE = "function with out=... arguments don't support automatic differentiation, " \
                                   "skip backward."
-    NO_BACKWARD_RESULT_MESSAGE = "function backward result is None, skip backward."
+    NO_BACKWARD_RESULT_MESSAGE = "This API does not have backward input data, skip backward."
+    UNSUPPORT_API_MESSAGE = "This API does not support backward ut, skip backward."
 
 
 class UtDataInfo:
@@ -91,7 +100,15 @@ def get_validated_details_csv_path(validated_result_csv_path):
     return validated_details_csv_path
 
 
-def exec_api(api_type, api_name, device, args, kwargs):
+def exec_api(exec_params):
+    api_type = exec_params.api_type
+    api_name = exec_params.api_name
+    device = exec_params.device
+    args = exec_params.args
+    kwargs = exec_params.kwargs
+    is_autocast = exec_params.is_autocast
+    autocast_dtype = exec_params.autocast_dtype
+
     if api_type == "Functional":
         torch_api = FunctionalOPTemplate(api_name, str, False)
     if api_type == "Tensor":
@@ -102,7 +119,11 @@ def exec_api(api_type, api_name, device, args, kwargs):
         torch_api = AtenOPTemplate(api_name, None, False)
     if api_type == "NPU":
         torch_api = NpuOPTemplate(api_name, None, False, device)
-    out = torch_api.forward(*args, **kwargs)
+    if is_autocast:
+        with autocast(dtype=autocast_dtype):
+            out = torch_api.forward(*args, **kwargs)
+    else:
+        out = torch_api.forward(*args, **kwargs)
     return out
 
 
@@ -186,28 +207,48 @@ 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 arg in arg_in))
+            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 v in arg_in.values()))
+            return set().union(*tuple(recursive_find_dtypes(v, kwargs, check_kwargs=True, depth=depth+1) for
+                                      v in arg_in.values()))
         return set()
 
     raise_dtype = None
+    autocast_dtype = None
+    is_autocast = False
     need_raise_dtypes = recursive_find_dtypes(input_args)
     need_raise_dtypes.update(recursive_find_dtypes(input_kwargs, check_kwargs=True))
     if len(need_raise_dtypes) == 1:
-        raise_dtype = PRECISION_MAPPING.get(need_raise_dtypes.pop(), torch.float32)
+        origin_dtype = need_raise_dtypes.pop()
+        raise_dtype = PRECISION_MAPPING.get(origin_dtype, torch.float32)
+        autocast_dtype = origin_dtype
+        
     elif len(need_raise_dtypes) >= 2:
         raise_dtype = torch.float32
+        need_raise_dtypes.discard(torch.float32)
+        autocast_dtype = need_raise_dtypes.pop()
+        is_autocast = True
 
     raise_dtype = None if api_name in not_raise_dtype_set else raise_dtype
     is_detach = api_name not in not_detach_set
     cpu_args = recursive_arg_to_cpu(input_args, is_detach, raise_dtype=raise_dtype)
-    cpu_kwargs = {key: recursive_arg_to_cpu(value, key != "out" and is_detach, raise_dtype=raise_dtype) for key, value in input_kwargs.items()}
-    return cpu_args, cpu_kwargs
+    cpu_kwargs = {key: recursive_arg_to_cpu(value, key != "out" and is_detach, raise_dtype=raise_dtype) for
+                  key, value in input_kwargs.items()}
+    cpu_params = CpuParams(cpu_args, cpu_kwargs, autocast_dtype, is_autocast)
+    return cpu_params
 
 
 def record_skip_info(api_full_name, compare, compare_alg_results):
     result_info = (api_full_name, CompareConst.SKIP, CompareConst.SKIP, [compare_alg_results], None, 0)
     compare.record_results(result_info)
+
+
+def is_unsupported_api(api_name, is_overflow_check=False):
+    split_name = api_name.split(Const.SEP)[0]
+    flag = (split_name == Const.DISTRIBUTED) or (is_overflow_check and split_name == Const.NPU)
+    if flag:
+        logger.info(f"{split_name} api is not supported for run ut. SKIP.")
+    return flag