mindstudio-probe 1.0.1__py3-none-any.whl

msprobe/pytorch/online_dispatch/dump_compare.py

@@ -0,0 +1,186 @@
+import os
+import json
+import copy
+from datetime import datetime, timezone
+
+import pandas as pd
+import torch
+from .utils import np_save_data, logger_debug, logger_error, logger_warn, logger_user, COLOR_RED, COLOR_GREEN, \
+    COLOR_RESET, CSV_COLUMN_NAME
+from msprobe.core.common.file_check import FileOpen, change_mode
+from msprobe.core.common.const import CompareConst, FileCheckConst, Const
+from msprobe.pytorch.common.log import logger
+
+class DispatchRunParam:
+    def __init__(self, debug_flag, device_id, root_npu_path, root_cpu_path, process_num, comparator):
+        # static parameters are initialized by constructors, and dynamic parameters are constructed at run time
+        self.debug_flag = debug_flag
+        self.device_id = device_id
+        self.root_npu_path = root_npu_path
+        self.root_cpu_path = root_cpu_path
+        self.process_num = process_num
+        self.process_flag = False
+        self.func_name = None
+        self.func_namespace = None
+        self.aten_api = None
+        self.aten_api_overload_name = None
+        self.single_api_index = None
+        self.api_index = None
+        self.dump_flag = None
+        self.auto_dump_flag = None
+        self.comparator = comparator
+
+
+class DisPatchDataInfo:
+    def __init__(self, cpu_args, cpu_kwargs, all_summery, func, npu_out_cpu, cpu_out, lock):
+        self.cpu_args = cpu_args
+        self.cpu_kwargs = cpu_kwargs
+        self.all_summery = all_summery
+        self.func = func
+        self.npu_out_cpu = npu_out_cpu
+        self.cpu_out = cpu_out
+        self.lock = lock
+
+
+class TimeStatistics:
+    def __init__(self, name_tag, run_param, timeout=5):
+        self.debug = run_param.debug_flag
+        if self.debug:
+            self.fun = run_param.func_name
+            self.device = run_param.device_id
+            self.process = run_param.process_num
+            self.index = run_param.single_api_index
+            self.tag = name_tag
+            self.timeout = timeout
+            self.time = None
+
+    def __enter__(self):
+        if self.debug:
+            self.time = datetime.now(tz=timezone.utc)
+            logger_debug(f'Time[{self.tag}]-ENTER: Dev[{self.device}], Pid[{os.getpid()}], Fun[{self.fun}], ' \
+                         f'Id[{self.index}]')
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if self.debug:
+            cost_time = datetime.now(tz=timezone.utc) - self.time
+            time_cost = f'Time[{self.tag}]-EXIT: Dev[{self.device}], Pid[{os.getpid()}], Fun[{self.fun}], ' \
+                        f'Id[{self.index}], time[{cost_time}]'
+            hot_time_cost = "Hotspot " + time_cost
+
+            if cost_time.total_seconds() > self.timeout:
+                logger_debug(hot_time_cost)
+            else:
+                logger_debug(time_cost)
+
+
+def support_basic_type(data):
+    if isinstance(data, (bool, int, float, torch.Tensor)):
+        return True
+    return False
+
+
+def dump_data(data, prefix, dump_path):
+    if isinstance(data, (tuple, list)) and data:
+        for i, item in enumerate(data):
+            dump_data(item, "{}.{}".format(prefix, i), dump_path)
+        return
+    elif support_basic_type(data):
+        if isinstance(data, torch.Tensor) and data.is_meta:
+            return
+        # dump data may greater than summery_list collect
+        np_save_data(data, prefix, dump_path)
+
+
+def save_temp_summery(api_index, single_api_summery, path, lock):
+    summery_path = os.path.join(path, f'summery.json')
+    lock.acquire()
+    with FileOpen(summery_path, "a") as f:
+        json.dump([api_index, single_api_summery], f)
+        f.write('\n')
+    lock.release()
+
+
+def dispatch_workflow(run_param: DispatchRunParam, data_info: DisPatchDataInfo):
+    cpu_args, cpu_kwargs = data_info.cpu_args, data_info.cpu_kwargs
+    all_summery, func = data_info.all_summery, data_info.func
+    npu_out_cpu, cpu_out, lock = data_info.npu_out_cpu, data_info.cpu_out, data_info.lock
+    single_api_summery = []
+
+    prefix_input = f'{run_param.aten_api}_{run_param.single_api_index}_input'
+    prefix_output = f'{run_param.aten_api}_{run_param.single_api_index}_output'
+
+    accuracy_reached = False
+    with TimeStatistics("COMPARE OUTPUT", run_param):
+        run_param.comparator.compare_output(prefix_output, cpu_out, npu_out_cpu, None, None)
+
+    # user set dump or auto mode will dump
+    if run_param.dump_flag or (run_param.auto_dump_flag and not accuracy_reached):
+        with TimeStatistics("DUMP INPUT", run_param):
+            dump_data(cpu_args, prefix_input, run_param.root_npu_path)
+            if len(cpu_kwargs) > 0:
+                for k, v in cpu_kwargs.items():
+                    kwargs_prefix_name = prefix_input + f'_{k}'
+                    dump_data(v, kwargs_prefix_name, run_param.root_npu_path)
+
+        with TimeStatistics("DUMP OUTPUT", run_param):
+            dump_data(cpu_out, prefix_output, run_param.root_cpu_path)
+            dump_data(npu_out_cpu, prefix_output, run_param.root_npu_path)
+
+    if run_param.process_num == 0:
+        all_summery[run_param.api_index - 1] = copy.deepcopy(single_api_summery)
+    else:
+        save_temp_summery(run_param.api_index - 1, single_api_summery, run_param.root_cpu_path, lock)
+
+
+def get_torch_func(run_param):
+    if hasattr(torch.ops, run_param.func_namespace):
+        ops_func = getattr(torch.ops, run_param.func_namespace)
+        if hasattr(ops_func, run_param.aten_api):
+            ops_aten_func = getattr(ops_func, run_param.aten_api)
+            if hasattr(ops_aten_func, run_param.aten_api_overload_name):
+                ops_aten_overlaod_func = getattr(ops_aten_func, run_param.aten_api_overload_name)
+                return ops_aten_overlaod_func
+    return None
+
+
+def dispatch_multiprocess(run_param, dispatch_data_info):
+    torch_func = get_torch_func(run_param)
+    if torch_func is None:
+        logger.error(f'can not find suitable call api:{run_param.aten_api}')
+    else:
+        dispatch_data_info.func = torch_func
+        dispatch_workflow(run_param, dispatch_data_info)
+
+
+def error_call(err):
+    logger.error(f'multiprocess {err}')
+
+
+def save_csv(all_summery, call_stack_list, csv_path):
+    df = pd.DataFrame(columns=CSV_COLUMN_NAME)
+
+    for index, list_data in enumerate(all_summery):
+        for data in list_data:
+            csv_row_data = {CompareConst.NPU_NAME: data[CompareConst.NPU_NAME],
+                            CompareConst.BENCH_NAME: data[CompareConst.BENCH_NAME],
+                            CompareConst.NPU_DTYPE: data[CompareConst.NPU_DTYPE],
+                            CompareConst.BENCH_DTYPE: data[CompareConst.BENCH_DTYPE],
+                            CompareConst.NPU_SHAPE: data[CompareConst.NPU_SHAPE],
+                            CompareConst.BENCH_SHAPE: data[CompareConst.BENCH_SHAPE],
+                            CompareConst.NPU_MAX: data[CompareConst.NPU_MAX],
+                            CompareConst.NPU_MIN: data[CompareConst.NPU_MIN],
+                            CompareConst.NPU_MEAN: data[CompareConst.NPU_MEAN],
+                            CompareConst.BENCH_MAX: data[CompareConst.BENCH_MAX],
+                            CompareConst.BENCH_MIN: data[CompareConst.BENCH_MIN],
+                            CompareConst.BENCH_MEAN: data[CompareConst.BENCH_MEAN],
+                            CompareConst.COSINE: data[CompareConst.COSINE],
+                            CompareConst.MAX_ABS_ERR: data[CompareConst.MAX_ABS_ERR],
+                            CompareConst.MAX_RELATIVE_ERR: data[CompareConst.MAX_RELATIVE_ERR],
+                            CompareConst.ACCURACY: data[CompareConst.ACCURACY],
+                            CompareConst.STACK: call_stack_list[index],
+                            CompareConst.ERROR_MESSAGE: data[CompareConst.ERROR_MESSAGE]}
+            row_df = pd.DataFrame.from_dict(csv_row_data, orient='index').T
+            df = pd.concat([df, row_df])
+
+    df.to_csv(csv_path, index=False)
+    change_mode(csv_path, FileCheckConst.DATA_FILE_AUTHORITY)

msprobe/pytorch/online_dispatch/single_compare.py

@@ -0,0 +1,391 @@
+import logging
+from functools import wraps
+import torch
+from prettytable import PrettyTable
+from collections import namedtuple
+from .utils import logger_user, logger_debug
+
+def func_log_wrapper():
+    def _out_wrapper(func):
+        @wraps(func)
+        def _in_wrapper(*kargs, **kwargs):
+            logger_debug("start to run: {}".format(func.__name__))
+            x = func(*kargs, **kwargs)
+            logger_debug("end to run: {}".format(func.__name__))
+            return x
+        
+        return _in_wrapper
+    
+    return _out_wrapper
+
+
+class SingleBenchmarkCompareStandard:
+    def __init__(self, high_precision=True):
+        self.high_precision = high_precision
+        self.small_value = 1.0
+        self.error_thd = {torch.float16: [2 ** -11, 2 ** -7],
+                          torch.bfloat16: [2 ** -8, 2 ** -6],
+                          torch.float32: [2 ** -14, 2 ** -11],
+                          torch.float64: [2 ** -14, 2 ** -11]}
+        self.eb_thd = {torch.float16: 2 ** -10,
+                       torch.bfloat16: 2 ** -7,
+                       torch.float32: 2 ** -14,
+                       torch.float64: 2 ** -14}
+        
+    def get_error_thd(self, dtype):
+        if dtype in self.error_thd.keys():
+            if dtype == torch.float64:
+                logging.warning("the output data of fp64 uses the same standard as fp32.")
+            return self.error_thd.get(dtype)[0] if self.high_precision else self.error_thd.get(dtype)[1]
+        logging.error(
+            "Single benchmark compare only supports floating point "
+            "in fp16, bf16, fp32. "
+        )
+        return None
+    
+    def get_eb_thd(self, dtype):
+        if dtype in self.eb_thd.keys():
+            return self.eb_thd.get(dtype)
+        return None
+    
+
+class SingleBenchmarkAccuracyResult:
+    def __init__(
+        self,
+        result=True,
+        error_balance=None,
+        max_abs_diff=None,
+        max_abs_idx=None,
+        max_rel_diff=None,
+        max_rel_idx=None
+    ):
+        self.result = result
+        self.error_balance = error_balance
+        self.max_abs_diff = max_abs_diff
+        self.max_abs_idx = max_abs_idx
+        self.max_rel_diff = max_rel_diff
+        self.max_rel_idx = max_rel_idx
+
+    def get_result(self, eb_thd, error_thd):
+        if (
+            self.error_balance > eb_thd
+            or self.max_abs_diff > error_thd
+            or self.max_rel_diff > error_thd
+        ):
+            self.result = False
+        else:
+            self.result = True
+
+
+class SingleBenchmarkAccuracyCompare:
+    @classmethod
+    @func_log_wrapper()
+    def check_output_size(cls, npu_out, bench_out):
+        acc_result = None
+        if npu_out.numel() == 0 and bench_out.nuimel() == 0:
+            info = (
+                "The npu_output is [], and it is same as benchmark_output, "
+                "the result of data_compare is Pass"
+            )
+            logging.debug(info)
+            acc_result = SingleBenchmarkAccuracyResult(result=True)
+
+        if npu_out.size() != bench_out.size():
+            error_info = (
+                f"the size of npu output[{npu_out.size()}] and"
+                f"benchmark[{bench_out.size()}] is not equal"
+            )
+
+            logging.error(error_info)
+            acc_result = SingleBenchmarkAccuracyResult(result=False)
+        return acc_result
+    
+    @classmethod
+    @func_log_wrapper()
+    def check_output_invalid_value(cls, output):
+        has_nan = torch.isnan(output).any()
+        has_inf = torch.isinf(output).any()
+        return has_nan or has_inf
+    
+    @classmethod
+    @func_log_wrapper()
+    def precision_compare_for_case(cls, npu_out, bench_out, benchmark_standard: SingleBenchmarkCompareStandard):
+        error_thd = None
+        eb_thd = None
+        acc_result = cls.check_output_size(npu_out, bench_out)
+        CompareResultInfo = namedtuple("CompareResultInfo",
+                                       ['accuracy_result', 'error_threshold', 'eb_threshold', 'failed_information'])
+
+        if acc_result:
+            failed_info = "比对数据的shape不一致"
+            return CompareResultInfo(acc_result, error_thd, eb_thd, failed_info)
+        
+        if cls.check_output_invalid_value(bench_out):
+            logging.info("The benchmark result contains nan/inf value. ")
+            failed_info = "标杆结果存在nan值或inf值, 依照单标杆标准该用例通过"
+            acc_result = SingleBenchmarkAccuracyResult(result=True)
+            return CompareResultInfo(acc_result, error_thd, eb_thd, failed_info)
+        
+        if cls.check_output_invalid_value(npu_out):
+            logging.info("The NPU result contains nan/inf value. ")
+            failed_info = "NPU结果存在nan值或inf值, 依照单标杆标准该用例不通过"
+            acc_result = SingleBenchmarkAccuracyResult(result=False)
+            return CompareResultInfo(acc_result, error_thd, eb_thd, failed_info)
+        
+        data_type = npu_out.dtype
+        if data_type not in [torch.float16, torch.float32, torch.float64, torch.bfloat16]:
+            acc_result = cls.compute_binary_diff(npu_out, bench_out)
+        else:
+            error_thd = benchmark_standard.get_error_thd(data_type)
+            eb_thd = benchmark_standard.get_eb_thd(data_type)
+            if error_thd is None:
+                logging.error(
+                    "single benchmark not support the comparison of %s", str(data_type)
+                )
+                acc_result = SingleBenchmarkAccuracyResult(result=False)
+            else:
+                if npu_out.dtype in [torch.float16, torch.bfloat16] and bench_out.dtype in [torch.float32]:
+                    npu_out = npu_out.to(torch.float32)
+                error_balance = cls.compute_error_balance(npu_out, bench_out, benchmark_standard)
+                max_abs_diff, max_abs_idx = cls.compute_abs_diff(npu_out, bench_out, error_thd, benchmark_standard)
+                max_rel_diff, max_rel_idx = cls.compute_rel_diff(npu_out, bench_out, error_thd, benchmark_standard)
+                acc_result = SingleBenchmarkAccuracyResult(
+                    error_balance=error_balance,
+                    max_abs_diff=max_abs_diff,
+                    max_abs_idx=max_abs_idx,
+                    max_rel_diff=max_rel_diff,
+                    max_rel_idx=max_rel_idx
+                )
+                acc_result.get_result(eb_thd, error_thd)
+            return CompareResultInfo(acc_result, error_thd, eb_thd, None)
+        return None
+
+    @classmethod
+    @func_log_wrapper()
+    def compute_binary_diff(cls, npu_out, bench_out):
+        result = torch.equal(npu_out, bench_out)
+        if result:
+            logger_user("二进制精度比对通过, 无需单标杆比对法验证")
+        return SingleBenchmarkAccuracyResult(result=result, max_abs_diff=0, max_rel_diff=0, error_balance=0)
+    
+    @classmethod
+    @func_log_wrapper()
+    def compute_error_balance(cls, npu_out, bench_out, benchmark_standard: SingleBenchmarkCompareStandard):
+        ones = torch.ones_like(npu_out)
+        zeros = torch.zeros_like(npu_out)
+        abs_mask_idx = torch.where(torch.abs(bench_out) < benchmark_standard.small_value, ones, zeros)
+        abs_mask_idx = abs_mask_idx.type(torch.bool)
+        diff_value = torch.subtract(npu_out, bench_out)
+        diff_value_rel = diff_value / (torch.abs(bench_out) + torch.finfo(torch.float).eps )
+        rel_and_abs = torch.where(abs_mask_idx, diff_value, diff_value_rel)
+        eb_float = float(torch.mean(rel_and_abs))
+        return eb_float
+    
+    @classmethod
+    @func_log_wrapper()
+    def compute_abs_diff(cls, npu_out, bench_out, error_thd, benchmark_standard: SingleBenchmarkCompareStandard):
+        max_abs_diff = 0
+        max_abs_idx = None
+
+        ones = torch.ones_like(npu_out)
+        zeros = torch.zeros_like(npu_out)
+        diff_value = torch.subtract(npu_out, bench_out)
+        diff_abs = torch.abs(diff_value)
+        abs_mask_idx = torch.where(torch.abs(bench_out) < benchmark_standard.small_value, ones, zeros)
+        abs_err_idx = torch.where(diff_abs > error_thd, ones, zeros)
+        abs_err_idx = abs_err_idx * abs_mask_idx
+        abs_err = diff_abs[torch.where(abs_err_idx == 1)]
+
+        if len(abs_err) > 0:
+            err_for_max = torch.where(abs_err_idx == 1, diff_abs, zeros)
+            logging.debug("err_for_max for abs %s", err_for_max)
+            max_abs_idx = torch.argmax(err_for_max)
+            max_abs_diff = diff_abs[max_abs_idx]
+        elif torch.sum(abs_mask_idx) > 0:
+            err_for_max = torch.where(abs_mask_idx == 1, diff_abs, zeros)
+            logging.debug("error_for_max for abs %s", err_for_max)
+            max_abs_idx = torch.argmax(err_for_max)
+            if err_for_max.max() != 0:
+                max_abs_diff = diff_abs[max_abs_idx]
+        return (float(max_abs_diff), int(max_abs_idx) if torch.is_tensor(max_abs_idx) else max_abs_idx)
+    
+    @classmethod
+    @func_log_wrapper()
+    def compute_rel_diff(cls, npu_out, bench_out, error_thd, benchmark_standard: SingleBenchmarkCompareStandard):
+        max_rel_diff = 0
+        max_rel_idx = None
+
+        ones = torch.ones_like(npu_out)
+        zeros = torch.zeros_like(npu_out)
+        diff_value = torch.subtract(npu_out, bench_out)
+        diff_abs = torch.abs(diff_value)
+
+        rel_mask_idx = torch.where(torch.abs(bench_out) >= benchmark_standard.small_value, ones, zeros)
+        rel_err = diff_abs / (torch.abs(bench_out) + torch.finfo(torch.float).eps )
+        diff_rel = rel_err
+        rel_err_idx = torch.where(rel_err > error_thd, ones, zeros)
+        rel_err_idx = rel_err_idx * rel_mask_idx
+        rel_err = rel_err[torch.where(rel_err_idx == 1)]
+        if len(rel_err) > 0:
+            err_for_max = torch.where(rel_err_idx == 1, diff_rel, zeros)
+            logging.debug("error_for_max for rel %s", err_for_max)
+            max_rel_idx = torch.argmax(err_for_max)
+            max_rel_diff = diff_rel[max_rel_idx]
+        elif torch.sum(rel_mask_idx > 0):
+            err_for_max = torch.where(rel_mask_idx == 1, diff_rel, zeros)
+            logging.debug("err_for_max for rel %s", err_for_max)
+            max_rel_idx = torch.argmax(err_for_max)
+            if torch.sum(err_for_max) != 0:
+                max_rel_diff = diff_rel[max_rel_idx]
+        return (float(max_rel_diff), int(max_rel_idx) if torch.is_tensor(max_rel_idx) else max_rel_idx)
+
+
+class SingleBenchSummary:
+    def __init__(self, precision_result: SingleBenchmarkAccuracyResult, npu_dtype=None,
+                bench_dtype=None, shape=None, error_thd=None, eb_thd=None, failed_info=None):
+        self.npu_dtype = npu_dtype
+        self.bench_dtype = bench_dtype
+        self.shape = shape
+        self.result = precision_result.result
+        self.error_balance = precision_result.error_balance
+        self.max_abs_diff = precision_result.max_abs_diff
+        self.max_abs_idx = precision_result.max_abs_idx
+        self.max_rel_diff = precision_result.max_rel_diff
+        self.max_rel_idx = precision_result.max_rel_idx
+        self.eb_thd = eb_thd
+        self.error_thd = error_thd
+        self.failed_info = failed_info
+
+    def get_check_result(self):
+        if self.result:
+            return "PASS"
+        else:
+            return "FAILED"
+        
+    def get_result_msg(self):
+        result_str = ""
+        if self.failed_info:
+            return self.failed_info
+        
+        if self.result:
+            result_str += "误差均衡性EB: %s <= 阈值%s\n" % (self.error_balance, self.eb_thd)
+            result_str += "最大绝对误差: %s <= 阈值%s\n" % (self.max_abs_diff, self.error_thd)
+            result_str += "最大相对误差: %s <= 阈值%s\n" % (self.max_rel_diff, self.error_thd)
+        else:
+            if self.error_balance > self.eb_thd:
+                result_str += "误差均衡性EB超过阈值%s: EB = %s\n" % (
+                    self.eb_thd,
+                    self.error_balance,
+                )
+            if self.max_abs_diff > self.error_thd:
+                result_str += "小值域最大绝对误差超过阈值%s: idx = %s, 绝对误差 = %s\n" % (
+                    self.error_thd,
+                    self.max_abs_idx,
+                    self.max_abs_diff
+                )
+            if self.max_rel_diff > self.error_thd:
+                result_str += "大值域最大相对误差超过阈值%s: idx = %s, 相对误差 = %s\n" % (
+                    self.error_thd,
+                    self.max_rel_idx,
+                    self.max_rel_diff,
+                )
+        return result_str
+    
+    def print_detail_table(self):
+        table = PrettyTable()
+        table.title = "Single Benchmark Metrics Info"
+        table.field_names = ["Index", "Result", "Threshold"]
+        table.add_row(["error_balance", self.error_balance, self.eb_thd])
+        table.add_row(["max_abs_diff", self.max_abs_diff, self.error_thd])
+        table.add_row(["max_abs_idx", self.max_abs_idx, "-"])
+        table.add_row(["max_rel_diff", self.max_rel_diff, self.error_thd])
+        table.add_row(["max_rel_idx", self.max_rel_idx, "-"])
+
+        logger_user(table)
+
+    def to_column_value(self):
+        return [self.bench_dtype, self.npu_dtype, self.shape, self.error_balance,
+                self.max_abs_diff, self.max_abs_idx, self.max_rel_diff, self.max_rel_idx,
+                self.eb_thd, self.error_thd, self.result, self.failed_info]
+    
+
+def single_benchmark_compare(npu_out: torch.Tensor, bench_out: torch.Tensor, high_precision: bool = True):
+    benchmark_standard = SingleBenchmarkCompareStandard(high_precision)
+    npu_out = npu_out.flatten()
+    bench_out = bench_out.flatten()
+
+    compare_results = SingleBenchmarkAccuracyCompare.precision_compare_for_case(npu_out, bench_out, benchmark_standard)
+    (
+        precision_result,
+        error_thd,
+        eb_thd,
+        failed_info
+    ) = (compare_results.accuracy_result, compare_results.error_threshold,
+         compare_results.eb_threshold, compare_results.failed_information)
+    
+    summary = SingleBenchSummary(precision_result, str(npu_out.dtype), str(bench_out.dtype), tuple(npu_out.shape), error_thd, eb_thd, failed_info)
+    result = summary.result
+    details = summary.to_column_value()
+    return result, details
+
+
+def calc_status_details_list_tuple(npu_out, bench_out, high_precision, summary):
+    status, details = [], []
+    if len(bench_out) != len(npu_out):
+        summary.result = False
+        summary.failed_info = "bench and npu output structure is different."
+        return False, summary.to_column_value()
+    for b_out_i, n_out_i in zip(bench_out, npu_out):
+        status_i, details_i = single_benchmark_compare_wrap(n_out_i, b_out_i, high_precision)
+        status.append(status_i)
+        details.append(details_i)
+    return status, details
+
+
+def calc_status_details_dict(npu_out, bench_out, high_precision, summary):
+    b_keys, n_keys = set(bench_out.keys()), set(npu_out.keys())
+    if b_keys != n_keys:
+        summary.result = False
+        summary.failed_info = "bench and npu_output dict keys are different."
+        return False, summary.to_column_value()
+    else:
+        status, details = single_benchmark_compare_wrap(list(bench_out.values(), list(npu_out.values())))
+        return status, details
+
+
+def calc_status_details_tensor(npu_out, bench_out, high_precision, summary):
+    return single_benchmark_compare(bench_out, npu_out)
+
+
+def calc_status_details_builtin(npu_out, bench_out, summary):
+    summary.bench_dtype = str(type(bench_out))
+    summary.npu_dtype = str(type(npu_out))
+    status = bench_out == npu_out
+    summary.result = status
+    return status, summary.to_column_value()
+
+
+def calc_status_details_none(npu_out, bench_out, high_precision, summary):
+    summary.result = True
+    summary.failed_info = "Output is None."
+    return True, summary.to_column_value()
+
+
+def single_benchmark_compare_wrap(npu_output: torch.Tensor, bench_output: torch.Tensor, high_precision=True):
+    type_method_dict = {
+        (list, tuple): calc_status_details_list_tuple,
+        dict: calc_status_details_dict,
+        torch.Tensor: calc_status_details_tensor,
+        (bool, int, float, str): calc_status_details_builtin,
+        None: calc_status_details_none,
+    }
+
+    result = SingleBenchmarkAccuracyResult(result=True)
+    bench_summary = SingleBenchSummary(result)
+    for type1, func in type_method_dict.items():
+        if isinstance(bench_output, type1):
+            return func(npu_output, bench_output, high_precision, bench_summary)
+
+    bench_summary.result = True
+    bench_summary.failed_info = "Unexpected output type: {}".format(type(bench_output))
+    return True, bench_summary.to_column_value()

msprobe/pytorch/online_dispatch/torch_ops_config.yaml

@@ -0,0 +1,50 @@
+aten_ops_blacklist:
+  - _cudnn_rnn
+  - _local_scalar_dense
+  - _pin_memory
+  - _to_copy
+  - _unsafe_view
+  - clone
+  - contiguous
+  - copy_
+  - cudnn_batch_norm
+  - cudnn_batch_norm_backward
+  - detach
+  - empty
+  - index_put_
+  - lift_fresh
+  - max_pool2d_with_indices_backward # shape unmatch
+  - native_batch_norm_backward
+  - new_empty
+  - new_empty_strided
+  - new_full
+  - new_ones
+  - new_zeros
+  - ones
+  - ones_like
+  - permute
+  - rand
+  - rand_like
+  - randint
+  - randint_like
+  - randn
+  - randn_like
+  - randperm
+  - scalar_tensor
+  - select
+  - to
+  - transpose
+  - unbind
+  - view
+  - zero
+  - zero_
+  - zeros
+  - zeros_like
+
+npu_adjust_autogard:
+  - adaptive_avg_pool2d
+  - batch_norm
+  - log_softmax
+  - nll_loss
+  - to
+