From 7e5edd32277054b0c5198873ea57a966ecc96028 Mon Sep 17 00:00:00 2001 From: l00816237 Date: Mon, 11 Dec 2023 14:17:28 +0800 Subject: [PATCH] add summary_model parameter, can dump md5 when summary_model is md5, --- .../src/python/ptdbg_ascend/common/utils.py | 23 ++++++ .../ptdbg_ascend/compare/acc_compare.py | 70 +++++++++++++------ .../compare/distributed_compare.py | 6 +- .../debugger/precision_debugger.py | 10 ++- .../src/python/ptdbg_ascend/dump/dump.py | 16 +++-- .../src/python/ptdbg_ascend/dump/utils.py | 55 +++++++++------ .../test/ut/compare/test_acc_compare.py | 4 +- .../ptdbg_ascend/test/ut/test_hooks.py | 2 +- .../ptdbg_ascend/test/ut/test_utils.py | 13 +++- 9 files changed, 144 insertions(+), 55 deletions(-) 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 942391d4b1..e7777272a2 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 @@ -23,6 +23,8 @@ import stat import subprocess import sys import time +import hashlib +import json from datetime import datetime, timezone from functools import wraps from pathlib import Path @@ -142,6 +144,9 @@ class CompareConst: ERROR_MESSAGE = "Err_message" ONE_THOUSANDTH_ERR_RATIO = "One Thousandth Err Ratio" FIVE_THOUSANDTHS_ERR_RATIO = "Five Thousandths Err Ratio" + NPU_MD5 = "NPU MD5" + BENCH_MD5 = "BENCH MD5" + RESULT = "Result" COMPARE_RESULT_HEADER = [ NPU_NAME, BENCH_NAME, NPU_DTYPE, BENCH_DTYPE, NPU_SHAPE, BENCH_SHAPE, COSINE, MAX_ABS_ERR, MAX_RELATIVE_ERR, @@ -154,6 +159,10 @@ class CompareConst: NPU_MAX, NPU_MIN, NPU_MEAN, NPU_NORM, BENCH_MAX, BENCH_MIN, BENCH_MEAN, BENCH_NORM, ACCURACY, ERROR_MESSAGE ] + MD5_COMPARE_RESULT_HEADER = [ + NPU_NAME, BENCH_NAME, NPU_DTYPE, BENCH_DTYPE, NPU_SHAPE, BENCH_SHAPE, NPU_MD5, BENCH_MD5, RESULT + ] + # compare result data NAN = 'Nan' SHAPE_UNMATCH = 'shape unmatched' @@ -375,6 +384,14 @@ def is_summary_compare(input_param): raise CompareException(CompareException.INVALID_PATH_ERROR) +def is_md5_compare(input_parma): + with FileOpen(input_parma.get("npu_pkl_path"), "r") as npu_pkl: + line = json.loads(npu_pkl.readline()) + if line[2]: + return True + return False + + def check_configuration_param(stack_mode=False, auto_analyze=True, fuzzy_match=False): if not (isinstance(stack_mode, bool) and isinstance(auto_analyze, bool) and isinstance(fuzzy_match, bool)): print_error_log("Invalid input parameters which should be only bool type.") @@ -726,6 +743,12 @@ def check_file_valid(file_path): raise CompareException(CompareException.INVALID_PATH_ERROR) +def get_md5_for_tensor(x): + tensor_bytes = x.cpu().detach().float().numpy().tobytes() + md5_hash = hashlib.md5(tensor_bytes) + return md5_hash.hexdigest() + + def check_path_before_create(path): if len(os.path.realpath(path)) > Const.DIRECTORY_LENGTH or len(os.path.basename(path)) > \ Const.FILE_NAME_LENGTH: 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 39be75e93e..7dde7eadc0 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 @@ -27,9 +27,9 @@ 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,\ + print_warn_log, print_error_log, CompareException, Const, \ CompareConst, format_value, check_file_not_exists, check_configuration_param, \ - is_summary_compare + is_summary_compare, is_md5_compare from ..common.file_check_util import FileChecker, FileCheckConst, change_mode, FileOpen @@ -241,9 +241,9 @@ def merge_tensor(tensor_list): break op_dict["op_name"].append(tensor[0]) if tensor[0].find("input") != -1: - op_dict["input_struct"].append((tensor[3], tensor[4])) + op_dict["input_struct"].append((tensor[3], tensor[4], tensor[2])) elif tensor[0].find("output") != -1: - op_dict["output_struct"].append((tensor[3], tensor[4])) + op_dict["output_struct"].append((tensor[3], tensor[4], tensor[2])) if tensor[1] <= Const.DUMP_RATIO_MAX: op_dict["summery"].append(tensor[5]) @@ -293,7 +293,7 @@ def match_op(npu_queue, bench_queue, fuzzy_match): return -1, -1 -def get_accuracy(result, n_dict, b_dict, summary_compare=False): +def get_accuracy(result, n_dict, b_dict, summary_compare=False, md5_compare=False): 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) @@ -305,6 +305,14 @@ 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 = "" + if md5_compare: + result_item = [n_name, b_name, n_struct[0], b_struct[0], n_struct[1], b_struct[1], + n_struct[2], b_struct[2], n_struct[2] == b_struct[2]] + if has_stack and index == 0 and key == "input_struct": + result_item.extend(npu_stack_info) + result.append(result_item) + continue + if summary_compare: result_item = [n_name, b_name, n_struct[0], b_struct[0], n_struct[1], b_struct[1], " ", " ", " ", " "] @@ -336,6 +344,11 @@ def get_accuracy(result, n_dict, b_dict, summary_compare=False): for index in range(b_len, n_len): n_name = n_dict['op_name'][n_start + index] n_struct = n_dict[key][index] + if md5_compare: + result_item = [n_name, CompareConst.NAN, n_struct[0], CompareConst.NAN, + n_struct[1], CompareConst.NAN, n_struct[2], CompareConst.NAN, CompareConst.NAN] + result.append(result_item) + continue 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] @@ -443,7 +456,8 @@ def compare_ops(idx, fusion_op_names, dump_path_dict, result_path, lock, input_p err_mess.append(err_msg) 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) + _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, one_thousand_err_ratio_result, five_thousand_err_ratio_result, result_path, lock): @@ -571,31 +585,34 @@ def compare(input_parma, output_path, stack_mode=False, auto_analyze=True, fuzzy_match=False): try: summary_compare = is_summary_compare(input_parma) + md5_compare = is_md5_compare(input_parma) check_configuration_param(stack_mode, auto_analyze, fuzzy_match) check_compare_param(input_parma, output_path, stack_mode, summary_compare) except CompareException as error: print_error_log('Compare failed. Please check the arguments and do it again!') sys.exit(error.code) compare_core(input_parma, output_path, stack_mode=stack_mode, - auto_analyze=auto_analyze, fuzzy_match=fuzzy_match, summary_compare=summary_compare) + auto_analyze=auto_analyze, fuzzy_match=fuzzy_match, summary_compare=summary_compare, + md5_compare=md5_compare) def compare_core(input_parma, output_path, stack_mode=False, auto_analyze=True, - suffix='', fuzzy_match=False, summary_compare=False): + suffix='', fuzzy_match=False, summary_compare=False, md5_compare=False): print_warn_log("Please check whether the input data belongs to you. If not, there may be security risks.") file_name = add_time_as_suffix("compare_result" + suffix) file_path = os.path.join(os.path.realpath(output_path), file_name) check_file_not_exists(file_path) with FileOpen(input_parma.get("npu_pkl_path"), "r") as npu_pkl, \ - FileOpen(input_parma.get("bench_pkl_path"), "r") as bench_pkl, \ - os.fdopen(os.open(file_path, os.O_RDWR | os.O_CREAT, stat.S_IWUSR | stat.S_IRUSR | stat.S_IRGRP), 'w+') \ - as fout: - compare_process([npu_pkl, bench_pkl, fout], stack_mode, fuzzy_match, summary_compare) + FileOpen(input_parma.get("bench_pkl_path"), "r") as bench_pkl, \ + os.fdopen(os.open(file_path, os.O_RDWR | os.O_CREAT, stat.S_IWUSR | stat.S_IRUSR | stat.S_IRGRP), 'w+') \ + as fout: + compare_process([npu_pkl, bench_pkl, fout], stack_mode, fuzzy_match, summary_compare, md5_compare) if summary_compare: return - _do_multi_process(input_parma, file_path) + if not md5_compare: + _do_multi_process(input_parma, file_path) change_mode(file_path, FileCheckConst.DATA_FILE_AUTHORITY) if auto_analyze: advisor = Advisor(file_path, output_path) @@ -637,7 +654,7 @@ def parse(pkl_file, module_name_prefix): print(summery_info) -def compare_process(file_handles, stack_mode, fuzzy_match, summary_compare=False): +def compare_process(file_handles, stack_mode, fuzzy_match, summary_compare=False, md5_compare=False): npu_pkl_handle, bench_pkl_handle, output_csv_handle = file_handles if fuzzy_match: print_warn_log("This task uses fuzzy matching, which may affect the accuracy of the comparison.") @@ -657,27 +674,32 @@ def compare_process(file_handles, stack_mode, fuzzy_match, summary_compare=False b_match_data = bench_ops_queue[b_match_point] un_match_data = npu_ops_queue[0: n_match_point] for npu_data in un_match_data: - get_un_match_accuracy(result, npu_data) - get_accuracy(result, n_match_data, b_match_data, summary_compare) + get_un_match_accuracy(result, npu_data, md5_compare) + get_accuracy(result, n_match_data, b_match_data, summary_compare, md5_compare) del npu_ops_queue[0: n_match_point + 1] del bench_ops_queue[0: b_match_point + 1] if npu_ops_queue: for npu_data in npu_ops_queue: - get_un_match_accuracy(result, npu_data) + get_un_match_accuracy(result, npu_data, md5_compare) - header = CompareConst.COMPARE_RESULT_HEADER[:] \ - if not summary_compare else CompareConst.SUMMARY_COMPARE_RESULT_HEADER[:] + header = [] + if md5_compare: + header = CompareConst.MD5_COMPARE_RESULT_HEADER[:] + elif summary_compare: + header = CompareConst.SUMMARY_COMPARE_RESULT_HEADER[:] + else: + header = CompareConst.COMPARE_RESULT_HEADER[:] if stack_mode: header.append(CompareConst.STACK) result_df = pd.DataFrame(result, columns=header) - if summary_compare: + if summary_compare and not md5_compare: header.remove(CompareConst.ACCURACY) header.remove(CompareConst.ERROR_MESSAGE) result_df = result_df[header] result_df.to_csv(output_csv_handle, index=False) -def get_un_match_accuracy(result, n_dict): +def get_un_match_accuracy(result, n_dict, md5_compare): index_out = 0 npu_stack_info = n_dict.get("stack_info", None) bench_name, bench_type, bench_shape = CompareConst.NAN, CompareConst.NAN, CompareConst.NAN @@ -691,6 +713,12 @@ 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] + if md5_compare: + result_item.extend([CompareConst.NAN] * 3) + if npu_stack_info and index == 0: + result_item.extend(npu_stack_info) + result.append(result_item) + continue result_item.extend([CompareConst.NAN] * 5) summery_data = n_dict.get("summery")[index] result_item.extend(summery_data) diff --git a/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/compare/distributed_compare.py b/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/compare/distributed_compare.py index bf038fa479..85f9bb95ff 100644 --- a/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/compare/distributed_compare.py +++ b/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/compare/distributed_compare.py @@ -18,7 +18,7 @@ import os import sys import re from ..common.utils import print_error_log, CompareException, check_compare_param, check_file_or_directory_path, \ - check_configuration_param, is_summary_compare + check_configuration_param, is_summary_compare, is_md5_compare from .acc_compare import compare_core @@ -88,9 +88,11 @@ def compare_distributed(npu_dump_dir, bench_dump_dir, output_path, **kwargs): } try: summary_compare = is_summary_compare(dump_result_param) + md5_compare = is_md5_compare(dump_result_param) check_configuration_param(stack_mode, auto_analyze, fuzzy_match) check_compare_param(dump_result_param, output_path, stack_mode=stack_mode, summary_compare=summary_compare) except CompareException as error: print_error_log('Compare failed. Please check the arguments and do it again!') sys.exit(error.code) - compare_core(dump_result_param, output_path, suffix=f'_{nr}-{br}', summary_compare=summary_compare, **kwargs) + compare_core(dump_result_param, output_path, suffix=f'_{nr}-{br}', summary_compare=summary_compare, + md5_compare=md5_compare, **kwargs) diff --git a/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/debugger/precision_debugger.py b/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/debugger/precision_debugger.py index 6d846b9c21..3a96ccf209 100644 --- a/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/debugger/precision_debugger.py +++ b/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/debugger/precision_debugger.py @@ -54,12 +54,18 @@ class PrecisionDebugger: return hook_dict.get(hook_name, lambda: ValueError("hook name {} is not in ['dump', 'overflow_check']".format(hook_name))) def configure_full_dump(self, mode='api_stack', scope=None, api_list=None, filter_switch=Const.OFF, - input_output_mode=[Const.ALL], acl_config=None, backward_input=None, summary_only=False): + input_output_mode=[Const.ALL], acl_config=None, backward_input=None, summary_only=False, summary_mode="all"): scope = scope or [] api_list = api_list or [] backward_input = backward_input or [] + + if summary_only: + print_warn_log("Argument 'summary_only' will be deprecated, it would be better to use 'summary_mode'") + summary_mode = "summary" + set_dump_switch_config(mode=mode, scope=scope, api_list=api_list, - filter_switch=filter_switch, dump_mode=input_output_mode, summary_only=summary_only) + filter_switch=filter_switch, dump_mode=input_output_mode, summary_only=summary_only, + summary_mode=summary_mode) if mode == 'acl': DumpUtil.set_acl_config(acl_config) if not scope or not isinstance(scope, list) or len(scope) != 1: 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 2a00f83bf5..6e14fbdf43 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,8 @@ 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, CompareConst +from ..common.utils import (print_warn_log, Const, print_info_log, modify_dump_path, check_inplace_op, CompareConst, + get_md5_for_tensor) from ..dump.utils import check_writable from ..common.file_check_util import FileOpen, change_mode, FileCheckConst, check_path_pattern_vaild, check_path_length @@ -82,11 +83,12 @@ api_list = APIList() class DataInfo(object): - def __init__(self, save_data, summary_data, dtype, shape): + def __init__(self, save_data, summary_data, dtype, shape, md5=""): self.save_data = save_data self.summary_data = summary_data self.dtype = dtype self.shape = shape + self.md5 = md5 def get_not_float_tensor_info(data): @@ -111,6 +113,8 @@ def get_scalar_data_info(data): def get_float_tensor_info(data): + if DumpUtil.summary_mode == "md5": + return DataInfo([], [], str(data.dtype), tuple(data.shape), get_md5_for_tensor(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() @@ -121,7 +125,7 @@ def get_float_tensor_info(data): def get_tensor_data_info(data, *tensor_args): summary_data = [] summary_data.extend([*tensor_args]) - if not DumpUtil.summary_only: + if DumpUtil.summary_mode == "all": saved_tensor = data.contiguous().cpu().detach() if data.dtype == torch.bfloat16: saved_numpy = saved_tensor.to(torch.float32).numpy() @@ -163,10 +167,10 @@ def dump_data(dump_step, prefix, data_info): output_path = os.path.join(DumpUtil.dump_data_dir, f'{prefix}.npy') check_path_length(output_path) check_path_pattern_vaild(output_path) - if not DumpUtil.summary_only: + if DumpUtil.summary_mode == "all": np.save(output_path, data_info.save_data) change_mode(output_path, FileCheckConst.DATA_FILE_AUTHORITY) - api_list.append([prefix, dump_step, [], data_info.dtype, data_info.shape, data_info.summary_data]) + api_list.append([prefix, dump_step, data_info.md5, data_info.dtype, data_info.shape, data_info.summary_data]) print_info_log(f"ptdbg is analyzing rank{rank} api: {prefix}" + " " * 10, end='\r') except Exception as e: print_warn_log("Dump data failed, error: {}".format(e)) @@ -273,7 +277,7 @@ def dump_acc_cmp(name, in_feat, out_feat, dump_step, module): if DumpUtil.dump_init_enable: DumpUtil.dump_init_enable = False DumpUtil.dump_data_dir = make_dump_data_dir(dump_file) \ - if DumpUtil.dump_switch_mode not in [Const.STACK, Const.ACL] and not DumpUtil.summary_only else "" + if DumpUtil.dump_switch_mode not in [Const.STACK, Const.ACL] and DumpUtil.summary_mode == "all" else "" if os.path.exists(dump_file) and not os.path.isdir(dump_file): check_writable(dump_file) try: diff --git a/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/dump/utils.py b/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/dump/utils.py index 950294a68f..3d98269920 100644 --- a/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/dump/utils.py +++ b/debug/accuracy_tools/ptdbg_ascend/src/python/ptdbg_ascend/dump/utils.py @@ -9,7 +9,7 @@ import torch.distributed as dist from ..dump import dump from ..common.utils import print_error_log, CompareException, DumpException, Const, get_time, print_info_log, \ check_mode_valid, check_switch_valid, check_dump_mode_valid, check_summary_only_valid, generate_compare_script, \ - check_is_npu, check_file_valid, make_dump_path_if_not_exists, check_path_before_create + check_is_npu, check_file_valid, make_dump_path_if_not_exists, check_path_before_create, print_warn_log from ..common.file_check_util import FileChecker, FileCheckConst, check_path_length, check_path_pattern_vaild from ..common.version import __version__ @@ -54,6 +54,17 @@ def check_stack_mode(name_prefix): return False +class DumpConfig: + def __init__(self, mode=None, scope=None, api_list=None, filter_switch=None, dump_mode=None, summary_only=False, summary_mode="all"): + self.mode = mode + self.scope = scope + self.api_list = api_list + self.filter_switch = filter_switch + self.dump_mode = dump_mode + self.summary_only = summary_only + self.summary_mode = summary_mode + + class DumpUtil(object): dump_root = None dump_data_dir = None @@ -74,6 +85,7 @@ class DumpUtil(object): target_rank = None summary_only = False need_replicate = False + summary_mode = "all" @staticmethod def set_dump_path(save_path): @@ -90,23 +102,25 @@ class DumpUtil(object): DumpUtil.dump_config = acl_config @staticmethod - def set_dump_switch(switch, mode=None, scope=None, api_list=None, filter_switch=None, dump_mode=None, summary_only=False): + def set_dump_switch(switch, dump_config): DumpUtil.dump_switch = switch - if mode is not None: - DumpUtil.dump_switch_mode = mode + if dump_config.mode is not None: + DumpUtil.dump_switch_mode = dump_config.mode DumpUtil.dump_init_enable = True - if scope is not None: - DumpUtil.dump_switch_scope = scope - if api_list is not None: - DumpUtil.dump_api_list = [api.lower() for api in api_list] - if filter_switch is not None: - DumpUtil.dump_filter_switch = filter_switch - if dump_mode is not None: - DumpUtil.dump_mode = dump_mode if isinstance(dump_mode, list) else [dump_mode] - - if mode == Const.ACL: - DumpUtil.dump_switch_scope = [api_name.replace("backward", "forward") for api_name in scope] - DumpUtil.summary_only = summary_only + if dump_config.scope is not None: + DumpUtil.dump_switch_scope = dump_config.scope + if dump_config.api_list is not None: + DumpUtil.dump_api_list = [api.lower() for api in dump_config.api_list] + if dump_config.filter_switch is not None: + DumpUtil.dump_filter_switch = dump_config.filter_switch + if dump_config.dump_mode is not None: + DumpUtil.dump_mode = dump_config.dump_mode if isinstance(dump_config.dump_mode, list) else [dump_config.dump_mode] + + if dump_config.mode == Const.ACL: + DumpUtil.dump_switch_scope = [api_name.replace("backward", "forward") for api_name in dump_config.scope] + + DumpUtil.summary_only = dump_config.summary_only + DumpUtil.summary_mode = dump_config.summary_mode check_mapper = { Const.LIST: check_list_or_acl_mode, @@ -215,7 +229,8 @@ def set_dump_switch(switch, mode=Const.ALL, scope=None, api_list=None, filter_sw check_switch_valid(switch) if not DumpUtil.dump_path: set_dump_path() - DumpUtil.set_dump_switch(switch, summary_only=summary_only) + dump_config = DumpConfig(switch, summary_only=summary_only) + DumpUtil.set_dump_switch(switch, dump_config) dump_path_str = generate_dump_path_str() if switch == "OFF": dump.write_to_disk() @@ -227,7 +242,7 @@ def set_dump_switch(switch, mode=Const.ALL, scope=None, api_list=None, filter_sw def set_dump_switch_config(mode=Const.ALL, scope=None, api_list=None, filter_switch=Const.OFF, dump_mode=None, - summary_only=False): + summary_only=False, summary_mode="all"): if scope is None: scope = [] if api_list is None: @@ -243,8 +258,8 @@ def set_dump_switch_config(mode=Const.ALL, scope=None, api_list=None, filter_swi print_error_log(str(err)) raise CompareException(CompareException.INVALID_PARAM_ERROR) from err switch = DumpUtil.dump_switch - DumpUtil.set_dump_switch("OFF", mode=mode, scope=scope, api_list=api_list, filter_switch=filter_switch, - dump_mode=dump_mode, summary_only=summary_only) + dump_config = DumpConfig(mode, scope, api_list, filter_switch, dump_mode, summary_only, summary_mode) + DumpUtil.set_dump_switch("OFF", dump_config) DumpUtil.dump_switch = switch 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 1d6ebbde0f..d51dbfb93d 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 @@ -19,8 +19,8 @@ tensor_list = [['Functional_conv2d_0_forward_input.0', 1, [], 'torch.float32', [ ['Functional_conv2d_0_forward_input.2', 1, [], 'torch.float32', [16], [0.19734230637550354, -0.18177609145641327, 0.007903944700956345]],\ ['Functional_conv2d_0_forward_output', 1, [], 'torch.float32', [1, 16, 28, 28], [2.1166646480560303, -2.190781354904175, -0.003579073818400502]]] result_op_dict = {'op_name': ['Functional_conv2d_0_forward_input.0', 'Functional_conv2d_0_forward_input.1', 'Functional_conv2d_0_forward_input.2', 'Functional_conv2d_0_forward_output'], \ -'input_struct': [('torch.float32', [1, 1, 28, 28]), ('torch.float32', [16, 1, 5, 5]), ('torch.float32', [16])], \ -'output_struct': [('torch.float32', [1, 16, 28, 28])], 'summery': [[3.029174327850342, -2.926689624786377, -0.06619918346405029], [0.19919930398464203, -0.19974489510059357, 0.006269412115216255], \ +'input_struct': [('torch.float32', [1, 1, 28, 28], []), ('torch.float32', [16, 1, 5, 5], []), ('torch.float32', [16], [])], \ +'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', '']] diff --git a/debug/accuracy_tools/ptdbg_ascend/test/ut/test_hooks.py b/debug/accuracy_tools/ptdbg_ascend/test/ut/test_hooks.py index 82f3d8dfed..8675584a20 100644 --- a/debug/accuracy_tools/ptdbg_ascend/test/ut/test_hooks.py +++ b/debug/accuracy_tools/ptdbg_ascend/test/ut/test_hooks.py @@ -59,7 +59,7 @@ class TestUtilsMethods(unittest.TestCase): def test_set_dump_filter_switch_off(self): dump_util = hooks.DumpUtil - hooks.DumpUtil.dump_path='/home/dump_path/ptdbg_dump_v3.2/rank0' + hooks.DumpUtil.dump_path = '/home/dump_path/ptdbg_dump_v3.2/rank0' hooks.set_dump_switch("ON", filter_switch="OFF") self.assertEqual(dump_util.dump_filter_switch, "OFF") diff --git a/debug/accuracy_tools/ptdbg_ascend/test/ut/test_utils.py b/debug/accuracy_tools/ptdbg_ascend/test/ut/test_utils.py index fcbd728ec1..7a0a34a0c8 100644 --- a/debug/accuracy_tools/ptdbg_ascend/test/ut/test_utils.py +++ b/debug/accuracy_tools/ptdbg_ascend/test/ut/test_utils.py @@ -1,8 +1,9 @@ import unittest +import torch import pytest import ptdbg_ascend.common.utils as utils -from ptdbg_ascend.common.utils import CompareException +from ptdbg_ascend.common.utils import CompareException, is_md5_compare, get_md5_for_tensor from ptdbg_ascend.common.file_check_util import FileCheckException @@ -31,3 +32,13 @@ class TestUtilsMethods(unittest.TestCase): utils.check_file_size(file, 0) self.assertEqual(error.value.code, CompareException.INVALID_FILE_ERROR) + def test_is_md5_compare(self): + input_param = {"npu_pkl_path": "resources/compare/npu_test.pkl"} + result = is_md5_compare(input_param) + self.assertFalse(result) + + def test_get_md5_for_tensor(self): + data = [[1, 2], [3, 4]] + x_data = torch.tensor(data) + md5_value = get_md5_for_tensor(x_data) + self.assertEqual(md5_value, "b4ad64bc24f643726bddf5606af738da") -- Gitee