From a7cf760170f12b05f11c203c9945684eac104707 Mon Sep 17 00:00:00 2001 From: litian_drinksnow Date: Mon, 20 Nov 2023 11:21:54 +0800 Subject: [PATCH 1/7] add graph mode (aten ir) compare --- .../ptdbg_ascend/compare/acc_compare.py | 76 ++++++++++++++----- .../src/python/ptdbg_ascend/compare/match.py | 28 +++++++ .../test/ut/{ => compare}/test_acc_compare.py | 8 ++ .../test/ut/compare/test_match.py | 20 +++++ 4 files changed, 113 insertions(+), 19 deletions(-) create mode 100644 debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/compare/match.py rename debug/accuracy_tools/ptdbg_ascend/test/ut/{ => compare}/test_acc_compare.py (96%) create mode 100644 debug/accuracy_tools/ptdbg_ascend/test/ut/compare/test_match.py 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 7db518793c..fec71d29ab 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 @@ -24,6 +24,7 @@ import sys import numpy as np import pandas as pd +from .match import graph_mapping from ..advisor.advisor import Advisor from ..common.utils import check_compare_param, add_time_as_suffix, \ print_warn_log, print_error_log, CompareException, Const,\ @@ -122,9 +123,20 @@ def get_max_relative_err(n_value, b_value): return format_value(max_relative_err), "" +def check_graph_mode(a_op_name, b_op_name): + if "Aten" in a_op_name and not "Aten" in b_op_name: + return True + if not "Aten" in a_op_name and "Aten" in b_op_name: + return True + return False + + def check_op(npu_dict, bench_dict, fuzzy_match): a_op_name = npu_dict["op_name"] b_op_name = bench_dict["op_name"] + graph_mode = check_graph_mode(a_op_name, b_op_name) + if graph_mode: + return graph_mapping.match(a_op_name[0], b_op_name[0]) struct_match = check_struct_match(npu_dict, bench_dict) if not fuzzy_match: return a_op_name == b_op_name and struct_match @@ -268,37 +280,63 @@ def match_op(npu_queue, bench_queue, fuzzy_match): return -1, -1 -def get_accuracy(result, n_dict, b_dict): - index_out = 0 +def get_accuracy_core(result, n_dict, b_dict, n_start, n_len, b_start, b_len, key): + min_len = min(n_len, b_len) npu_stack_info = n_dict.get("stack_info", None) bench_stack_info = b_dict.get("stack_info", None) - - for index, n_name in enumerate(n_dict["op_name"]): - b_name = b_dict["op_name"][index] - if n_name.find("input") != -1: - n_struct = n_dict["input_struct"][index] - b_struct = b_dict["input_struct"][index] - else: - n_struct = n_dict["output_struct"][index_out] - b_struct = b_dict["output_struct"][index_out] - index_out += 1 + for index in range(min_len): + n_name = n_dict['op_name'][n_start + index] + b_name = n_dict['op_name'][b_start + index] + n_struct = n_dict[key][index] + b_struct = b_dict[key][index] err_msg = "" - accuracy_check_res = CompareConst.ACCURACY_CHECK_YES - + accuracy_check_yes = CompareConst.ACCURACY_CHECK_YES result_item = [n_name, b_name, n_struct[0], b_struct[0], n_struct[1], b_struct[1], " ", " ", " "] - summery_data = n_dict.get("summery")[index] + summery_data = n_dict.get("summery")[n_start + index] result_item.extend(summery_data) - - summery_data = b_dict.get("summery")[index] + summery_data = b_dict.get("summery")[b_start + index] result_item.extend(summery_data) - result_item.append(accuracy_check_res) + + result_item.append(accuracy_check_yes) result_item.append(err_msg) - if npu_stack_info and bench_stack_info and index == 0: + if npu_stack_info and bench_stack_info and index == 0 and key == "input_struct": result_item.extend(npu_stack_info) result.append(result_item) + if n_len > b_len: + for index in range(b_len, n_len): + 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, " ", " ", " "] + 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]))] + result_item.extend(summery_data) + + err_msg = "" + accuracy_check_yes = CompareConst.ACCURACY_CHECK_YES + result_item.append(accuracy_check_yes) + result_item.append(err_msg) + + if npu_stack_info and bench_stack_info and index == 0 and key == "input_struct": + result_item.extend(npu_stack_info) + + result.append(result_item) + + +def get_accuracy(result, n_dict, b_dict): + n_num = len(n_dict)['op_name'] + b_num = len(b_dict)['op_name'] + n_num_input = len([name for name in n_dict['op_name'] if 'input' in name]) + b_num_input = len([name for name in b_dict['op_name'] if 'input' in name]) + n_num_output = n_num - n_num_input + b_num_output = b_num - b_num_input + get_accuracy_core(result, n_dict, b_dict, 0, n_num_input, 0, b_num_input, 'input_struct') + get_accuracy_core(result, n_dict, b_dict, n_num_input, n_num_output, b_num_input, b_num_output, 'output_struct') + def _do_multi_process(input_parma, result_path): try: diff --git a/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/compare/match.py b/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/compare/match.py new file mode 100644 index 0000000000..409bef3af9 --- /dev/null +++ b/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/compare/match.py @@ -0,0 +1,28 @@ +import os +import yaml +from ..common.file_check_util import FileOpen + + +class AtenIrMapping(): + def __init__(self): + cur_path = os.path.dirname(os.path.realpath(__file__)) + yaml_path = os.path.join(cur_path, "mapping.yaml") + with FileOpen(yaml_path, 'r') as f: + self.aten_mapping = yaml.safe_load(f) + + def match(self, op1, op2): + if "Aten" in op1 and "Aten" not in op2: + return self.match_op(op1, op2) + else: + return self.match_op(op2, op1) + + def match_op(self, aten_op, torch_op): + aten_op_raw_name_overload = '_'.join(aten_op.split("_")[1:-3]) + aten_op_raw_name = aten_op_raw_name_overload.split('.')[0] + torch_op_raw_name = '_'.join(torch_op.split("_")[1:-3]).lower() + matching_op = self.aten_mapping.get(aten_op_raw_name) + if matching_op is None: + return False + if matching_op.lower() == torch_op_raw_name: + return True + return False \ No newline at end of file diff --git a/debug/accuracy_tools/ptdbg_ascend/test/ut/test_acc_compare.py b/debug/accuracy_tools/ptdbg_ascend/test/ut/compare/test_acc_compare.py similarity index 96% rename from debug/accuracy_tools/ptdbg_ascend/test/ut/test_acc_compare.py rename to debug/accuracy_tools/ptdbg_ascend/test/ut/compare/test_acc_compare.py index a35dd542b2..1b2dcae4b7 100644 --- a/debug/accuracy_tools/ptdbg_ascend/test/ut/test_acc_compare.py +++ b/debug/accuracy_tools/ptdbg_ascend/test/ut/compare/test_acc_compare.py @@ -101,6 +101,14 @@ class TestUtilsMethods(unittest.TestCase): self.assertEqual(max_relative_err, "0.000000000000") self.assertEqual(message, "") + def test_check_graph_mode(self): + op1 = "Aten" + op2 = "torch" + self.assertTrue(compare.check_graph_mode(op1, op2)) + self.assertTrue(compare.check_graph_mode(op2, op1)) + self.assertFalse(compare.check_graph_mode(op1, op1)) + self.assertFalse(compare.check_graph_mode(op2, op2)) + def test_check_op(self): fuzzy_match = False result = compare.check_op(npu_dict, bench_dict, fuzzy_match) diff --git a/debug/accuracy_tools/ptdbg_ascend/test/ut/compare/test_match.py b/debug/accuracy_tools/ptdbg_ascend/test/ut/compare/test_match.py new file mode 100644 index 0000000000..d6e12e639c --- /dev/null +++ b/debug/accuracy_tools/ptdbg_ascend/test/ut/compare/test_match.py @@ -0,0 +1,20 @@ +import unittest +import os +from ptdbg_ascend.compare import match + + +class TestMatch(unittest.TestCase): + def test_graph_mapping(self): + op1 = "Aten_convolution_1_forward_0.input.0" + op2 = "Torch_conv2d_0_forward_0.input.0" + op3 = "Torch_batch_norm_0_forward_0.input.0" + op4 = "Aten_convolution.default_1_forward_0.input.0" + op5 = "Aten_foo_1_forward_0.input.0" + self.assertTrue(match.graph_mapping.match(op1, op2)) + self.assertTrue(match.graph_mapping.match(op2, op1)) + self.assertTrue(match.graph_mapping.match(op4, op2)) + self.assertTrue(match.graph_mapping.match(op2, op4)) + self.assertFalse(match.graph_mapping.match(op1, op3)) + self.assertFalse(match.graph_mapping.match(op3, op1)) + self.assertFalse(match.graph_mapping.match(op5, op2)) + self.assertFalse(match.graph_mapping.match(op2, op5)) \ No newline at end of file -- Gitee From 420d6954689cffd2b665fec3287eef4e3a4c4770 Mon Sep 17 00:00:00 2001 From: litian_drinksnow Date: Mon, 20 Nov 2023 12:03:29 +0800 Subject: [PATCH 2/7] fix typo --- .../python/ptdbg_ascend/compare/acc_compare.py | 16 ++++++++-------- .../src/python/ptdbg_ascend/compare/match.py | 14 +++++++++++++- 2 files changed, 21 insertions(+), 9 deletions(-) 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 fec71d29ab..df555fe5c2 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 @@ -134,7 +134,7 @@ def check_graph_mode(a_op_name, b_op_name): def check_op(npu_dict, bench_dict, fuzzy_match): a_op_name = npu_dict["op_name"] b_op_name = bench_dict["op_name"] - graph_mode = check_graph_mode(a_op_name, b_op_name) + graph_mode = check_graph_mode(a_op_name[0], b_op_name[0]) if graph_mode: return graph_mapping.match(a_op_name[0], b_op_name[0]) struct_match = check_struct_match(npu_dict, bench_dict) @@ -286,7 +286,7 @@ def get_accuracy_core(result, n_dict, b_dict, n_start, n_len, b_start, b_len, ke bench_stack_info = b_dict.get("stack_info", None) for index in range(min_len): n_name = n_dict['op_name'][n_start + index] - b_name = n_dict['op_name'][b_start + index] + b_name = b_dict['op_name'][b_start + index] n_struct = n_dict[key][index] b_struct = b_dict[key][index] err_msg = "" @@ -328,8 +328,8 @@ def get_accuracy_core(result, n_dict, b_dict, n_start, n_len, b_start, b_len, ke def get_accuracy(result, n_dict, b_dict): - n_num = len(n_dict)['op_name'] - b_num = len(b_dict)['op_name'] + n_num = len(n_dict['op_name']) + b_num = len(b_dict['op_name']) n_num_input = len([name for name in n_dict['op_name'] if 'input' in name]) b_num_input = len([name for name in b_dict['op_name'] if 'input' in name]) n_num_output = n_num - n_num_input @@ -381,7 +381,7 @@ def _handle_multi_process(func, input_parma, result_path, lock): pool = multiprocessing.Pool(process_num) def err_call(args): - print_error_log('multiprocess compare failed! season:{}'.format(args)) + print_error_log('multiprocess compare failed! Reason: {}'.format(args)) try: pool.terminate() if os.path.exists(result_path): @@ -407,7 +407,7 @@ def compare_ops(idx, fusion_op_names, dump_path_dict, result_path, lock, input_p 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 comapre: {}".format(op_name)) + 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) 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)) @@ -477,7 +477,7 @@ 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) if len(n_value.shape) == 0: if n_value.dtype == bool: n_value = n_value.astype(float) @@ -490,7 +490,7 @@ def compare_by_op(op_name, op_name_mapping_dict, input_parma): 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." if n_value.dtype != b_value.dtype: - print_warn_log("Dtype of NPU and bench Tensor do not match:{}".format(op_name)) + 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." else: err_msg = "" diff --git a/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/compare/match.py b/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/compare/match.py index 409bef3af9..806644bcb1 100644 --- a/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/compare/match.py +++ b/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/compare/match.py @@ -25,4 +25,16 @@ class AtenIrMapping(): return False if matching_op.lower() == torch_op_raw_name: return True - return False \ No newline at end of file + return False + + +graph_mapping = AtenIrMapping() + + + + + + + + + -- Gitee From d773b79cc02183977cb2f01d2871bd4df1ede9a1 Mon Sep 17 00:00:00 2001 From: litian_drinksnow Date: Mon, 20 Nov 2023 20:32:48 +0800 Subject: [PATCH 3/7] clean code --- .../ptdbg_ascend/compare/acc_compare.py | 78 +-- .../python/ptdbg_ascend/compare/mapping.yaml | 607 ++++++++++++++++++ 2 files changed, 646 insertions(+), 39 deletions(-) create mode 100644 debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/compare/mapping.yaml 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 df555fe5c2..e5655e7ef3 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 @@ -124,9 +124,9 @@ def get_max_relative_err(n_value, b_value): def check_graph_mode(a_op_name, b_op_name): - if "Aten" in a_op_name and not "Aten" in b_op_name: + if "Aten" in a_op_name and "Aten" not in b_op_name: return True - if not "Aten" in a_op_name and "Aten" in b_op_name: + if "Aten" not in a_op_name and "Aten" in b_op_name: return True return False @@ -280,62 +280,62 @@ def match_op(npu_queue, bench_queue, fuzzy_match): return -1, -1 -def get_accuracy_core(result, n_dict, b_dict, n_start, n_len, b_start, b_len, key): - min_len = min(n_len, b_len) - npu_stack_info = n_dict.get("stack_info", None) - bench_stack_info = b_dict.get("stack_info", None) - for index in range(min_len): - n_name = n_dict['op_name'][n_start + index] - b_name = b_dict['op_name'][b_start + index] - n_struct = n_dict[key][index] - b_struct = b_dict[key][index] - err_msg = "" - accuracy_check_yes = CompareConst.ACCURACY_CHECK_YES - result_item = [n_name, b_name, n_struct[0], b_struct[0], n_struct[1], b_struct[1], " ", " ", " "] - - summery_data = n_dict.get("summery")[n_start + index] - result_item.extend(summery_data) - summery_data = b_dict.get("summery")[b_start + index] - result_item.extend(summery_data) - - result_item.append(accuracy_check_yes) - result_item.append(err_msg) - if npu_stack_info and bench_stack_info and index == 0 and key == "input_struct": - result_item.extend(npu_stack_info) - - result.append(result_item) - - if n_len > b_len: - for index in range(b_len, n_len): +def get_accuracy(result, n_dict, b_dict): + def get_accuracy_core(n_start, n_len, b_start, b_len, key): + min_len = min(n_len, b_len) + npu_stack_info = n_dict.get("stack_info", None) + bench_stack_info = b_dict.get("stack_info", None) + has_stack = npu_stack_info and bench_stack_info + for index in range(min_len): n_name = n_dict['op_name'][n_start + index] + b_name = b_dict['op_name'][b_start + index] n_struct = n_dict[key][index] - result_item = [n_name, CompareConst.NAN, n_struct[0], CompareConst.NAN, - n_struct[1], CompareConst.NAN, " ", " ", " "] + b_struct = b_dict[key][index] + err_msg = "" + accuracy_check_yes = CompareConst.ACCURACY_CHECK_YES + result_item = [n_name, b_name, n_struct[0], b_struct[0], n_struct[1], b_struct[1], " ", " ", " "] + 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]))] + summery_data = b_dict.get("summery")[b_start + index] result_item.extend(summery_data) - err_msg = "" - accuracy_check_yes = CompareConst.ACCURACY_CHECK_YES result_item.append(accuracy_check_yes) result_item.append(err_msg) - - if npu_stack_info and bench_stack_info and index == 0 and key == "input_struct": + if has_stack and index == 0 and key == "input_struct": result_item.extend(npu_stack_info) result.append(result_item) + if n_len > b_len: + for index in range(b_len, n_len): + 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, " ", " ", " "] + 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]))] + result_item.extend(summery_data) + + err_msg = "" + accuracy_check_yes = CompareConst.ACCURACY_CHECK_YES + result_item.append(accuracy_check_yes) + result_item.append(err_msg) + + if has_stack and index == 0 and key == "input_struct": + result_item.extend(npu_stack_info) + + result.append(result_item) -def get_accuracy(result, n_dict, b_dict): n_num = len(n_dict['op_name']) b_num = len(b_dict['op_name']) n_num_input = len([name for name in n_dict['op_name'] if 'input' in name]) b_num_input = len([name for name in b_dict['op_name'] if 'input' in name]) n_num_output = n_num - n_num_input b_num_output = b_num - b_num_input - get_accuracy_core(result, n_dict, b_dict, 0, n_num_input, 0, b_num_input, 'input_struct') - get_accuracy_core(result, n_dict, b_dict, n_num_input, n_num_output, b_num_input, b_num_output, 'output_struct') + get_accuracy_core(0, n_num_input, 0, b_num_input, 'input_struct') + get_accuracy_core(n_num_input, n_num_output, b_num_input, b_num_output, 'output_struct') def _do_multi_process(input_parma, result_path): diff --git a/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/compare/mapping.yaml b/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/compare/mapping.yaml new file mode 100644 index 0000000000..eaffbe7a18 --- /dev/null +++ b/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/compare/mapping.yaml @@ -0,0 +1,607 @@ +__and__: __and__ +__iand__: __iand__ +__ilshift__: __ilshift__ +__ior__: __ior__ +__irshift__: __irshift__ +__ixor__: __ixor__ +__lshift__: __lshift__ +__or__: __or__ +__rshift__: __rshift__ +__xor__: __xor__ +_adaptive_avg_pool2d: adaptive_avg_pool2d +_adaptive_avg_pool3d: adaptive_avg_pool3d +_cdist_forward: cdist +_cudnn_rnn: rnn +_embedding_bag: embedding_bag +_fft_c2c: fft +_fft_c2r: rfft +_foreach_add_: _foreach_add_ +_foreach_addcdiv: _foreach_addcdiv +_foreach_copy_: _foreach_copy_ +_foreach_lerp_: _foreach_lerp_ +_foreach_maximum: _foreach_maximum +_foreach_mul: _foreach_mul +_foreach_neg_: _foreach_neg_ +_foreach_pow: _foreach_pow +_foreach_reciprocal_: _foreach_reciprocal_ +_foreach_sign: _foreach_sign +_foreach_sqrt: _foreach_sqrt +_foreach_sqrt_: _foreach_sqrt_ +_foreach_sub: _foreach_sub +_fused_adam: FusedAdam +_linalg_det: det +_linalg_eigh: eigh +_linalg_slogdet: slogdet +_linalg_svd: svd +_list_to_tensor: as_tensor +_log_softmax: log_softmax +_native_batch_norm_legit: batch_norm +_nested_tensor_from_tensor_list: _nested_tensor_from_tensor_list +_pdist_forward: pdist +_pin_memory: pin_memory +_reshape_alias: reshape +_resize_output_: resize_ +_softmax: softmax +_to_copy: to +abs: abs +abs_: abs_ +absolute: abs +absolute_: abs_ +acos: acos +acos_: acos_ +acosh: acosh +acosh_: acosh_ +adaptive_max_pool2d: adaptive_max_pool2d +adaptive_max_pool3d: adaptive_max_pool3d +add: add +add_: add_ +addbmm: addbmm +addbmm_: addbmm_ +addcdiv: addcdiv +addcdiv_: addcdiv_ +addcmul: addcmul +addcmul_: addcmul_ +addmm: addmm +addmm_: addmm_ +addmv: addmv +addmv_: addmv_ +addr: addr +affine_grid_generator: affine_grid +alias: alias +all: all +alpha_dropout: AlphaDropout +amax: amax +amin: amin +aminmax: aminmax +angle: angle +any: any +arange: arange +arccos: acos +arccos_: arccos_ +arccosh: arccosh +arccosh_: arccosh_ +arcsin: asin +arcsin_: arcsin_ +arcsinh: asinh +arcsinh_: arcsinh_ +arctan: atan +arctan2: atan2 +arctan2_: arctan2_ +arctan_: arctan_ +arctanh: arctanh +arctanh_: arctanh_ +argmax: argmax +argmin: argmin +argsort: argsort +as_strided: as_strided +asin: asin +asin_: asin_ +asinh: asinh +asinh_: asinh_ +atan: atan +atan2: atan2 +atan2_: atan2_ +atan_: atan_ +atanh: atanh +atanh_: atanh_ +avg_pool2d: avg_pool2d +avg_pool3d: avg_pool3d +baddbmm: baddbmm +baddbmm_: baddbmm_ +bernoulli: bernoulli +bernoulli_: bernoulli_ +binary_cross_entropy: BCELoss +binary_cross_entropy_with_logits: binary_cross_entropy_with_logits +bitwise_and: bitwise_and +bitwise_and_: bitwise_and_ +bitwise_left_shift: __lshift__ +bitwise_left_shift_: bitwise_left_shift_ +bitwise_not: bitwise_not +bitwise_not_: bitwise_not_ +bitwise_or: bitwise_or +bitwise_or_: bitwise_or_ +bitwise_right_shift: __rshift__ +bitwise_right_shift_: bitwise_right_shift_ +bitwise_xor: bitwise_xor +bitwise_xor_: bitwise_xor_ +bmm: bmm +broadcast_tensors: broadcast_tensors +bucketize: bucketize +cat: cat +cauchy: Cauchy +cauchy_: cauchy_ +ceil: ceil +ceil_: ceil_ +celu: celu +celu_: celu_ +cholesky: cholesky +cholesky_inverse: cholesky_inverse +cholesky_solve: cholesky_solve +clamp: clamp +clamp_: clamp_ +clamp_max: clamp_max +clamp_max_: clamp_max_ +clamp_min: clamp_min +clamp_min_: clamp_min_ +clip: clip +clip_: clip_ +clone: clone +col2im: col2im +complex: complex +conj_physical: conj +conj_physical_: conj_ +constant_pad_nd: pad +convolution: Conv2d +copy: copy_ +copy_: copy_ +copysign: copysign +copysign_: copysign_ +cos: cos +cos_: cos_ +cosh: cosh +cosh_: cosh_ +count_nonzero: count_nonzero +cudnn_batch_norm: BatchNorm2d +cummax: cummax +cummin: cummin +cumprod: cumprod +cumprod_: cumprod_ +cumsum: cumsum +cumsum_: cumsum_ +deg2rad: deg2rad +deg2rad_: deg2rad_ +detach: detach +diag: diag +diag_embed: diag_embed +diagonal: diagonal +diagonal_copy: diagonal +diagonal_scatter: diagonal +digamma: digamma +digamma_: digamma_ +dist: dist +div: div +div_: div_ +divide: div +divide_: divide_ +dot: dot +dropout: dropout +elu: ELU +elu_: elu_ +embedding: embedding +empty_like: empty_like +empty_strided: empty_strided +eq: eq +eq_: eq_ +erf: erf +erf_: erf_ +erfc: erfc +erfc_: erfc_ +erfinv: erfinv +erfinv_: erfinv_ +exp: exp +exp2: exp2 +exp2_: exp2_ +exp_: exp_ +expand: expand +expm1: expm1 +expm1_: expm1_ +exponential: Exponential +exponential_: exponential_ +eye: eye +fft_fft: fft +fft_fft2: fft2 +fft_fftn: fftn +fft_fftshift: fftshift +fft_hfft: hfft +fft_hfft2: hfft2 +fft_hfftn: hfftn +fft_ifft: ifft +fft_ifft2: ifft2 +fft_ifftn: ifftn +fft_ifftshift: ifftshift +fft_ihfft: ihfft +fft_ihfft2: ihfft2 +fft_ihfftn: ifftn +fft_irfft: irfft +fft_irfft2: irfft2 +fft_irfftn: irfftn +fft_rfft: rfft +fft_rfft2: rfft2 +fft_rfftn: rfftn +fill: fill_ +fill_: fill_ +fix: fix +fix_: fix_ +flip: flip +float_power_: float_power_ +floor: floor +floor_: floor_ +floor_divide: floor_divide +floor_divide_: floor_divide_ +fmax: fmax +fmin: fmin +fmod: fmod +fmod_: fmod_ +frac: frac +frac_: frac_ +full: full +full_like: full_like +gather: gather +gcd: gcd +gcd_: gcd_ +ge: ge +ge_: ge_ +gelu: GELU +gelu_: gelu_ +geometric: Geometric +geometric_: geometric_ +glu: glu +greater: gt +greater_: ge_ +greater_equal: ge +greater_equal_: ge_ +grid_sampler_2d: grid_sample +grid_sampler_3d: grid_sample +gru: GRU +gt: gt +gt_: gt_ +hardshrink: Hardshrink +hardsigmoid: hardsigmoid +hardsigmoid_: hardsigmoid_ +hardswish: hardswish +hardswish_: hardswish_ +hardtanh: hardtanh +hardtanh_: hardtanh_ +heaviside: heaviside +heaviside_: heaviside_ +hinge_embedding_loss: HingeEmbeddingLoss +huber_loss: huber_loss +hypot: hypot +hypot_: hypot_ +i0: i0 +i0_: i0_ +igamma: igamma +igamma_: igamma_ +igammac: igammac +igammac_: igammac_ +index: __getitem__ +index_add: index_add +index_add_: index_add_ +index_copy: index_copy_ +index_copy_: index_copy_ +index_fill: index_fill_ +index_fill_: index_fill_ +index_put: index_put_ +index_put_: index_put_ +index_reduce: index_select +index_select: index_select +is_pinned: is_pinned +is_same_size: is_same_size +isinf: isinf +isnan: isnan +isneginf: isneginf +isposinf: isposinf +istft: istft +item: item +lcm: lcm +lcm_: lcm_ +le: le +le_: le_ +leaky_relu: LeakyReLU +leaky_relu_: leaky_relu_ +lerp: lerp +lerp_: lerp_ +less: less +less_: less_ +less_equal: le +less_equal_: less_equal_ +lgamma: lgamma +lgamma_: lgamma_ +linalg_cholesky_ex: cholesky +linalg_cross: cross +linalg_householder_product: householder_product +linalg_inv_ex: inv +linalg_ldl_factor_ex: ldl +linalg_ldl_solve: ldl_solve +linalg_lu: lu +linalg_lu_factor_ex: lu_factor +linalg_lu_solve: lu_solve +linalg_matrix_exp: matrix_exp +linalg_qr: qr +linalg_solve_triangular: solve +linalg_vector_norm: norm +linspace: linspace +log: log +log10: log10 +log10_: log10_ +log1p: log1p +log1p_: log1p_ +log2: log2 +log2_: log2_ +log_: log_ +log_normal: LogNormal +log_sigmoid_forward: log_sigmoid +logaddexp: logaddexp +logaddexp2: logaddexp2 +_native_batch_norm_legit_functional: batch_norm +logcumsumexp: logcumsumexp +logical_and: logical_and +logical_and_: logical_and_ +logical_not: logical_not +logical_not_: logical_not_ +logical_or: logical_or +logical_or_: logical_or_ +logical_xor: logical_xor +logical_xor_: logical_xor_ +logit: logit +logit_: logit_ +logspace: logspace +logsumexp: logsumexp +lstm: LSTM +lt: lt +lt_: lt_ +lu_unpack: lu_unpack +margin_ranking_loss: margin_ranking_loss +masked_fill: masked_fill +masked_fill_: masked_fill_ +matmul: matmul +max: max +max_pool2d_with_indices: MaxPool2d +max_pool3d_with_indices: MaxPool3d +max_unpool2d: MaxUnpool2d +max_unpool3d: max_unpool3d +maximum: maximum +mean: mean +median: median +meshgrid: meshgrid +min: min +minimum: minimum +mish: Mish +mish_: mish_ +mm: mm +mode: mode +mse_loss: mse_loss +mul: mul +mul_: mul_ +multi_margin_loss: MultiMarginLoss +multilabel_margin_loss_forward: multilabel_margin_loss +multinomial: multinomial +multiply: multiply +multiply_: mul_ +mv: mv +mvlgamma: mvlgamma +mvlgamma_: mvlgamma_ +name: name +nan_to_num: nan_to_num +nan_to_num_: nan_to_num_ +nanmedian: nanmedian +nansum: nansum +narrow_copy: narrow +native_batch_norm: BatchNorm2d +native_dropout: dropout +native_group_norm: group_norm +native_layer_norm: LayerNorm +ne: ne +ne_: ne_ +neg: neg +neg_: neg_ +negative: neg +negative_: neg_ +new_empty: new_empty +new_empty_strided: new_empty_strided +new_full: new_full +new_ones: new_ones +new_zeros: new_zeros +nextafter: nextafter +nextafter_: nextafter_ +nll_loss: nll_loss +nll_loss2d_forward: NLLLoss2d +nll_loss_forward: NLLLoss +nonzero_static: nonzero +norm: norm +normal: normal +normal_: normal_ +not_equal: ne +not_equal_: ne_ +ones: ones +ones_like: ones_like +ormqr: ormqr +pairwise_distance: pairwise_distance +pdist: pdist +permute: permute +pin_memory: pin_memory +pixel_shuffle: PixelShuffle +polar: polar +polygamma: polygamma +positive: positive +pow: pow +pow_: pow_ +prelu: prelu +prod: prod +quantized_gru: GRU +quantized_lstm: LSTM +rad2deg: rad2deg +rad2deg_: rad2deg_ +rand: rand +rand_like: rand_like +randint: randint +randint_like: randint_like +randn: randn +randn_like: randn_like +randperm: randperm +reciprocal: reciprocal +reciprocal_: reciprocal_ +reflection_pad1d: reflection_pad1d +reflection_pad2d: reflection_pad2d +reflection_pad3d: ReflectionPad3d +relu: relu +relu6: relu6 +relu_: relu_ +remainder: remainder +remainder_: remainder_ +renorm: renorm +renorm_: renorm_ +repeat: repeat +repeat_interleave: repeat_interleave +replication_pad1d: ReplicationPad1d +replication_pad2d: replication_pad2d +replication_pad3d: replication_pad3d +resize_as_: resize_as_ +rnn_relu: RNN +rnn_tanh: RNN +roll: roll +rot90: rot90 +round: round +round_: round_ +rrelu_with_noise: RReLU +rrelu_with_noise_: rrelu_with_noise +rsqrt: rsqrt +rsqrt_: rsqrt_ +rsub: rsub +scalar_tensor: scalar_tensor +scatter: scatter_ +scatter_: scatter_ +scatter_add: scatter_add +scatter_add_: scatter_add_ +searchsorted: searchsorted +select: select +selu: selu +selu_: selu_ +sgn: sgn +sgn_: sgn_ +sigmoid: sigmoid +sigmoid_: sigmoid_ +sign: sign +sign_: sign_ +signbit: signbit +silu: silu +silu_: silu_ +sin: sin +sin_: sin_ +sinc: sinc +sinc_: sinc_ +sinh: sinh +sinh_: sinh_ +slice: slice +smooth_l1_loss: smooth_l1_loss +soft_margin_loss: soft_margin_loss +softplus: softplus +softshrink: softshrink +sort: sort +special_airy_ai: airy_ai +special_bessel_j0: j0 +special_bessel_j1: j1 +special_bessel_y0: y0 +special_bessel_y1: y1 +special_chebyshev_polynomial_t: chebyshev_t +special_chebyshev_polynomial_u: chebyshev_u +special_entr: entr +special_erfcx: erfcx +special_hermite_polynomial_h: hermite +special_hermite_polynomial_he: he +special_i0: i0 +special_i0e: i0e +special_i1: i1 +special_i1e: i1e +special_laguerre_polynomial_l: laguerre_l +special_log_ndtr: log_ndtr +special_modified_bessel_i0: i0 +special_modified_bessel_i1: i1 +special_modified_bessel_k0: k0 +special_modified_bessel_k1: i1 +special_ndtr: ndtr +special_ndtri: ndtri +special_scaled_modified_bessel_k0: i0e +special_scaled_modified_bessel_k1: scaled_modified_bessel_k1 +special_spherical_bessel_j0: spherical_jn +special_xlog1py: xlog1py +special_zeta: zeta +split: split +split_with_sizes: split +sqrt: sqrt +sqrt_: sqrt_ +square: square +square_: square_ +squeeze: squeeze +stack: stack +std: std +std_mean: std_mean +stft: stft +sub: sub +sub_: sub_ +subtract: sub +subtract_: subtract_ +sum: sum +t: t +t_: t_ +take: take +tan: tan +tan_: tan_ +tanh: tanh +tanh_: tanh_ +threshold: threshold +threshold_: threshold_ +to: to +topk: topk +trace: trace +transpose: transpose +transpose_: transpose_ +triangular_solve: triangular_solve +tril: tril +tril_: tril_ +tril_indices: tril_indices +triu: triu +triu_: triu_ +triu_indices: triu_indices +true_divide: true_divide +true_divide_: true_divide_ +trunc: trunc +trunc_: trunc_ +unbind: unbind +unfold: unfold +uniform: Uniform +uniform_: uniform_ +unsafe_chunk: unsafe_chunk +unsafe_split: split +unsafe_split_with_sizes: split_with_sizes +unsqueeze: unsqueeze +unsqueeze_: unsqueeze_ +upsample_bicubic2d: interpolate +upsample_bilinear2d: upsample_bilinear +upsample_nearest1d: interpolate +upsample_nearest2d: interpolate +upsample_nearest3d: interpolate +var: var +var_mean: var_mean +vdot: vdot +view: view +where: where +xlogy: xlogy +xlogy_: xlogy_ +zero: zeros +zero_: zero_ +zeros: zeros +zeros_like: zeros_like + + + -- Gitee From c3847cb7d2159ad3dccfc8e1d96ffb58a1462ba2 Mon Sep 17 00:00:00 2001 From: litian_drinksnow Date: Mon, 20 Nov 2023 20:50:29 +0800 Subject: [PATCH 4/7] add ut for graph mode compare --- .../test/ut/compare/test_acc_compare.py | 56 ++++++++++++++++++- 1 file changed, 55 insertions(+), 1 deletion(-) 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 1b2dcae4b7..1910c830ee 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 @@ -25,6 +25,55 @@ result_op_dict = {'op_name': ['Functional_conv2d_0_forward_input.0', 'Functional 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', + 'Aten__native_batch_norm_legit_functional.default_0_forward_input.2', + 'Aten__native_batch_norm_legit_functional.default_0_forward_input.3', + 'Aten__native_batch_norm_legit_functional.default_0_forward_input.4', + 'Aten__native_batch_norm_legit_functional.default_0_forward_output.0', + 'Aten__native_batch_norm_legit_functional.default_0_forward_output.1', + 'Aten__native_batch_norm_legit_functional.default_0_forward_output.2', + 'Aten__native_batch_norm_legit_functional.default_0_forward_output.3', + 'Aten__native_batch_norm_legit_functional.default_0_forward_output.4'], + 'input_struct': [('torch.float16', [256, 256, 14, 14]), ('torch.float32', [256]), ('torch.float32', [256]), ('torch.float32', [256]), ('torch.float32', [256])], + 'output_struct': [('torch.float16', [256, 256, 14, 14]), ('torch.float32', [256]), ('torch.float32', [256]), ('torch.float32', [256]), ('torch.float32', [256])], + 'summery': [[139.625, -127.5625, -0.0103607177734375], + [2.5276029109954834, -2.1788690090179443, -0.0008259844034910202], + [2.472219944000244, -2.845968723297119, -0.008756577968597412], + [2.763145923614502, -3.398397922515869, -0.052132632583379745], + [2.673110008239746, -3.149275064468384, 0.01613386906683445], + [13.5546875, -10.640625, -0.008758544921875], + [0.30550330877304077, -0.24485322833061218, -0.010361209511756897], + [623.9192504882812, 432.96826171875, 520.2276611328125], + [2.4797861576080322, -3.055997371673584, -0.04795549064874649], + [61.7945556640625, 42.59713363647461, 52.03831481933594]]} + +bench_dict_functional = {'op_name': ['Functional_batch_norm_0_forward_input.0', 'Functional_batch_norm_0_forward_input.1', + 'Functional_batch_norm_0_forward_input.2', 'Functional_batch_norm_0_forward_input.3', + 'Functional_batch_norm_0_forward_input.4', 'Functional_batch_norm_0_forward_output'], + 'input_struct': [('torch.float32', [256, 256, 14, 14]), ('torch.float32', [256]), ('torch.float32', [256]), + ('torch.float32', [256]), ('torch.float32', [256])], + 'output_struct': [('torch.float32', [256, 256, 14, 14])], + 'summery': [[3.061628818511963, -3.22507381439209, 3.634914173744619e-05], + [0.0005779837374575436, -0.0006301702815108001, 3.634906533989124e-06], + [0.9338104128837585, 0.9277191162109375, 0.930335283279419], + [1.0, 1.0, 1.0], [0.0, 0.0, 0.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', 'N/A', 'torch.float32', 'N/A', [256], 'N/A', ' ', ' ', ' ', 0.30550330877304077, -0.24485322833061218, -0.010361209511756897, 'N/A', 'N/A', 'N/A', 'Yes', ''], + ['Aten__native_batch_norm_legit_functional.default_0_forward_output.2', 'N/A', 'torch.float32', 'N/A', [256], 'N/A', ' ', ' ', ' ', 623.9192504882812, 432.96826171875, 520.2276611328125, 'N/A', 'N/A', 'N/A', 'Yes', ''], + ['Aten__native_batch_norm_legit_functional.default_0_forward_output.3', 'N/A', 'torch.float32', 'N/A', [256], 'N/A', ' ', ' ', ' ', 2.4797861576080322, -3.055997371673584, -0.04795549064874649, 'N/A', 'N/A', 'N/A', 'Yes', ''], + ['Aten__native_batch_norm_legit_functional.default_0_forward_output.4', 'N/A', 'torch.float32', 'N/A', [256], 'N/A', ' ', ' ', ' ', 61.7945556640625, 42.59713363647461, 52.03831481933594, 'N/A', 'N/A', 'N/A', 'Yes', ''] + ] + + class TestUtilsMethods(unittest.TestCase): def test_correct_data(self): input_1 = 'NAN' @@ -119,7 +168,7 @@ class TestUtilsMethods(unittest.TestCase): self.assertEqual(op_dict, result_op_dict) def test_read_op(self): - base_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__))) + base_dir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) pkl_dir = os.path.join(base_dir, "resources/compare/npu_test.pkl") @@ -141,3 +190,8 @@ class TestUtilsMethods(unittest.TestCase): compare.get_accuracy(result, npu_dict, bench_dict) self.assertEqual(result, o_result) + + def test_get_accuracy_graph_mode(self): + result = [] + compare.get_accuracy(result, npu_dict_aten, bench_dict_functional) + self.assertEqual(result, aten_result) -- Gitee From b3e8ddd46ca43bd2871d7e4665ca608226cac2c1 Mon Sep 17 00:00:00 2001 From: litian_drinksnow Date: Mon, 20 Nov 2023 20:56:44 +0800 Subject: [PATCH 5/7] fix compare ut data --- .../ptdbg_ascend/test/ut/compare/test_acc_compare.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) 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 1910c830ee..05f72181a4 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 @@ -67,10 +67,10 @@ aten_result = [['Aten__native_batch_norm_legit_functional.default_0_forward_inpu ['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', 'N/A', 'torch.float32', 'N/A', [256], 'N/A', ' ', ' ', ' ', 0.30550330877304077, -0.24485322833061218, -0.010361209511756897, 'N/A', 'N/A', 'N/A', 'Yes', ''], - ['Aten__native_batch_norm_legit_functional.default_0_forward_output.2', 'N/A', 'torch.float32', 'N/A', [256], 'N/A', ' ', ' ', ' ', 623.9192504882812, 432.96826171875, 520.2276611328125, 'N/A', 'N/A', 'N/A', 'Yes', ''], - ['Aten__native_batch_norm_legit_functional.default_0_forward_output.3', 'N/A', 'torch.float32', 'N/A', [256], 'N/A', ' ', ' ', ' ', 2.4797861576080322, -3.055997371673584, -0.04795549064874649, 'N/A', 'N/A', 'N/A', 'Yes', ''], - ['Aten__native_batch_norm_legit_functional.default_0_forward_output.4', 'N/A', 'torch.float32', 'N/A', [256], 'N/A', ' ', ' ', ' ', 61.7945556640625, 42.59713363647461, 52.03831481933594, 'N/A', 'N/A', 'N/A', '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', ''] ] -- Gitee From b875280ebcaf0a3bc9f5e5e247b133abbfe50b1b Mon Sep 17 00:00:00 2001 From: litian_drinksnow Date: Tue, 21 Nov 2023 12:01:59 +0800 Subject: [PATCH 6/7] capture exception indexerror --- .../ptdbg_ascend/compare/acc_compare.py | 6 ++---- .../src/python/ptdbg_ascend/compare/match.py | 21 +++++++------------ 2 files changed, 10 insertions(+), 17 deletions(-) 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 e5655e7ef3..e214ce1dd1 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 @@ -292,7 +292,6 @@ def get_accuracy(result, n_dict, b_dict): n_struct = n_dict[key][index] b_struct = b_dict[key][index] err_msg = "" - accuracy_check_yes = CompareConst.ACCURACY_CHECK_YES result_item = [n_name, b_name, n_struct[0], b_struct[0], n_struct[1], b_struct[1], " ", " ", " "] summery_data = n_dict.get("summery")[n_start + index] @@ -300,7 +299,7 @@ def get_accuracy(result, n_dict, b_dict): summery_data = b_dict.get("summery")[b_start + index] result_item.extend(summery_data) - result_item.append(accuracy_check_yes) + result_item.append(CompareConst.ACCURACY_CHECK_YES) result_item.append(err_msg) if has_stack and index == 0 and key == "input_struct": result_item.extend(npu_stack_info) @@ -319,8 +318,7 @@ def get_accuracy(result, n_dict, b_dict): result_item.extend(summery_data) err_msg = "" - accuracy_check_yes = CompareConst.ACCURACY_CHECK_YES - result_item.append(accuracy_check_yes) + result_item.append(CompareConst.ACCURACY_CHECK_YES) result_item.append(err_msg) if has_stack and index == 0 and key == "input_struct": diff --git a/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/compare/match.py b/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/compare/match.py index 806644bcb1..d8d1a6ebe7 100644 --- a/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/compare/match.py +++ b/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/compare/match.py @@ -1,7 +1,7 @@ import os import yaml from ..common.file_check_util import FileOpen - +from ..common.utils import CompareException class AtenIrMapping(): def __init__(self): @@ -17,9 +17,13 @@ class AtenIrMapping(): return self.match_op(op2, op1) def match_op(self, aten_op, torch_op): - aten_op_raw_name_overload = '_'.join(aten_op.split("_")[1:-3]) - aten_op_raw_name = aten_op_raw_name_overload.split('.')[0] - torch_op_raw_name = '_'.join(torch_op.split("_")[1:-3]).lower() + try: + aten_op_raw_name_overload = '_'.join(aten_op.split("_")[1:-3]) + aten_op_raw_name = aten_op_raw_name_overload.split('.')[0] + torch_op_raw_name = '_'.join(torch_op.split("_")[1:-3]).lower() + except IndexError: + raise CompareException.INVALID_DATA_ERROR(f"Dump op name format error: {aten_op}, {torch_op}. " + f"Your dump data may be corrupted.") matching_op = self.aten_mapping.get(aten_op_raw_name) if matching_op is None: return False @@ -29,12 +33,3 @@ class AtenIrMapping(): graph_mapping = AtenIrMapping() - - - - - - - - - -- Gitee From 3d3b3e83a574e021a83ab4a546e6c4e914a87bee Mon Sep 17 00:00:00 2001 From: litian_drinksnow Date: Tue, 21 Nov 2023 12:21:24 +0800 Subject: [PATCH 7/7] clean code --- .../ptdbg_ascend/src/python/ptdbg_ascend/compare/match.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/compare/match.py b/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/compare/match.py index d8d1a6ebe7..1840bdf52d 100644 --- a/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/compare/match.py +++ b/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/compare/match.py @@ -3,6 +3,7 @@ import yaml from ..common.file_check_util import FileOpen from ..common.utils import CompareException + class AtenIrMapping(): def __init__(self): cur_path = os.path.dirname(os.path.realpath(__file__)) @@ -21,9 +22,9 @@ class AtenIrMapping(): aten_op_raw_name_overload = '_'.join(aten_op.split("_")[1:-3]) aten_op_raw_name = aten_op_raw_name_overload.split('.')[0] torch_op_raw_name = '_'.join(torch_op.split("_")[1:-3]).lower() - except IndexError: - raise CompareException.INVALID_DATA_ERROR(f"Dump op name format error: {aten_op}, {torch_op}. " - f"Your dump data may be corrupted.") + except IndexError as e: + err_msg = f"Dump op name format error: {aten_op}, {torch_op}. Your dump data may be corrupted." + raise CompareException.INVALID_DATA_ERROR(err_msg) from e matching_op = self.aten_mapping.get(aten_op_raw_name) if matching_op is None: return False -- Gitee