mindstudio-probe 1.0.1__py3-none-any.whl

msprobe/pytorch/api_accuracy_checker/run_ut/data_generate.py

@@ -0,0 +1,328 @@
+#!/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");
+# 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 os
+import math
+import torch
+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_file_or_directory_path, check_object_type, \
+    get_full_data_path, CompareException
+from msprobe.pytorch.common.log import logger
+from msprobe.core.common.const import Const
+
+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_"]
+
+
+def gen_data(info, api_name, need_grad, convert_type, real_data_path=None):
+    """
+    Function Description:
+        Based on arg basic information, generate arg data
+    Parameter:
+        info: arg basic information. Dict
+        api_name: API name
+        need_grad: set Tensor grad for backward
+        convert_type: convert ori_type to dist_type flag.
+    """
+    check_object_type(info, dict)
+    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)
+    if data_type in TENSOR_DATA_LIST:
+        if data_path:
+            data = gen_real_tensor(data_path, convert_type)
+        else:
+            data = gen_random_tensor(info, convert_type)
+        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:
+            data.requires_grad_(True)
+            temp_data = data * 1
+            data = temp_data.type_as(data)
+            data.retain_grad()
+    elif data_type.startswith("numpy"):
+        if data_type not in NUMPY_TYPE:
+            raise Exception("{} is not supported now".format(data_type))
+        data = info.get("value")
+        try:
+            data = eval(data_type)(data)
+        except Exception as err:
+            logger.error("Failed to convert the type to numpy: %s" % str(err))
+    elif data_type == "torch.Size":
+        data = torch.Size(info.get("value"))
+    else:
+        data = info.get('value')
+        if info.get("type") == "slice":
+            data = slice(*data)
+    return data
+
+
+def gen_real_tensor(data_path, convert_type):
+    """
+    Function Description:
+        Based on API data path, generate input parameters real data
+    Parameter:
+        data_path: API data path
+        convert_type: convert ori_type to dist_type flag.
+    """
+    data_path = os.path.realpath(data_path)
+    check_file_or_directory_path(data_path)
+    if not data_path.endswith('.pt') and not data_path.endswith('.npy'):
+        error_info = f"The file: {data_path} is not a pt or numpy file."
+        raise CompareException(CompareException.INVALID_FILE_ERROR, error_info)
+    if data_path.endswith('.pt'):
+        data = torch.load(data_path).cpu()
+    else:
+        data_np = numpy.load(data_path)
+        data = torch.from_numpy(data_np)
+    if convert_type:
+        ori_dtype = Const.CONVERT.get(convert_type)[0]
+        dist_dtype = Const.CONVERT.get(convert_type)[1]
+        if str(data.dtype) == ori_dtype:
+            data = data.type(eval(dist_dtype))
+    return data
+
+
+def gen_random_tensor(info, convert_type):
+    """
+    Function Description:
+        Based on API MAX and MIN, generate input parameters random data
+    Parameter:
+        info: API data info
+        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_info = [low, low_origin]
+    high_info = [high, high_origin]
+    data_dtype = info.get('dtype')
+    shape = tuple(info.get('shape'))
+    if not isinstance(low, (int, float)) or not isinstance(high, (int, float)):
+        error_info = f'Data info Min: {low} , Max: {high}, info type must be int or float.'
+        raise CompareException(CompareException.INVALID_PARAM_ERROR, error_info)
+    if data_dtype == "torch.bool":
+        data = gen_bool_tensor(low, high, shape)
+    else:
+        data = gen_common_tensor(low_info, high_info, shape, data_dtype, convert_type)
+    return data
+
+
+def fp32_to_hf32_to_fp32(input_tensor):
+    # 将输入的float32 tensor转为hf32 tensor，再转为float32 tensor
+    input_np = input_tensor.detach().numpy()
+    input_int = input_np.view(numpy.int32)
+    input_int = numpy.right_shift(numpy.right_shift(input_int, 11) + 1, 1)
+    input_int = numpy.left_shift(input_int, 12)
+    input_fp32 = input_int.view(numpy.float32)
+    input_hf32 = torch.from_numpy(input_fp32)
+    return input_hf32
+
+
+def gen_common_tensor(low_info, high_info, shape, data_dtype, convert_type):
+    """
+    Function Description:
+        Based on API basic information, generate int or float tensor
+    Parameter:
+        low_info: [low, low_origin], low is the minimum value in the tensor removed inf and nan, 
+        low_origin is the original minimum value in the tensor
+        high_info: [high, high_origin], high is the maximum value in the tensor removed inf and nan, 
+        high_origin is the original maximum value in the tensor
+        shape:The shape of Tensor
+        data_dtype: The data type of Tensor
+        convert_type: convert ori_type to dist_type flag.
+    """
+    if convert_type:
+        ori_dtype = Const.CONVERT.get(convert_type)[0]
+        if ori_dtype == data_dtype:
+            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:
+        if math.isnan(high):
+            tensor = torch._C._VariableFunctionsClass.full(shape, float('nan'), dtype=eval(data_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))
+            tensor[-1] = low
+            return tensor
+        low_scale, high_scale = low, high
+        dtype_finfo = torch.finfo(eval(data_dtype))
+        #适配老版json high和low为inf或-inf的情况，取dtype的最大值或最小值进行放缩
+        if high == float('inf'):
+            high_scale = dtype_finfo.max
+        elif high == float('-inf'):
+            high_scale = dtype_finfo.min
+        if low == float('inf'):
+            low_scale = dtype_finfo.max
+        elif low == float('-inf'):
+            low_scale = dtype_finfo.min
+
+        scale = high_scale - low_scale
+        rand01 = torch.rand(shape, dtype=eval(data_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))
+    else:
+        logger.error('Dtype is not supported: ' + data_dtype)
+        raise NotImplementedError()
+    if tensor.nelement() == 0:
+        return tensor
+    tmp_tensor = tensor.reshape(-1)
+    if high_origin and math.isnan(high_origin):
+        if tmp_tensor.numel() <= 2:
+            tmp_tensor[0] = float('nan')
+            tmp_tensor[-1] = high
+        else:
+            tmp_tensor[0] = low
+            tmp_tensor[1] = float('nan')
+            tmp_tensor[-1] = high
+    else:
+        tmp_tensor[0] = low
+        tmp_tensor[-1] = high
+        if high_origin in [float('inf'), float('-inf')]:
+            tmp_tensor[-1] = high_origin
+        if low_origin in [float('inf'), float('-inf')]:
+            tmp_tensor[0] = low_origin
+    data = tmp_tensor.reshape(shape)
+    return data
+
+
+def gen_bool_tensor(low, high, shape):
+    """
+    Function Description:
+        Based on API basic information, generate bool tensor
+    Parameter:
+        low: The minimum value in Tensor
+        high: The max value in Tensor
+        shape:The shape of Tensor
+    """
+    low, high = int(low), int(high)
+    if low > high:
+        low, high = high, low
+    tensor = torch.randint(low, high + 1, shape)
+    data = torch.gt(tensor, 0)
+    return data
+
+
+def gen_args(args_info, api_name, need_grad=True, convert_type=None, real_data_path=None):
+    """
+    Function Description:
+        Based on API basic information, generate input parameters: args, for API forward running
+    Parameter:
+        api_info: API basic information. List
+        api_name: API name
+        need_grad: set Tensor grad for backward
+        convert_type: convert ori_type to dist_type flag.
+        real_data_path: the root directory for storing real data.
+    """
+    check_object_type(args_info, list)
+    args_result = []
+    for arg in args_info:
+        if isinstance(arg, (list, tuple)):
+            data = gen_args(arg, api_name, need_grad, convert_type, real_data_path)
+        elif isinstance(arg, dict):
+            data = gen_data(arg, api_name, need_grad, convert_type, real_data_path)
+        elif arg is None:
+            data = None
+        else:
+            logger.warning(f'Warning: {arg} is not supported')
+            raise NotImplementedError()
+        args_result.append(data)
+    return args_result
+
+
+def gen_kwargs(api_info, convert_type=None, real_data_path=None):
+    """
+    Function Description:
+        Based on API basic information, generate input parameters: kwargs, for API forward running
+    Parameter:
+        api_info: API basic information. Dict
+        convert_type: convert ori_type to dist_type flag.
+        real_data_path: the root directory for storing real data.
+    """
+    check_object_type(api_info, dict)
+    kwargs_params = api_info.get("input_kwargs")
+    for key, value in kwargs_params.items():
+        if isinstance(value, (list, tuple)):
+            kwargs_params[key] = gen_list_kwargs(value, convert_type, real_data_path)
+        elif value is None:
+            kwargs_params[key] = None
+        elif value.get('type') in TENSOR_DATA_LIST or value.get('type').startswith("numpy"):
+            kwargs_params[key] = gen_data(value, True, convert_type, real_data_path)
+        elif value.get('type') in TORCH_TYPE:
+            gen_torch_kwargs(kwargs_params, key, value)
+        else:
+            kwargs_params[key] = value.get('value')
+    return kwargs_params
+
+
+def gen_torch_kwargs(kwargs_params, key, value):
+    if value.get('type') != "torch.device":
+        kwargs_params[key] = eval(value.get('value'))
+
+
+def gen_list_kwargs(kwargs_item_value, convert_type, real_data_path=None):
+    """
+    Function Description:
+        When kwargs value is list, generate the list of kwargs result
+    Parameter:
+        kwargs_item_value: kwargs value before to generate. List
+        convert_type: convert ori_type to dist_type flag.
+    """
+    kwargs_item_result = []
+    for item in kwargs_item_value:
+        if item.get('type') in TENSOR_DATA_LIST:
+            item_value = gen_data(item, False, convert_type, real_data_path)
+        elif item.get('type') == "torch.Size":
+            item_value = torch.Size(item.get('value'))
+        else:
+            item_value = item.get('value')
+        kwargs_item_result.append(item_value)
+    return kwargs_item_result
+
+
+def gen_api_params(api_info, api_name, need_grad=True, convert_type=None, real_data_path=None):
+    """
+    Function Description:
+        Based on API basic information, generate input parameters: args, kwargs, for API forward running
+    Parameter:
+        api_info: API basic information. Dict
+        api_name: API name
+        need_grad: set grad for backward
+        convert_type: convert ori_type to dist_type flag.
+    """
+    check_object_type(api_info, dict)
+    if convert_type and convert_type not in Const.CONVERT:
+        error_info = f"convert_type params not support {convert_type}."
+        raise CompareException(CompareException.INVALID_PARAM_ERROR, error_info)
+    kwargs_params = gen_kwargs(api_info, convert_type, real_data_path)
+    if api_info.get("input_args"):
+        args_params = gen_args(api_info.get("input_args"), api_name, need_grad, convert_type, real_data_path)
+    else:
+        logger.warning(f'Warning: No args in {api_info} ')
+        args_params = []
+    return args_params, kwargs_params

msprobe/pytorch/api_accuracy_checker/run_ut/multi_run_ut.py

@@ -0,0 +1,203 @@
+import subprocess
+import json
+import os
+import sys
+import argparse
+import time
+import signal
+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, get_validated_result_csv_path, \
+    get_validated_details_csv_path, preprocess_forward_content
+from msprobe.pytorch.api_accuracy_checker.compare.compare import Comparator
+from msprobe.pytorch.common import parse_json_info_forward_backward
+from msprobe.core.common.file_check import FileChecker, check_file_suffix, check_link, FileOpen, \
+    check_path_before_create, create_directory
+from msprobe.pytorch.common.log import logger
+from msprobe.core.common.const import FileCheckConst
+
+
+def split_json_file(input_file, num_splits, filter_api):
+    forward_data, backward_data, real_data_path = parse_json_info_forward_backward(input_file)
+    if filter_api:
+        forward_data = preprocess_forward_content(forward_data)
+    for data_name in list(forward_data.keys()):
+        forward_data[f"{data_name}.forward"] = forward_data.pop(data_name)
+    for data_name in list(backward_data.keys()):
+        backward_data[f"{data_name}.backward"] = backward_data.pop(data_name)
+
+    with FileOpen(input_file, 'r') as file:
+        input_data = json.load(file)
+        input_data.pop("data")
+
+    items = list(forward_data.items())
+    total_items = len(items)
+    chunk_size = total_items // num_splits
+    split_files = []
+
+    for i in range(num_splits):
+        start = i * chunk_size
+        end = (i + 1) * chunk_size if i < num_splits - 1 else total_items
+
+        split_forward_data = dict(items[start:end])
+        temp_data = {
+            **input_data,
+            "data":{
+                **split_forward_data,
+                **backward_data
+            }
+        }
+        split_filename = f"temp_part{i}.json"
+        with FileOpen(split_filename, 'w') as split_file:
+            json.dump(temp_data, split_file)
+        split_files.append(split_filename)
+
+    return split_files, total_items
+
+
+def signal_handler(signum, frame):
+    logger.warning(f'Signal handler called with signal {signum}')
+    raise KeyboardInterrupt()
+
+
+signal.signal(signal.SIGINT, signal_handler)
+signal.signal(signal.SIGTERM, signal_handler)
+
+
+ParallelUTConfig = namedtuple('ParallelUTConfig', ['api_files', 'out_path', 'num_splits',
+                                                   'save_error_data_flag', 'jit_compile_flag', 'device_id',
+                                                   'result_csv_path', 'total_items', 'real_data_path'])
+
+
+def run_parallel_ut(config):
+    processes = []
+    device_id_cycle = cycle(config.device_id)
+    if config.save_error_data_flag:
+        logger.info("UT task error datas will be saved")
+    logger.info(f"Starting parallel UT 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")
+        cmd = [
+            sys.executable, run_ut_path,
+            '-api_info', api_info,
+            *(['-o', config.out_path] if config.out_path else []),
+            '-d', str(dev_id),
+            *(['-j'] if config.jit_compile_flag else []),
+            *(['-save_error_data'] if config.save_error_data_flag else []),
+            '-csv_path', config.result_csv_path,
+            *(['-real_data_path', config.real_data_path] if config.real_data_path else [])
+        ]
+        return cmd
+
+    def read_process_output(process):
+        try:
+            while True:
+                if process.poll() is not None:
+                    break
+                output = process.stdout.readline()
+                if output == '':
+                    break
+                if '[ERROR]' in output:
+                    print(output, end='')
+                    sys.stdout.flush()
+        except ValueError as e:
+            logger.warning(f"An error occurred while reading subprocess output: {e}")
+
+    def update_progress_bar(progress_bar, result_csv_path):
+        while any(process.poll() is None for process in processes):
+            try:
+                with open(result_csv_path, 'r') as result_file:
+                    completed_items = len(result_file.readlines()) - 1
+                    progress_bar.update(completed_items - progress_bar.n)
+            except FileNotFoundError:
+                logger.warning(f"Result CSV file not found: {result_csv_path}.")
+            except Exception as e:
+                logger.error(f"An unexpected error occurred while reading result CSV: {e}")
+            time.sleep(1)
+
+    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)
+        processes.append(process)
+        threading.Thread(target=read_process_output, args=(process,), daemon=True).start()
+
+    progress_bar_thread = threading.Thread(target=update_progress_bar, args=(progress_bar, config.result_csv_path))
+    progress_bar_thread.start()
+
+    def clean_up():
+        progress_bar.close()
+        for process in processes:
+            try:
+                process.terminate()
+                process.wait(timeout=1)
+            except subprocess.TimeoutExpired:
+                process.kill()
+        for file in config.api_files:
+            check_link(file)
+            try:
+                os.remove(file)
+            except FileNotFoundError:
+                logger.warning(f"File not found and could not be deleted: {file}")
+
+    try:
+        for process in processes:
+            process.communicate(timeout=None)
+    except KeyboardInterrupt:
+        logger.warning("Interrupted by user, terminating processes and cleaning up...")
+    except Exception as e:
+        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.")
+        clean_up()
+        progress_bar_thread.join()
+    try:
+        comparator = Comparator(config.result_csv_path, config.result_csv_path, False)
+        comparator.print_pretest_result()
+    except FileNotFoundError as e:
+        logger.error(f"Error: {e}")
+    except Exception as e:
+        logger.error(f"An unexpected error occurred: {e}")
+
+
+def prepare_config(args):
+    check_link(args.api_info_file)
+    api_info = os.path.realpath(args.api_info_file)
+    check_file_suffix(api_info, FileCheckConst.JSON_SUFFIX)
+    out_path = os.path.realpath(args.out_path) if args.out_path else "./"
+    check_path_before_create(out_path)
+    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 = split_json_file(api_info, args.num_splits, args.filter_api)
+
+    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)
+    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}")
+    return ParallelUTConfig(split_files, out_path, args.num_splits, args.save_error_data,
+                            args.jit_compile, args.device_id, result_csv_path,
+                            total_items, args.real_data_path)
+
+
+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')
+    args = parser.parse_args()
+    config = prepare_config(args)
+    run_parallel_ut(config)
+
+
+if __name__ == '__main__':
+    main()

msprobe/pytorch/api_accuracy_checker/run_ut/run_overflow_check.py

@@ -0,0 +1,127 @@
+import argparse
+import os
+import sys
+
+try:
+    import torch_npu
+except ImportError:
+    is_gpu = True
+else:
+    is_gpu = False
+import torch
+from tqdm import tqdm
+from msprobe.pytorch.api_accuracy_checker.run_ut.run_ut import exec_api, generate_device_params, get_api_info
+from msprobe.pytorch.api_accuracy_checker.common.utils import get_json_contents
+from msprobe.core.common.file_check import check_link
+from msprobe.pytorch.common.log import logger
+
+def check_tensor_overflow(x):
+    if isinstance(x, torch.Tensor) and x.numel() != 0 and x.dtype != torch.bool:
+        if len(x.shape) == 0:
+            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()
+        # inf
+        if tensor_max == float('inf') or tensor_min == float('-inf'):
+            return True
+        # nan
+        elif tensor_max != tensor_max or tensor_min != tensor_min:
+            return True
+        else:
+            return False
+    elif isinstance(x, bool) or isinstance(x, int) or isinstance(x, float):
+        if x == float('inf') or x == float('-inf') or x != x:
+            return True
+        else:
+            return False
+    else:
+        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
+    else:
+        return check_tensor_overflow(x)
+
+
+def run_overflow_check(forward_file):
+    logger.info("start UT test")
+    forward_content = get_json_contents(forward_file)
+    for api_full_name, api_info_dict in tqdm(forward_content.items()):
+        try:
+            run_torch_api(api_full_name, api_info_dict)
+        except Exception as err:
+            api_name = api_full_name.split("_", 1)[1].rsplit("_", 2)[0]
+            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.")
+            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.")
+            else:
+                logger.error(f"Run {api_full_name} UT Error: %s" % str(err))
+
+
+def run_torch_api(api_full_name, api_info_dict):
+    torch.npu.clear_npu_overflow_flag()
+    api_type = api_full_name.split(".")[0]
+    api_name = api_full_name.split(".", 1)[1].rsplit(".", 2)[0]
+    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)
+    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, args, kwargs)
+    npu_out = exec_api(api_type, api_name, npu_args, npu_kwargs)
+    cpu_overflow = check_data_overflow(out)
+    npu_overflow = torch_npu.npu.utils.npu_check_overflow(npu_out)
+    if cpu_overflow == npu_overflow:
+        logger.warning("The %s overflow is a normal overflow." % api_full_name)
+    else:
+        logger.warning("The %s overflow is an abnormal overflow." % api_full_name)
+    return
+
+
+def _run_overflow_check_parser(parser):
+    parser.add_argument("-api_info", "--api_info_file", dest="api_info_file", default="",
+                        help="<Required> The api param tool result file: generate from api param tool, "
+                             "a json file.",
+                        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",
+                        default=0, required=False)
+
+
+def _run_overflow_check(parser=None):
+    if not parser:
+        parser = argparse.ArgumentParser()
+    _run_overflow_check_parser(parser)
+    args = parser.parse_args(sys.argv[1:])
+    _run_overflow_check_command(args)
+
+
+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)
+    try:
+        torch.npu.set_device(npu_device)
+    except Exception as error:
+        logger.error(f"Set NPU device id failed. device id is: {args.device_id}")
+        raise NotImplementedError from error
+    run_overflow_check(api_info)
+
+
+if __name__ == '__main__':
+    _run_overflow_check()
+    logger.info("UT task completed.")