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

msprobe/pytorch/api_accuracy_checker/run_ut/data_generate.py

@@ -1,8 +1,9 @@
 #!/usr/bin/env python3
 # -*- coding: utf-8 -*-
-"""
-# Copyright (C) 2023-2023. Huawei Technologies Co., Ltd. All rights reserved.
-# Licensed under the Apache License, Version 2.0 (the "License");
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0  (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
@@ -13,7 +14,6 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-"""
 
 import os
 import math
@@ -22,19 +22,28 @@ import numpy
 
 from msprobe.pytorch.api_accuracy_checker.run_ut.run_ut_utils import hf_32_standard_api
 from msprobe.pytorch.api_accuracy_checker.common.utils import check_object_type, get_full_data_path, \
-    CompareException
+    CompareException, get_module_and_atttribute_name, get_attribute
 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
-from msprobe.core.common.const import Const, FileCheckConst
+from msprobe.core.common.const import Const, FileCheckConst, CompareConst
 
 TORCH_TYPE = ["torch.device", "torch.dtype"]
 TENSOR_DATA_LIST = ["torch.Tensor", "torch.nn.parameter.Parameter"]
-FLOAT_TYPE = ['torch.float32', 'torch.float', 'torch.float64', 'torch.double', 'torch.float16',
-              'torch.half', 'torch.bfloat16']
-NUMPY_TYPE = ["numpy.int8", "numpy.int16", "numpy.int32", "numpy.int64", "numpy.uint8", "numpy.uint16", "numpy.uint32",
-              "numpy.uint64", "numpy.float16", "numpy.float32", "numpy.float64", "numpy.float128", "numpy.complex64", 
-              "numpy.complex128", "numpy.complex256", "numpy.bool_", "numpy.string_", "numpy.bytes_", "numpy.unicode_"]
+FLOAT_TYPE = [
+            'torch.float32', 
+            'torch.float', 
+            'torch.float64', 
+            'torch.double', 
+            'torch.float16',
+            'torch.half', 
+            'torch.bfloat16'
+            ]
+NUMPY_TYPE = [
+            "numpy.int8", "numpy.int16", "numpy.int32", "numpy.int64", "numpy.uint8", "numpy.uint16", "numpy.uint32",
+            "numpy.uint64", "numpy.float16", "numpy.float32", "numpy.float64", "numpy.float128", "numpy.complex64", 
+            "numpy.complex128", "numpy.complex256", "numpy.bool_", "numpy.string_", "numpy.bytes_", "numpy.unicode_"
+            ]
 
 
 def gen_data(info, api_name, need_grad, convert_type, real_data_path=None):
@@ -68,7 +77,8 @@ def gen_data(info, api_name, need_grad, convert_type, real_data_path=None):
             raise Exception("{} is not supported now".format(data_type))
         data = info.get("value")
         try:
-            data = eval(data_type)(data)
+            module_name, attribute_name = get_module_and_atttribute_name(data_type)
+            data = get_attribute(module_name, attribute_name)(data)
         except Exception as err:
             logger.error("Failed to convert the type to numpy: %s" % str(err))
     elif data_type == "torch.Size":
@@ -104,8 +114,9 @@ def gen_real_tensor(data_path, convert_type):
     if convert_type:
         ori_dtype = Const.CONVERT.get(convert_type)[0]
         dist_dtype = Const.CONVERT.get(convert_type)[1]
+        module_name, attribute_name = get_module_and_atttribute_name(dist_dtype)
         if str(data.dtype) == ori_dtype:
-            data = data.type(eval(dist_dtype))
+            data = data.type(get_attribute(module_name, attribute_name))
     return data
 
 
@@ -118,8 +129,12 @@ def gen_random_tensor(info, convert_type):
         convert_type: convert ori_type to dist_type flag.
     """
     check_object_type(info, dict)
-    low, high = info.get('Min'), info.get('Max')
-    low_origin, high_origin = info.get('Min_origin'), info.get('Max_origin')
+
+    low_origin = info.get('Min')
+    low = info.get('Min_except_inf_nan', low_origin)
+    high_origin = info.get('Max')
+    high = info.get('Max_except_inf_nan', high_origin)
+    
     low_info = [low, low_origin]
     high_info = [high, high_origin]
     data_dtype = info.get('dtype')
@@ -164,33 +179,35 @@ def gen_common_tensor(low_info, high_info, shape, data_dtype, convert_type):
             data_dtype = Const.CONVERT.get(convert_type)[1]
     low, low_origin = low_info[0], low_info[1]
     high, high_origin = high_info[0], high_info[1]
-    if data_dtype in FLOAT_TYPE:
+    module_name, attribute_name = get_module_and_atttribute_name(data_dtype)
+    dtype = get_attribute(module_name, attribute_name)
+    if data_dtype in FLOAT_TYPE: 
         if math.isnan(high):
-            tensor = torch._C._VariableFunctionsClass.full(shape, float('nan'), dtype=eval(data_dtype))
+            tensor = torch.full(shape, float('nan'), dtype=dtype)
             return tensor
         #high_origin为新版json中的属性，只有当high_origin不为None,且high为inf或-inf时，原tensor全为inf或-inf
-        if high_origin and high in [float('inf'), float('-inf')]:
-            tensor = torch._C._VariableFunctionsClass.full(shape, high, dtype=eval(data_dtype))
+        if high_origin and high in [float(CompareConst.INF), float(CompareConst.NEG_INF)]:
+            tensor = torch.full(shape, high, dtype=dtype)
             tensor[-1] = low
             return tensor
         low_scale, high_scale = low, high
-        dtype_finfo = torch.finfo(eval(data_dtype))
+        dtype_finfo = torch.finfo(dtype)
         #适配老版json high和low为inf或-inf的情况，取dtype的最大值或最小值进行放缩
-        if high == float('inf'):
+        if high == float(CompareConst.INF):
             high_scale = dtype_finfo.max
-        elif high == float('-inf'):
+        elif high == float(CompareConst.NEG_INF):
             high_scale = dtype_finfo.min
-        if low == float('inf'):
+        if low == float(CompareConst.INF):
             low_scale = dtype_finfo.max
-        elif low == float('-inf'):
+        elif low == float(CompareConst.NEG_INF):
             low_scale = dtype_finfo.min
 
         scale = high_scale - low_scale
-        rand01 = torch.rand(shape, dtype=eval(data_dtype))
+        rand01 = torch.rand(shape, dtype=dtype)
         tensor = rand01 * scale + low_scale
     elif 'int' in data_dtype or 'long' in data_dtype:
         low, high = int(low), int(high)
-        tensor = torch.randint(low, high + 1, shape, dtype=eval(data_dtype))
+        tensor = torch.randint(low, high + 1, shape, dtype=dtype)
     else:
         logger.error('Dtype is not supported: ' + data_dtype)
         raise NotImplementedError()
@@ -208,9 +225,9 @@ def gen_common_tensor(low_info, high_info, shape, data_dtype, convert_type):
     else:
         tmp_tensor[0] = low
         tmp_tensor[-1] = high
-        if high_origin in [float('inf'), float('-inf')]:
+        if high_origin in [float(CompareConst.INF), float(CompareConst.NEG_INF)]:
             tmp_tensor[-1] = high_origin
-        if low_origin in [float('inf'), float('-inf')]:
+        if low_origin in [float(CompareConst.INF), float(CompareConst.NEG_INF)]:
             tmp_tensor[0] = low_origin
     data = tmp_tensor.reshape(shape)
     return data
@@ -233,7 +250,7 @@ def gen_bool_tensor(low, high, shape):
     return data
 
 
-def gen_args(args_info, api_name, need_grad=True, convert_type=None, real_data_path=None):
+def gen_args(args_info, api_name, func_options):
     """
     Function Description:
         Based on API basic information, generate input parameters: args, for API forward running
@@ -246,9 +263,20 @@ def gen_args(args_info, api_name, need_grad=True, convert_type=None, real_data_p
     """
     check_object_type(args_info, list)
     args_result = []
+    
+    need_grad = func_options.get('need_grad', True)
+    convert_type = func_options.get('convert_type', None)
+    real_data_path = func_options.get('real_data_path', None)
+    depth = func_options.get('depth', 0)
+
+    if depth > Const.MAX_DEPTH:
+        logger.error("The depth of args is too large, please check the input args.")
+        raise CompareException(CompareException.RECURSION_LIMIT_ERROR)
+    
     for arg in args_info:
         if isinstance(arg, (list, tuple)):
-            data = gen_args(arg, api_name, need_grad, convert_type, real_data_path)
+            func_options['depth'] = depth + 1
+            data = gen_args(arg, api_name, func_options)
         elif isinstance(arg, dict):
             data = gen_data(arg, api_name, need_grad, convert_type, real_data_path)
         elif arg is None:
@@ -288,7 +316,8 @@ def gen_kwargs(api_info, api_name, convert_type=None, real_data_path=None):
 
 def gen_torch_kwargs(kwargs_params, key, value):
     if value.get('type') != "torch.device":
-        kwargs_params[key] = eval(value.get('value'))
+        module_name, attribute_name = get_module_and_atttribute_name(value.get('value'))
+        kwargs_params[key] = get_attribute(module_name, attribute_name)
 
 
 def gen_list_kwargs(kwargs_item_value, api_name, convert_type, real_data_path=None):
@@ -327,8 +356,14 @@ def gen_api_params(api_info, api_name, need_grad=True, convert_type=None, real_d
         error_info = f"convert_type params not support {convert_type}."
         raise CompareException(CompareException.INVALID_PARAM_ERROR, error_info)
     kwargs_params = gen_kwargs(api_info, api_name, convert_type, real_data_path)
+    func_options = {
+        'need_grad': need_grad,
+        'convert_type': convert_type,
+        'real_data_path': real_data_path,
+        'depth': 0
+    }
     if api_info.get("input_args"):
-        args_params = gen_args(api_info.get("input_args"), api_name, need_grad, convert_type, real_data_path)
+        args_params = gen_args(api_info.get("input_args"), api_name, func_options)
     else:
         logger.warning(f'Warning: No args in {api_info} ')
         args_params = []

msprobe/pytorch/api_accuracy_checker/run_ut/multi_run_ut.py

@@ -1,3 +1,20 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0  (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 import subprocess
 import json
 import os
@@ -105,7 +122,7 @@ def run_parallel_ut(config):
                 if output == '':
                     break
                 if '[ERROR]' in output:
-                    print(output, end='')
+                    logger.warning(output, end='')
                     sys.stdout.flush()
         except ValueError as e:
             logger.warning(f"An error occurred while reading subprocess output: {e}")
@@ -119,7 +136,8 @@ def run_parallel_ut(config):
 
     for api_info in config.api_files:
         cmd = create_cmd(api_info, next(device_id_cycle))
-        process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, text=True, bufsize=1, shell=False)
+        process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.DEVNULL, 
+                                   text=True, bufsize=1, shell=False)
         processes.append(process)
         threading.Thread(target=read_process_output, args=(process,), daemon=True).start()
 
@@ -150,7 +168,8 @@ def run_parallel_ut(config):
         logger.error(f"An unexpected error occurred: {e}")
     finally:
         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 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.")
         clean_up()
         progress_bar_thread.join()
     try:
@@ -173,7 +192,8 @@ def prepare_config(args):
     out_path = out_path_checker.common_check()
     split_files, total_items = split_json_file(api_info, args.num_splits, args.filter_api)
     config_path = os.path.realpath(args.config_path) if args.config_path else None
-    result_csv_path = args.result_csv_path or os.path.join(out_path, f"accuracy_checking_result_{time.strftime('%Y%m%d%H%M%S')}.csv")
+    result_csv_path = args.result_csv_path or os.path.join(
+                      out_path, f"accuracy_checking_result_{time.strftime('%Y%m%d%H%M%S')}.csv")
     if not args.result_csv_path:
         details_csv_path = os.path.join(out_path, f"accuracy_checking_details_{time.strftime('%Y%m%d%H%M%S')}.csv")
         comparator = Comparator(result_csv_path, details_csv_path, False)
@@ -190,7 +210,8 @@ def prepare_config(args):
 def main():
     parser = argparse.ArgumentParser(description='Run UT in parallel')
     _run_ut_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')
+    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()
     config = prepare_config(args)
     run_parallel_ut(config)

msprobe/pytorch/api_accuracy_checker/run_ut/run_overflow_check.py

@@ -1,3 +1,20 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0  (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 import argparse
 import os
 import sys
@@ -24,8 +41,8 @@ def check_tensor_overflow(x):
             tensor_max = x.cpu().detach().float().numpy().tolist()
             tensor_min = tensor_max
         else:
-            tensor_max = torch._C._VariableFunctionsClass.max(x).cpu().detach().float().numpy().tolist()
-            tensor_min = torch._C._VariableFunctionsClass.min(x).cpu().detach().float().numpy().tolist()
+            tensor_max = torch.max(x).cpu().detach().float().numpy().tolist()
+            tensor_min = torch.min(x).cpu().detach().float().numpy().tolist()
         # inf
         if tensor_max == float('inf') or tensor_min == float('-inf'):
             return True

msprobe/pytorch/api_accuracy_checker/run_ut/run_ut.py

@@ -1,3 +1,20 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Copyright (c) 2024-2024, Huawei Technologies Co., Ltd.
+# All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0  (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
 import argparse
 import os
 import csv
@@ -17,8 +34,8 @@ else:
 import torch
 from tqdm import tqdm
 
-from msprobe.pytorch.api_accuracy_checker.run_ut.run_ut_utils import Backward_Message, hf_32_standard_api, UtDataInfo, \
-    get_validated_result_csv_path, get_validated_details_csv_path, exec_api
+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
 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
@@ -26,13 +43,14 @@ 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.common.parse_json import parse_json_info_forward_backward
-from msprobe.core.common.file_utils import FileOpen, FileChecker, \
-    change_mode, check_path_before_create, create_directory, get_json_contents
+from msprobe.core.common.file_utils import FileChecker, change_mode, check_path_before_create, \
+    create_directory, get_json_contents, read_csv
 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.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
 
 
 current_time = time.strftime("%Y%m%d%H%M%S")
@@ -46,14 +64,7 @@ RunUTConfig = namedtuple('RunUTConfig', ['forward_content', 'backward_content',
 OnlineConfig = namedtuple('OnlineConfig', ['is_online', 'nfs_path', 'host', 'port', 'rank_list', 'tls_path'])
 
 not_backward_list = ['repeat_interleave']
-not_detach_set = {'resize_', 'resize_as_', 'set_', 'transpose_', 't_', 'squeeze_', 'unsqueeze_'}
-not_raise_dtype_set = {'type_as'}
 
-RAISE_PRECISION = {
-    torch.float16: torch.float32,
-    torch.bfloat16: torch.float32,
-    torch.float32: torch.float64
-}
 
 tqdm_params = {
     'smoothing': 0,  # 平滑进度条的预计剩余时间，取值范围0到1
@@ -71,98 +82,6 @@ tqdm_params = {
 }
 
 
-def deal_detach(arg, to_detach=True):
-    return arg.detach() if to_detach else arg
-
-
-def raise_bench_data_dtype(api_name, arg, raise_dtype=None):
-    '''
-    将标杆数据的dtype转换为raise_dtype
-    输入：
-        api_name：api名称
-        arg：标杆输入
-        raise_dtype：需要转换的dtype
-    输出： 
-        arg: 转换dtype的标杆输入
-    '''
-    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 RAISE_PRECISION or raise_dtype == arg.dtype:
-        return arg
-    return arg.type(raise_dtype)
-
-
-def generate_device_params(input_args, input_kwargs, need_backward, api_name):
-    def recursive_arg_to_device(arg_in, to_detach):
-        if isinstance(arg_in, (list, tuple)):
-            return type(arg_in)(recursive_arg_to_device(arg, to_detach) for arg in arg_in)
-        elif isinstance(arg_in, torch.Tensor):
-            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
-                arg_in = temp_arg_in.type_as(arg_in)
-                arg_in.retain_grad()
-                return arg_in
-            else:
-                return deal_detach(arg_in.clone(), to_detach).to(current_device)
-        else:
-            return arg_in
-
-    is_detach = api_name not in not_detach_set
-    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
-
-
-def generate_cpu_params(input_args, input_kwargs, need_backward, api_name):
-    def recursive_arg_to_cpu(arg_in, to_detach, raise_dtype=None):
-        if isinstance(arg_in, (list, tuple)):
-            return type(arg_in)(recursive_arg_to_cpu(arg, to_detach, raise_dtype=raise_dtype) for arg in arg_in)
-        elif isinstance(arg_in, torch.Tensor):
-            if need_backward and arg_in.requires_grad:
-                arg_in = deal_detach(raise_bench_data_dtype(
-                                     api_name, arg_in.clone(), raise_dtype=raise_dtype), to_detach).requires_grad_()
-                temp_arg_in = arg_in * 1
-                arg_in = temp_arg_in.type_as(arg_in)
-                arg_in.retain_grad()
-                return arg_in
-            else:
-                return deal_detach(raise_bench_data_dtype(api_name, arg_in.clone(), raise_dtype=raise_dtype), to_detach)
-        else:
-            return arg_in
-
-    def is_tensor_with_raise_precision(arg_in, check_kwargs=False):
-        if arg_in.dtype in RAISE_PRECISION:
-            return True
-        if check_kwargs and arg_in.dtype in [torch.half, torch.bfloat16]:
-            return True
-        return False
-
-    def recursive_find_dtypes(arg_in, kwargs=None, check_kwargs=False):
-        if isinstance(arg_in, (list, tuple)):
-            return set().union(*tuple(recursive_find_dtypes(arg, kwargs, check_kwargs=check_kwargs) 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) for v in arg_in.values()))
-        return set()
-
-    raise_dtype = None
-    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 = RAISE_PRECISION.get(need_raise_dtypes.pop(), torch.float32)
-    elif len(need_raise_dtypes) >= 2:
-        raise_dtype = torch.float32
-
-    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
-
-
 def run_ut(config):
     logger.info("start UT test")
     if config.online_config.is_online:
@@ -179,10 +98,8 @@ def run_ut(config):
     if config.online_config.is_online:
         run_api_online(config, compare)
     else:
-        with FileOpen(config.result_csv_path, 'r') as file:
-            csv_reader = csv.reader(file)
-            next(csv_reader)
-            api_name_set = {row[0] for row in csv_reader}
+        csv_df = read_csv(config.result_csv_path)
+        api_name_set = {row[0] for row in csv_df.itertuples(index=False, name=None)}
         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)
@@ -198,17 +115,23 @@ 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."
+            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."
             logger.error(err_message)
-            fwd_compare_alg_results = err_column.to_column_value(CompareConst.SKIP, err_message)
-            result_info = (api_full_name, CompareConst.SKIP, CompareConst.SKIP, [fwd_compare_alg_results], None, 0)
-            compare.record_results(result_info)
+            compare_alg_results = err_column.to_column_value(CompareConst.SKIP, err_message)
+            record_skip_info(api_full_name, compare, compare_alg_results)
             continue
         try:
             if blacklist_and_whitelist_filter(api_name, config.black_list, config.white_list):
+                skip_message = f"API {api_name} in black list or not in white list. SKIP."
+                logger.info(skip_message)
+                compare_alg_results = err_column.to_column_value(CompareConst.SKIP, skip_message)
+                record_skip_info(api_full_name, compare, compare_alg_results)
                 continue
             data_info = run_torch_api(api_full_name, config.real_data_path, config.backward_content, api_info_dict)
             is_fwd_success, is_bwd_success = compare.compare_output(api_full_name, data_info)
@@ -220,9 +143,8 @@ def run_api_offline(config, compare, api_name_set):
                                f"'int32_to_int64' list in accuracy_tools/api_accuracy_check/common/utils.py file.")
             else:
                 logger.error(f"Run {api_full_name} UT Error: %s" % str(err))
-            fwd_compare_alg_results = err_column.to_column_value(CompareConst.SKIP, str(err))
-            result_info = (api_full_name, CompareConst.SKIP, CompareConst.SKIP, [fwd_compare_alg_results], None, 0)
-            compare.record_results(result_info)
+            compare_alg_results = err_column.to_column_value(CompareConst.SKIP, str(err))
+            record_skip_info(api_full_name, compare, compare_alg_results)
         finally:
             if is_gpu:
                 torch.cuda.empty_cache()
@@ -327,12 +249,12 @@ def run_torch_api(api_full_name, real_data_path, backward_content, api_info_dict
     in_fwd_data_list.append(kwargs)
     need_backward = api_full_name in backward_content
     if not need_grad:
-        logger.warning("%s %s" % (api_full_name, Backward_Message.UNSUPPORT_BACKWARD_MESSAGE))
-        backward_message += Backward_Message.UNSUPPORT_BACKWARD_MESSAGE
+        logger.warning("%s %s" % (api_full_name, BackwardMessage.UNSUPPORT_BACKWARD_MESSAGE))
+        backward_message += BackwardMessage.UNSUPPORT_BACKWARD_MESSAGE
     if api_name in not_backward_list:
         need_grad = False
-        logger.warning("%s %s" % (api_full_name, Backward_Message.NO_BACKWARD_RESULT_MESSAGE))
-        backward_message += Backward_Message.NO_BACKWARD_RESULT_MESSAGE
+        logger.warning("%s %s" % (api_full_name, BackwardMessage.NO_BACKWARD_RESULT_MESSAGE))
+        backward_message += BackwardMessage.NO_BACKWARD_RESULT_MESSAGE
     need_backward = need_backward and need_grad
     if kwargs.get("device"):
         del kwargs["device"]
@@ -353,13 +275,16 @@ def run_torch_api(api_full_name, real_data_path, backward_content, api_info_dict
     if need_backward:
         if need_to_backward(grad_index, out):
             backward_args = backward_content[api_full_name].get("input")
-            grad = gen_args(backward_args, api_name, real_data_path=real_data_path)[0]
+            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)
             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 += Backward_Message.MULTIPLE_BACKWARD_MESSAGE
+            backward_message += BackwardMessage.MULTIPLE_BACKWARD_MESSAGE
     if api_name == "npu_fusion_attention":
         out = out[0]
         device_out = device_out[0]
@@ -416,7 +341,7 @@ def initialize_save_error_data(error_data_path):
     error_data_path_checker = FileChecker(error_data_path, FileCheckConst.DIR,
                                           ability=FileCheckConst.WRITE_ABLE)
     error_data_path = error_data_path_checker.common_check()
-    error_data_path =initialize_save_path(error_data_path, UT_ERROR_DATA_DIR)
+    error_data_path = initialize_save_path(error_data_path, UT_ERROR_DATA_DIR)
     return error_data_path
 
 
@@ -477,7 +402,8 @@ def preprocess_forward_content(forward_content):
         if key not in arg_cache:
             filtered_new_args = [
                 {k: v for k, v in arg.items() if k not in ['Max', 'Min']}
-                for arg in value['input_args'] if isinstance(arg, dict)
+                for arg in value['input_args']
+                if isinstance(arg, dict)
             ]
             arg_cache[key] = (filtered_new_args, value['input_kwargs'])
 
@@ -529,14 +455,14 @@ def run_ut_command(args):
     # 离线场景下，forward_content, backward_content, real_data_path从api_info_file中解析
     forward_content, backward_content, real_data_path = None, None, None
     if 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_file_checker = FileChecker(file_path=args.api_info_file, path_type=FileCheckConst.FILE, 
+                                            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 args.filter_api:
-            logger.info("Start filtering the api in the forward_input_file.")
+            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 forward_input_file.")
+            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)