diff --git a/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/common/utils.py b/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/common/utils.py index b0e4fef8c5069e7a20071e26f61decd1c87498ed..a78eb595f6eeed6ebbf8e2194e31bb6a0be3f375 100644 --- a/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/common/utils.py +++ b/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/common/utils.py @@ -125,9 +125,11 @@ class CompareConst: NPU_MAX = "NPU max" NPU_MIN = "NPU min" NPU_MEAN = "NPU mean" + NPU_NORM = "NPU l2norm" BENCH_MAX = "Bench max" BENCH_MIN = "Bench min" BENCH_MEAN = "Bench mean" + BENCH_NORM = "Bench l2norm" MAX_DIFF = "Max diff" MIN_DIFF = "Min diff" MEAN_DIFF = "Mean diff" @@ -137,15 +139,19 @@ class CompareConst: ACCURACY = "Accuracy Reached or Not" STACK = "NPU_Stack_Info" ERROR_MESSAGE = "Err_message" + ONE_THOUSANDTH_ERR_RATIO = "One Thousandth Err Ratio" + FIVE_THOUSANDTHS_ERR_RATIO = "Five Thousandths Err Ratio" COMPARE_RESULT_HEADER = [ NPU_NAME, BENCH_NAME, NPU_DTYPE, BENCH_DTYPE, NPU_SHAPE, BENCH_SHAPE, COSINE, MAX_ABS_ERR, MAX_RELATIVE_ERR, - NPU_MAX, NPU_MIN, NPU_MEAN, BENCH_MAX, BENCH_MIN, BENCH_MEAN, ACCURACY, ERROR_MESSAGE + ONE_THOUSANDTH_ERR_RATIO, FIVE_THOUSANDTHS_ERR_RATIO, + NPU_MAX, NPU_MIN, NPU_MEAN, NPU_NORM, BENCH_MAX, BENCH_MIN, BENCH_MEAN, BENCH_NORM, ACCURACY, ERROR_MESSAGE ] SUMMARY_COMPARE_RESULT_HEADER = [ NPU_NAME, BENCH_NAME, NPU_DTYPE, BENCH_DTYPE, NPU_SHAPE, BENCH_SHAPE, MAX_DIFF, MIN_DIFF, MEAN_DIFF, - NPU_MAX, NPU_MIN, NPU_MEAN, BENCH_MAX, BENCH_MIN, BENCH_MEAN, ACCURACY, ERROR_MESSAGE + ONE_THOUSANDTH_ERR_RATIO, FIVE_THOUSANDTHS_ERR_RATIO, + NPU_MAX, NPU_MIN, NPU_MEAN, NPU_NORM, BENCH_MAX, BENCH_MIN, BENCH_MEAN, BENCH_NORM, ACCURACY, ERROR_MESSAGE ] # compare result data diff --git a/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/compare/acc_compare.py b/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/compare/acc_compare.py index 1fe7861cbaaaaf307f192e462bed1a0c2580c247..bd5cd015732848ccca512db727661415d03c19bf 100644 --- a/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/compare/acc_compare.py +++ b/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/compare/acc_compare.py @@ -104,7 +104,7 @@ def get_max_abs_err(n_value, b_value): return format_value(max_value), "" -def get_max_relative_err(n_value, b_value): +def get_relative_err(n_value, b_value): np.seterr(divide='ignore', invalid='ignore') if b_value.dtype in CompareConst.FLOAT_TYPE: zero_mask = (b_value == 0) @@ -116,6 +116,14 @@ def get_max_relative_err(n_value, b_value): b_value[zero_mask] += np.finfo(float).eps n_value[zero_mask] += np.finfo(float).eps relative_err = np.divide((n_value - b_value), b_value) + return np.abs(relative_err) + + +def get_max_relative_err(n_value, b_value, input_relative_err=None): + if input_relative_err is None: + relative_err = get_relative_err(n_value, b_value) + else: + relative_err = input_relative_err max_relative_err = np.max(np.abs(relative_err)) if np.isnan(max_relative_err): message = 'Cannot compare by MaxRelativeError, the data contains nan in dump data.' @@ -123,6 +131,10 @@ def get_max_relative_err(n_value, b_value): return format_value(max_relative_err), "" +def rel_err_ratio(relative_err, threshold): + return format_value(np.sum(relative_err < threshold) / np.size(relative_err)) + + def check_graph_mode(a_op_name, b_op_name): if "Aten" in a_op_name and "Aten" not in b_op_name: return True @@ -292,7 +304,7 @@ def get_accuracy(result, n_dict, b_dict, summary_compare=False): n_struct = n_dict[key][index] b_struct = b_dict[key][index] err_msg = "" - result_item = [n_name, b_name, n_struct[0], b_struct[0], n_struct[1], b_struct[1], " ", " ", " "] + result_item = [n_name, b_name, n_struct[0], b_struct[0], n_struct[1], b_struct[1], " ", " ", " ", " ", " "] npu_summery_data = n_dict.get("summery")[n_start + index] result_item.extend(npu_summery_data) @@ -316,7 +328,7 @@ def get_accuracy(result, n_dict, b_dict, summary_compare=False): n_name = n_dict['op_name'][n_start + index] n_struct = n_dict[key][index] result_item = [n_name, CompareConst.NAN, n_struct[0], CompareConst.NAN, - n_struct[1], CompareConst.NAN, " ", " ", " "] + n_struct[1], CompareConst.NAN, " ", " ", " ", " ", " "] summery_data = n_dict.get("summery")[n_start + index] result_item.extend(summery_data) summery_data = [CompareConst.NAN for _ in range(len(n_dict.get("summery")[0]))] @@ -407,21 +419,25 @@ def compare_ops(idx, fusion_op_names, dump_path_dict, result_path, lock, input_p max_err_result = [] max_relative_err_result = [] err_mess = [] + one_thousand_err_ratio_result = [] + five_thousand_err_ratio_result = [] is_print_compare_log = input_parma.get("is_print_compare_log") for i, op_name in enumerate(fusion_op_names): if is_print_compare_log: print("start compare: {}".format(op_name)) - cos_sim, max_abs_err, max_relative_err, err_msg = compare_by_op(op_name, dump_path_dict, input_parma) + cos_sim, max_abs_err, max_relative_err, err_msg, one_thousand_err_ratio, five_thousand_err_ratio = compare_by_op(op_name, dump_path_dict, input_parma) if is_print_compare_log: - print("[{}] Compare result: cosine {}, max_abs_err {}, max_relative_err {}, {}".format(op_name, cos_sim, max_abs_err, max_relative_err, err_msg)) + print("[{}] Compare result: cosine {}, max_abs_err {}, max_relative_err {}, {}, one_thousand_err_ratio {}, five_thousand_err_ratio {}".format(op_name, cos_sim, max_abs_err, max_relative_err, err_msg, one_thousand_err_ratio, five_thousand_err_ratio)) cos_result.append(cos_sim) max_err_result.append(max_abs_err) max_relative_err_result.append(max_relative_err) err_mess.append(err_msg) - _save_cmp_result(idx, cos_result, max_err_result, max_relative_err_result, err_mess, result_path, lock) + one_thousand_err_ratio_result.append(one_thousand_err_ratio) + five_thousand_err_ratio_result.append(five_thousand_err_ratio) + _save_cmp_result(idx, cos_result, max_err_result, max_relative_err_result, err_mess, one_thousand_err_ratio_result, five_thousand_err_ratio_result, result_path, lock) -def _save_cmp_result(idx, cos_result, max_err_result, max_relative_err_result, err_msg, result_path, lock): +def _save_cmp_result(idx, cos_result, max_err_result, max_relative_err_result, err_msg, one_thousand_err_ratio_result, five_thousand_err_ratio_result, result_path, lock): lock.acquire() try: csv_pd = pd.read_csv(result_path, dtype=str) @@ -434,6 +450,8 @@ def _save_cmp_result(idx, cos_result, max_err_result, max_relative_err_result, e csv_pd.loc[process_index, CompareConst.MAX_RELATIVE_ERR] = max_relative_err_result[i] csv_pd.loc[process_index, CompareConst.ERROR_MESSAGE] = err_msg[i] csv_pd.loc[process_index, CompareConst.ACCURACY] = check_accuracy(cos_result[i], max_err_result[i]) + csv_pd.loc[process_index, CompareConst.ONE_THOUSANDTH_ERR_RATIO] = one_thousand_err_ratio_result[i] + csv_pd.loc[process_index, CompareConst.FIVE_THOUSANDTHS_ERR_RATIO] = five_thousand_err_ratio_result[i] csv_pd.to_csv(result_path, index=False) except FileNotFoundError as e: print_error_log('{} file is not found.'.format(result_path)) @@ -467,7 +485,7 @@ def check_accuracy(cos, max_abs_err): def compare_by_op(op_name, op_name_mapping_dict, input_parma): npu_bench_name_list = op_name_mapping_dict[op_name] if npu_bench_name_list[1] == CompareConst.NAN: - return CompareConst.NAN, CompareConst.NAN, CompareConst.NAN, CompareConst.NO_BENCH + return CompareConst.NAN, CompareConst.NAN, CompareConst.NAN, CompareConst.NO_BENCH, CompareConst.NAN, CompareConst.NAN try: n_path = os.path.join(input_parma.get("npu_dump_data_dir"), npu_bench_name_list[0] + ".npy") b_path = os.path.join(input_parma.get("bench_dump_data_dir"), npu_bench_name_list[1] + ".npy") @@ -480,18 +498,19 @@ def compare_by_op(op_name, op_name_mapping_dict, input_parma): n_value = np.load(n_path) b_value = np.load(b_path) except IOError as error: - return CompareConst.NAN, CompareConst.NAN, CompareConst.NAN, "Dump file: {} not found.".format(error.filename) + return CompareConst.NAN, CompareConst.NAN, CompareConst.NAN, "Dump file: {} not found.".format(error.filename), CompareConst.NAN, CompareConst.NAN + relative_err = get_relative_err(n_value, b_value) if len(n_value.shape) == 0: if n_value.dtype == bool: n_value = n_value.astype(float) b_value = b_value.astype(float) max_abs_err, _ = get_max_abs_err(n_value, b_value) - max_relative_err, _ = get_max_relative_err(n_value, b_value) - return "unsupported", max_abs_err, max_relative_err, "This is type of scalar data, can not compare." + max_relative_err, _ = get_max_relative_err(n_value, b_value, input_relative_err=relative_err) + return "unsupported", max_abs_err, max_relative_err, "This is type of scalar data, can not compare.", CompareConst.NAN, CompareConst.NAN if n_value.size == 0: - return "unsupported", 0, 0, "This is empty data, can not compare." + return "unsupported", 0, 0, "This is empty data, can not compare.", 0, 0 if n_value.shape != b_value.shape: - return CompareConst.SHAPE_UNMATCH, CompareConst.SHAPE_UNMATCH, CompareConst.SHAPE_UNMATCH, "Shape of NPU and bench Tensor do not match. Skipped." + return CompareConst.SHAPE_UNMATCH, CompareConst.SHAPE_UNMATCH, CompareConst.SHAPE_UNMATCH, "Shape of NPU and bench Tensor do not match. Skipped.", CompareConst.SHAPE_UNMATCH, CompareConst.SHAPE_UNMATCH if n_value.dtype != b_value.dtype: print_warn_log("Dtype of NPU and bench Tensor do not match: {}".format(op_name)) err_msg = " Dtype of NPU and bench Tensor do not match." @@ -500,15 +519,18 @@ def compare_by_op(op_name, op_name_mapping_dict, input_parma): n_value, b_value = handle_inf_nan(n_value, b_value) if n_value is CompareConst.NAN or b_value is CompareConst.NAN: - return "N/A", "N/A", "N/A", "The position of inf or nan in NPU and bench Tensor do not match." + return "N/A", "N/A", "N/A", "The position of inf or nan in NPU and bench Tensor do not match.", "N/A", "N/A" n_value = n_value.reshape(-1).astype(float) b_value = b_value.reshape(-1).astype(float) err_msg = "" cos_sim, message = cosine_similarity(n_value, b_value) - max_abs_err, _ = get_max_abs_err(n_value, b_value) - max_relative_err, message = get_max_relative_err(n_value, b_value) + abs_err = np.abs(n_value - b_value) + max_abs_err = format_value(np.max(abs_err)) + max_relative_err, message = get_max_relative_err(n_value, b_value, input_relative_err=relative_err) + one_thousand_err_ratio = rel_err_ratio(relative_err, 0.001) + five_thousand_err_ratio = rel_err_ratio(relative_err, 0.005) if not err_msg: err_msg += message @@ -517,7 +539,7 @@ def compare_by_op(op_name, op_name_mapping_dict, input_parma): if npu_bench_name_list[0] != npu_bench_name_list[1]: err_msg += " Fuzzy matching data, the comparison accuracy may be affected." - return cos_sim, max_abs_err, max_relative_err, err_msg + return cos_sim, max_abs_err, max_relative_err, err_msg, one_thousand_err_ratio, five_thousand_err_ratio def handle_inf_nan(n_value, b_value): @@ -658,7 +680,7 @@ def get_un_match_accuracy(result, n_dict): accuracy_check_res = CompareConst.NAN result_item = [n_name, bench_name, n_struct[0], bench_type, n_struct[1], bench_shape] - result_item.extend([CompareConst.NAN] * 3) + result_item.extend([CompareConst.NAN] * 5) summery_data = n_dict.get("summery")[index] result_item.extend(summery_data) summery_data = [CompareConst.NAN] * 3 diff --git a/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/dump/dump.py b/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/dump/dump.py index 8583c9641fcca9f796e8628213ff98e30504f93c..17fe015ac7341034dcd2915baf98021e0a9ca23b 100644 --- a/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/dump/dump.py +++ b/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/dump/dump.py @@ -33,7 +33,7 @@ else: is_gpu = False from .utils import DumpUtil, check_if_in_api_list, make_dump_data_dir, get_tensor_rank, create_dirs_if_not_exist -from ..common.utils import print_warn_log, Const, print_info_log, modify_dump_path, check_inplace_op +from ..common.utils import print_warn_log, Const, print_info_log, modify_dump_path, check_inplace_op, CompareConst from ..dump.utils import check_writable from ..common.file_check_util import FileOpen, change_mode, FileCheckConst, check_path_pattern_vaild, check_path_length @@ -71,11 +71,11 @@ def get_not_float_tensor_info(data): tensor_max = torch._C._VariableFunctionsClass.max(data).cpu().detach().float().numpy().tolist() tensor_min = torch._C._VariableFunctionsClass.min(data).cpu().detach().float().numpy().tolist() tensor_mean = torch._C._VariableFunctionsClass.mean(data.float()).cpu().detach().float().numpy().tolist() - return get_tensor_data_info(data, tensor_max, tensor_min, tensor_mean) + return get_tensor_data_info(data, tensor_max, tensor_min, tensor_mean, CompareConst.NAN) def get_scalar_data_info(data): - summary_data = [data, data, data] + summary_data = [data, data, data, data] return DataInfo(data, summary_data, str(type(data)), str([])) @@ -83,12 +83,13 @@ def get_float_tensor_info(data): tensor_max = torch._C._VariableFunctionsClass.max(data).cpu().detach().float().numpy().tolist() tensor_min = torch._C._VariableFunctionsClass.min(data).cpu().detach().float().numpy().tolist() tensor_mean = torch._C._VariableFunctionsClass.mean(data).cpu().detach().float().numpy().tolist() - return get_tensor_data_info(data, tensor_max, tensor_min, tensor_mean) + tensor_norm = torch._C._VariableFunctionsClass.norm(data).cpu().detach().float().numpy().tolist() + return get_tensor_data_info(data, tensor_max, tensor_min, tensor_mean, tensor_norm) -def get_tensor_data_info(data, tensor_max, tensor_min, tensor_mean): +def get_tensor_data_info(data, *tensor_args): summary_data = [] - summary_data.extend([tensor_max, tensor_min, tensor_mean]) + summary_data.extend([*tensor_args]) if not DumpUtil.summary_only: saved_tensor = data.contiguous().cpu().detach() if data.dtype == torch.bfloat16: diff --git a/debug/accuracy_tools/ptdbg_ascend/test/ut/compare/test_acc_compare.py b/debug/accuracy_tools/ptdbg_ascend/test/ut/compare/test_acc_compare.py index 05f72181a47e16963161f71c4d7fe9fed339a8e7..1d6ebbde0f361b4f0a7890f72cc5c0309702e18c 100644 --- a/debug/accuracy_tools/ptdbg_ascend/test/ut/compare/test_acc_compare.py +++ b/debug/accuracy_tools/ptdbg_ascend/test/ut/compare/test_acc_compare.py @@ -23,7 +23,7 @@ result_op_dict = {'op_name': ['Functional_conv2d_0_forward_input.0', 'Functional 'output_struct': [('torch.float32', [1, 16, 28, 28])], 'summery': [[3.029174327850342, -2.926689624786377, -0.06619918346405029], [0.19919930398464203, -0.19974489510059357, 0.006269412115216255], \ [0.19734230637550354, -0.18177609145641327, 0.007903944700956345], [2.1166646480560303, -2.190781354904175, -0.003579073818400502]], 'stack_info': []} -o_result = [['Functional_conv2d_0_forward_input.0', 'Functional_conv2d_0_forward_input.0', 'torch.float32', 'torch.float32', [1, 1, 28, 28], [1, 1, 28, 28], ' ', ' ', ' ', 3.029174327850342, -2.926689624786377, -0.06619918346405029, 3.029174327850342, -2.926689624786377, -0.06619918346405029, 'Yes', ''], ['Functional_conv2d_0_forward_input.1', 'Functional_conv2d_0_forward_input.1', 'torch.float32', 'torch.float32', [16, 1, 5, 5], [16, 1, 5, 5], ' ', ' ', ' ', 0.19919930398464203, -0.19974489510059357, 0.006269412115216255, 0.19919930398464203, -0.19974489510059357, 0.006269412115216255, 'Yes', ''], ['Functional_conv2d_0_forward_input.2', 'Functional_conv2d_0_forward_input.2', 'torch.float32', 'torch.float32', [16], [16], ' ', ' ', ' ', 0.19734230637550354, -0.18177609145641327, 0.007903944700956345, 0.19734230637550354, -0.18177609145641327, 0.007903944700956345, 'Yes', ''], ['Functional_conv2d_0_forward_output', 'Functional_conv2d_0_forward_output', 'torch.float32', 'torch.float32', [1, 16, 28, 28], [1, 16, 28, 28], ' ', ' ', ' ', 2.1166646480560303, -2.190781354904175, -0.003579073818400502, 2.1166646480560303, -2.190781354904175, -0.003579073818400502, 'Yes', '']] +o_result = [['Functional_conv2d_0_forward_input.0', 'Functional_conv2d_0_forward_input.0', 'torch.float32', 'torch.float32', [1, 1, 28, 28], [1, 1, 28, 28], ' ', ' ', ' ', ' ', ' ', 3.029174327850342, -2.926689624786377, -0.06619918346405029, 3.029174327850342, -2.926689624786377, -0.06619918346405029, 'Yes', ''], ['Functional_conv2d_0_forward_input.1', 'Functional_conv2d_0_forward_input.1', 'torch.float32', 'torch.float32', [16, 1, 5, 5], [16, 1, 5, 5], ' ', ' ', ' ', ' ', ' ', 0.19919930398464203, -0.19974489510059357, 0.006269412115216255, 0.19919930398464203, -0.19974489510059357, 0.006269412115216255, 'Yes', ''], ['Functional_conv2d_0_forward_input.2', 'Functional_conv2d_0_forward_input.2', 'torch.float32', 'torch.float32', [16], [16], ' ', ' ', ' ', ' ', ' ', 0.19734230637550354, -0.18177609145641327, 0.007903944700956345, 0.19734230637550354, -0.18177609145641327, 0.007903944700956345, 'Yes', ''], ['Functional_conv2d_0_forward_output', 'Functional_conv2d_0_forward_output', 'torch.float32', 'torch.float32', [1, 16, 28, 28], [1, 16, 28, 28], ' ', ' ', ' ', ' ', ' ', 2.1166646480560303, -2.190781354904175, -0.003579073818400502, 2.1166646480560303, -2.190781354904175, -0.003579073818400502, 'Yes', '']] npu_dict_aten = {'op_name': ['Aten__native_batch_norm_legit_functional.default_0_forward_input.0', 'Aten__native_batch_norm_legit_functional.default_0_forward_input.1', @@ -61,16 +61,16 @@ bench_dict_functional = {'op_name': ['Functional_batch_norm_0_forward_input.0', [5.397906303405762, -5.796811580657959, 2.5283952709287405e-10]] } -aten_result = [['Aten__native_batch_norm_legit_functional.default_0_forward_input.0', 'Functional_batch_norm_0_forward_input.0', 'torch.float16', 'torch.float32', [256, 256, 14, 14], [256, 256, 14, 14], ' ', ' ', ' ', 139.625, -127.5625, -0.0103607177734375, 3.061628818511963, -3.22507381439209, 3.634914173744619e-05, 'Yes', ''], - ['Aten__native_batch_norm_legit_functional.default_0_forward_input.1', 'Functional_batch_norm_0_forward_input.1', 'torch.float32', 'torch.float32', [256], [256], ' ', ' ', ' ', 2.5276029109954834, -2.1788690090179443, -0.0008259844034910202, 0.0005779837374575436, -0.0006301702815108001, 3.634906533989124e-06, 'Yes', ''], - ['Aten__native_batch_norm_legit_functional.default_0_forward_input.2', 'Functional_batch_norm_0_forward_input.2', 'torch.float32', 'torch.float32', [256], [256], ' ', ' ', ' ', 2.472219944000244, -2.845968723297119, -0.008756577968597412, 0.9338104128837585, 0.9277191162109375, 0.930335283279419, 'Yes', ''], - ['Aten__native_batch_norm_legit_functional.default_0_forward_input.3', 'Functional_batch_norm_0_forward_input.3', 'torch.float32', 'torch.float32', [256], [256], ' ', ' ', ' ', 2.763145923614502, -3.398397922515869, -0.052132632583379745, 1.0, 1.0, 1.0, 'Yes', ''], - ['Aten__native_batch_norm_legit_functional.default_0_forward_input.4', 'Functional_batch_norm_0_forward_input.4', 'torch.float32', 'torch.float32', [256], [256], ' ', ' ', ' ', 2.673110008239746, -3.149275064468384, 0.01613386906683445, 0.0, 0.0, 0.0, 'Yes', ''], - ['Aten__native_batch_norm_legit_functional.default_0_forward_output.0', 'Functional_batch_norm_0_forward_output', 'torch.float16', 'torch.float32', [256, 256, 14, 14], [256, 256, 14, 14], ' ', ' ', ' ', 13.5546875, -10.640625, -0.008758544921875, 5.397906303405762, -5.796811580657959, 2.5283952709287405e-10, 'Yes', ''], - ['Aten__native_batch_norm_legit_functional.default_0_forward_output.1', 'Nan', 'torch.float32', 'Nan', [256], 'Nan', ' ', ' ', ' ', 0.30550330877304077, -0.24485322833061218, -0.010361209511756897, 'Nan', 'Nan', 'Nan', 'Yes', ''], - ['Aten__native_batch_norm_legit_functional.default_0_forward_output.2', 'Nan', 'torch.float32', 'Nan', [256], 'Nan', ' ', ' ', ' ', 623.9192504882812, 432.96826171875, 520.2276611328125, 'Nan', 'Nan', 'Nan', 'Yes', ''], - ['Aten__native_batch_norm_legit_functional.default_0_forward_output.3', 'Nan', 'torch.float32', 'Nan', [256], 'Nan', ' ', ' ', ' ', 2.4797861576080322, -3.055997371673584, -0.04795549064874649, 'Nan', 'Nan', 'Nan', 'Yes', ''], - ['Aten__native_batch_norm_legit_functional.default_0_forward_output.4', 'Nan', 'torch.float32', 'Nan', [256], 'Nan', ' ', ' ', ' ', 61.7945556640625, 42.59713363647461, 52.03831481933594, 'Nan', 'Nan', 'Nan', 'Yes', ''] +aten_result = [['Aten__native_batch_norm_legit_functional.default_0_forward_input.0', 'Functional_batch_norm_0_forward_input.0', 'torch.float16', 'torch.float32', [256, 256, 14, 14], [256, 256, 14, 14], ' ', ' ', ' ', ' ', ' ', 139.625, -127.5625, -0.0103607177734375, 3.061628818511963, -3.22507381439209, 3.634914173744619e-05, 'Yes', ''], + ['Aten__native_batch_norm_legit_functional.default_0_forward_input.1', 'Functional_batch_norm_0_forward_input.1', 'torch.float32', 'torch.float32', [256], [256], ' ', ' ', ' ', ' ', ' ', 2.5276029109954834, -2.1788690090179443, -0.0008259844034910202, 0.0005779837374575436, -0.0006301702815108001, 3.634906533989124e-06, 'Yes', ''], + ['Aten__native_batch_norm_legit_functional.default_0_forward_input.2', 'Functional_batch_norm_0_forward_input.2', 'torch.float32', 'torch.float32', [256], [256], ' ', ' ', ' ', ' ', ' ', 2.472219944000244, -2.845968723297119, -0.008756577968597412, 0.9338104128837585, 0.9277191162109375, 0.930335283279419, 'Yes', ''], + ['Aten__native_batch_norm_legit_functional.default_0_forward_input.3', 'Functional_batch_norm_0_forward_input.3', 'torch.float32', 'torch.float32', [256], [256], ' ', ' ', ' ', ' ', ' ', 2.763145923614502, -3.398397922515869, -0.052132632583379745, 1.0, 1.0, 1.0, 'Yes', ''], + ['Aten__native_batch_norm_legit_functional.default_0_forward_input.4', 'Functional_batch_norm_0_forward_input.4', 'torch.float32', 'torch.float32', [256], [256], ' ', ' ', ' ', ' ', ' ', 2.673110008239746, -3.149275064468384, 0.01613386906683445, 0.0, 0.0, 0.0, 'Yes', ''], + ['Aten__native_batch_norm_legit_functional.default_0_forward_output.0', 'Functional_batch_norm_0_forward_output', 'torch.float16', 'torch.float32', [256, 256, 14, 14], [256, 256, 14, 14], ' ', ' ', ' ', ' ', ' ', 13.5546875, -10.640625, -0.008758544921875, 5.397906303405762, -5.796811580657959, 2.5283952709287405e-10, 'Yes', ''], + ['Aten__native_batch_norm_legit_functional.default_0_forward_output.1', 'Nan', 'torch.float32', 'Nan', [256], 'Nan', ' ', ' ', ' ', ' ', ' ', 0.30550330877304077, -0.24485322833061218, -0.010361209511756897, 'Nan', 'Nan', 'Nan', 'Yes', ''], + ['Aten__native_batch_norm_legit_functional.default_0_forward_output.2', 'Nan', 'torch.float32', 'Nan', [256], 'Nan', ' ', ' ', ' ', ' ', ' ', 623.9192504882812, 432.96826171875, 520.2276611328125, 'Nan', 'Nan', 'Nan', 'Yes', ''], + ['Aten__native_batch_norm_legit_functional.default_0_forward_output.3', 'Nan', 'torch.float32', 'Nan', [256], 'Nan', ' ', ' ', ' ', ' ', ' ', 2.4797861576080322, -3.055997371673584, -0.04795549064874649, 'Nan', 'Nan', 'Nan', 'Yes', ''], + ['Aten__native_batch_norm_legit_functional.default_0_forward_output.4', 'Nan', 'torch.float32', 'Nan', [256], 'Nan', ' ', ' ', ' ', ' ', ' ', 61.7945556640625, 42.59713363647461, 52.03831481933594, 'Nan', 'Nan', 'Nan', 'Yes', ''] ] diff --git a/debug/accuracy_tools/ptdbg_ascend/test/ut/test_dump.py b/debug/accuracy_tools/ptdbg_ascend/test/ut/test_dump.py index 5b8cb1d9c087fb63ed1776d8599a2129313b2c68..92c52bdf286d788a3dad44ed651ee6a9a75203fc 100644 --- a/debug/accuracy_tools/ptdbg_ascend/test/ut/test_dump.py +++ b/debug/accuracy_tools/ptdbg_ascend/test/ut/test_dump.py @@ -15,21 +15,21 @@ class TestDump(unittest.TestCase): def test_get_not_float_tensor_info(self): data_info = get_not_float_tensor_info(self.tensor) self.assertEqual(data_info.save_data.tolist(), self.tensor.numpy().tolist()) - self.assertEqual(data_info.summary_data, [3.0, 1.0, 2.0]) + self.assertEqual(data_info.summary_data, [3.0, 1.0, 2.0, 'Nan']) self.assertEqual(data_info.dtype, 'torch.float32') self.assertEqual(data_info.shape, (3,)) def test_get_scalar_data_info(self): data_info = get_scalar_data_info(self.scalar) self.assertEqual(data_info.save_data, self.scalar) - self.assertEqual(data_info.summary_data, [self.scalar, self.scalar, self.scalar]) + self.assertEqual(data_info.summary_data, [self.scalar, self.scalar, self.scalar, self.scalar]) self.assertEqual(data_info.dtype, '') self.assertEqual(data_info.shape, '[]') def test_get_float_tensor_info(self): data_info = get_float_tensor_info(self.tensor) self.assertEqual(data_info.save_data.tolist(), self.tensor.numpy().tolist()) - self.assertEqual(data_info.summary_data, [3.0, 1.0, 2.0]) + self.assertEqual(data_info.summary_data, [3.0, 1.0, 2.0, 3.7416574954986572]) self.assertEqual(data_info.dtype, 'torch.float32') self.assertEqual(data_info.shape, (3,))