mindstudio-probe 8.3.3__py3-none-any.whl → 26.0.0a1__py3-none-any.whl

msprobe/pytorch/parse_tool/lib/compare.py

@@ -1,253 +0,0 @@
-# Copyright (c) 2024-2025, Huawei Technologies Co., Ltd.
-# All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0  (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import os
-import time
-from collections import namedtuple
-
-import numpy as np
-
-from msprobe.core.common.file_utils import create_directory, load_npy, save_npy_to_txt, write_csv, os_walk_for_files
-from msprobe.pytorch.parse_tool.lib.config import Const
-from msprobe.pytorch.parse_tool.lib.parse_exception import ParseException
-from msprobe.pytorch.parse_tool.lib.utils import Util
-
-
-class Compare:
-    def __init__(self):
-        self.util = Util()
-        self.log = self.util.log
-        self.vector_compare_result = {}
-
-    def npu_vs_npu_compare(self, my_dump_path, golden_dump_path, result_dir, msaccucmp_path):
-        self.log.info("Start Compare ...............")
-        self.compare_vector(my_dump_path, golden_dump_path, result_dir, msaccucmp_path)
-        self.log.info("Compare finished!!")
-
-    def compare_vector(self, my_dump_path, golden_dump_path, result_dir, msaccucmp_path):
-        create_directory(result_dir)
-        self.util.check_path_valid(result_dir)
-        call_msaccucmp = self.util.check_msaccucmp(msaccucmp_path)
-        cmd = '%s %s compare -m %s -g %s -out %s' % (
-            self.util.python, call_msaccucmp, my_dump_path, golden_dump_path, result_dir
-        )
-        return self.util.execute_command(cmd)
-
-    def convert_dump_to_npy(self, dump_file, data_format, output, msaccucmp_path):
-        dump_file = self.util.path_strip(dump_file)
-        file_name = ""
-        if os.path.isfile(dump_file):
-            self.log.info("Covert file is: %s" % dump_file)
-            file_name = os.path.basename(dump_file)
-        elif os.path.isdir(dump_file):
-            self.log.info("Convert all files in path: %s" % dump_file)
-            file_name = ""
-        output = output if output else Const.DUMP_CONVERT_DIR
-        convert = self.convert(dump_file, data_format, output, msaccucmp_path)
-        if convert == 0:
-            convert_files = self.util.list_convert_files(output, file_name)
-
-            summary_txt = ["SrcFile: %s" % dump_file]
-            for convert_file in convert_files.values():
-                summary_txt.append(" - %s" % convert_file.file_name)
-            self.log.info("Transfer result is saved in : %s" % os.path.realpath(output))
-            self.util.print_panel("\n".join(summary_txt))
-
-    def convert(self, dump_file, data_format, output, msaccucmp_path):
-        create_directory(output)
-        self.util.check_path_valid(output)
-        call_msaccucmp = self.util.check_msaccucmp(msaccucmp_path)
-        if data_format:
-            cmd = '%s %s convert -d %s -out %s -f %s' % (
-                self.util.python, call_msaccucmp, dump_file, output, data_format
-            )
-        else:
-            cmd = '%s %s convert -d %s -out %s' % (
-                self.util.python, call_msaccucmp, dump_file, output
-            )
-        return self.util.execute_command(cmd)
-
-    def compare_data(self, args):
-        """Compare data"""
-        (left, right, save_txt, rl, al, diff_count) = args
-        if left is None or right is None:
-            raise ParseException("invalid input or output")
-        if self.util.check_path_valid(left) and self.util.check_path_valid(right):
-            left_data = load_npy(left)
-            right_data = load_npy(right)
-        # save to txt
-        if save_txt:
-            save_npy_to_txt(left_data, left + ".txt")
-            save_npy_to_txt(right_data, right + ".txt")
-        # compare data
-        (total_cnt, all_close, cos_sim, err_percent) = self.do_compare_data(left_data, right_data, rl, al, diff_count)
-        content = ['Left:', ' ├─ NpyFile: %s' % left]
-        if save_txt:
-            content.append(' ├─ TxtFile: [green]%s.txt[/green]' % left)
-        content.append(' └─ NpySpec: [yellow]%s[/yellow]' % self.util.gen_npy_info_txt(left_data))
-        content.append('Right:')
-        content.append(' ├─ NpyFile: %s' % right)
-        if save_txt:
-            content.append(' ├─ TxtFile: [green]%s.txt[/green]' % right)
-        content.append(' └─ NpySpec: [yellow]%s[/yellow]' % self.util.gen_npy_info_txt(right_data))
-        content.append('NumCnt:   %s' % total_cnt)
-        content.append('AllClose: %s' % all_close)
-        content.append('CosSim:   %s' % cos_sim)
-        content.append('ErrorPer: %s  (rl= %s, al= %s)' % (err_percent, rl, al))
-        self.util.print_panel("\n".join(content))
-
-    def do_compare_data(self, left, right, rl=0.001, al=0.001, diff_count=20):
-        data_left = left.astype(np.float32)
-        data_right = right.astype(np.float32)
-        shape_left = data_left.shape
-        shape_right = data_right.shape
-        if shape_left != shape_right:
-            self.log.warning("Data shape not equal: %s vs %s" % (data_left.shape, data_right.shape))
-        data_left = data_left.reshape(-1)
-        data_right = data_right.reshape(-1)
-        if data_left.shape[0] != data_right.shape[0]:
-            self.log.warning("Data size not equal: %s vs %s" % (data_left.shape, data_right.shape))
-            if data_left.shape[0] < data_right.shape[0]:
-                data_left = np.pad(data_left, (0, data_right.shape[0] - data_left.shape[0]), 'constant')
-            else:
-                data_right = np.pad(data_right, (0, data_left.shape[0] - data_right.shape[0]), 'constant')
-        all_close = np.allclose(data_left, data_right, atol=al, rtol=rl)
-        np.seterr(divide='raise')
-        cos_sim = np.dot(data_left, data_right) / (
-                np.sqrt(np.dot(data_left, data_left)) * np.sqrt(np.dot(data_right, data_right)))
-        err_cnt = 0
-        total_cnt = data_left.shape[0]
-        diff_table_columns = ['Index', 'Left', 'Right', 'Diff']
-        err_table = self.util.create_table("Error Item Table", diff_table_columns)
-        top_table = self.util.create_table("Top Item Table", diff_table_columns)
-        for i in range(total_cnt):
-            abs_diff = abs(data_left[i] - data_right[i])
-            if i < diff_count:
-                top_table.add_row(str(i), str(data_left[i]), str(data_right[i]), str(abs_diff))
-            if abs_diff > (al + rl * abs(data_right[i])):
-                if err_cnt < diff_count:
-                    err_table.add_row(str(i), str(data_left[i]), str(data_right[i]), str(abs_diff))
-                err_cnt += 1
-        if total_cnt == 0:
-            err_percent = float(0)
-        else:
-            err_percent = float(err_cnt / total_cnt)
-        self.util.print(self.util.create_columns([err_table, top_table]))
-        do_compare_data_result = namedtuple('do_compare_data_result', ['cnt', 'close', 'cos', 'err'])
-        res = do_compare_data_result(total_cnt, all_close, cos_sim, err_percent)
-        return res
-
-    def compare_npy(self, file, bench_file, output_path):
-        if self.util.check_path_valid(file) and self.util.check_path_valid(bench_file):
-            data = load_npy(file)
-            bench_data = load_npy(bench_file)
-        shape, dtype = data.shape, data.dtype
-        bench_shape, bench_dtype = bench_data.shape, bench_data.dtype
-        filename = os.path.basename(file)
-        bench_filename = os.path.basename(bench_file)
-        if shape != bench_shape or dtype != bench_dtype:
-            self.log.error(
-                "Shape or dtype between two npy files is inconsistent. Please check the two files."
-                "File 1: %s, file 2: %s" % (file, bench_file))
-            self.util.deal_with_dir_or_file_inconsistency(output_path)
-            return
-        md5_consistency = False
-        if self.util.get_md5_for_numpy(data) == self.util.get_md5_for_numpy(bench_data):
-            md5_consistency = True
-        data_mean = np.mean(data)
-        bench_data_mean = np.mean(bench_data)
-        abs_error = np.abs(data - bench_data)
-        bench_data = self.util.deal_with_value_if_has_zero(bench_data)
-        rel_error = np.abs(abs_error / bench_data)
-        abs_diff_max = abs_error.max()
-        rel_diff_max = np.max(rel_error)
-        compare_result = [[filename, bench_filename, data_mean, bench_data_mean, md5_consistency, abs_diff_max,
-                           rel_diff_max]]
-        write_csv(compare_result, output_path)
-
-    def compare_all_file_in_directory(self, my_dump_dir, golden_dump_dir, output_path):
-        if not (self.util.is_subdir_count_equal(my_dump_dir, golden_dump_dir)
-                and self.util.check_npy_files_valid_in_dir(my_dump_dir)
-                and self.util.check_npy_files_valid_in_dir(golden_dump_dir)):
-            self.log.error(
-                "Top level(Npy files level) directory structure is inconsistent. Please check the two directory.")
-            self.util.deal_with_dir_or_file_inconsistency(output_path)
-            return
-        my_npy_files = self.util.get_sorted_files_names(my_dump_dir)
-        golden_npy_files = self.util.get_sorted_files_names(golden_dump_dir)
-        for my_npy_file_name, golden_npy_file_name in zip(my_npy_files, golden_npy_files):
-            my_npy_path = os.path.join(my_dump_dir, my_npy_file_name)
-            golden_npy_path = os.path.join(golden_dump_dir, golden_npy_file_name)
-            self.compare_npy(my_npy_path, golden_npy_path, output_path)
-
-    def compare_timestamp_directory(self, my_dump_dir, golden_dump_dir, output_path):
-        if not self.util.is_subdir_count_equal(my_dump_dir, golden_dump_dir):
-            self.log.error(
-                "Second level(Timestamp level) directory structure is inconsistent. Please check the two directory.")
-            self.util.deal_with_dir_or_file_inconsistency(output_path)
-            return
-        my_ordered_subdirs = self.util.get_sorted_subdirectories_names(my_dump_dir)
-        golden_ordered_subdirs = self.util.get_sorted_subdirectories_names(golden_dump_dir)
-        for my_subdir_name, golden_subdir_name in zip(my_ordered_subdirs, golden_ordered_subdirs):
-            my_subdir_path = os.path.join(my_dump_dir, my_subdir_name)
-            golden_subdir_path = os.path.join(golden_dump_dir, golden_subdir_name)
-            self.compare_all_file_in_directory(my_subdir_path, golden_subdir_path, output_path)
-
-    def compare_converted_dir(self, my_dump_dir, golden_dump_dir, output_dir):
-        if not self.util.is_subdir_count_equal(my_dump_dir, golden_dump_dir):
-            self.log.error(
-                "Top level(Opname level) directory structure is inconsistent. Please check the two directory.")
-            return
-        timestamp = int(time.time())
-        output_file_name = f"batch_compare_{timestamp}.csv"
-        output_path = os.path.join(output_dir, output_file_name)
-        title_rows = [[
-            "NPU File Name",
-            "Bench File Name",
-            "Mean",
-            "Bench Mean",
-            "Md5 Consistency",
-            "Max Abs Error",
-            "Max Relative Error"
-        ]]
-        write_csv(title_rows, output_path)
-
-        my_ordered_subdirs = self.util.get_sorted_subdirectories_names(my_dump_dir)
-        golden_ordered_subdirs = self.util.get_sorted_subdirectories_names(golden_dump_dir)
-        for my_subdir_name, golden_subdir_name in zip(my_ordered_subdirs, golden_ordered_subdirs):
-            if not my_subdir_name == golden_subdir_name:
-                self.log.error(
-                    "Top level(Opname level) directory structure is inconsistent. Please check the two directory.")
-                self.util.deal_with_dir_or_file_inconsistency(output_path)
-                return
-            my_subdir_path = os.path.join(my_dump_dir, my_subdir_name)
-            golden_subdir_path = os.path.join(golden_dump_dir, golden_subdir_name)
-            self.compare_timestamp_directory(my_subdir_path, golden_subdir_path, output_path)
-        self.util.change_filemode_safe(output_path)
-        self.log.info("Compare result is saved in : %s" % (output_path))
-
-    def convert_api_dir_to_npy(self, dump_dir, param, output_dir, msaccucmp_path):
-        dump_dir = self.util.path_strip(dump_dir)
-        files = os_walk_for_files(dump_dir, Const.MAX_TRAVERSAL_DEPTH)
-        filepaths = [os.path.join(file['root'], file['file']) for file in files]
-        for path in filepaths:
-            filename = os.path.basename(path)
-            parts = filename.split(".")
-            if len(parts) < 5:
-                continue
-            op_name = parts[1]
-            timestamp = parts[-1]
-            output_path = os.path.join(output_dir, op_name, timestamp)
-            self.convert_dump_to_npy(path, param, output_path, msaccucmp_path)

msprobe/pytorch/parse_tool/lib/config.py

@@ -1,50 +0,0 @@
-# Copyright (c) 2024-2025, Huawei Technologies Co., Ltd.
-# All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0  (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import os
-
-import numpy as np
-
-
-class Const:
-    MS_ACCU_CMP_PATH = '/usr/local/Ascend/ascend-toolkit/latest/tools/operator_cmp/compare/msaccucmp.py'
-    MS_ACCU_CMP_FILE_NAME = 'msaccucmp.py'
-    ROOT_DIR = ""
-    LOG_LEVEL = "NOTSET"
-    DATA_ROOT_DIR = os.path.join(ROOT_DIR, 'parse_data')
-    DUMP_CONVERT_DIR = os.path.join(DATA_ROOT_DIR, 'dump_convert')
-    COMPARE_DIR = os.path.join(DATA_ROOT_DIR, 'compare_result')
-    BATCH_DUMP_CONVERT_DIR = os.path.join(DATA_ROOT_DIR, 'batch_dump_convert')
-    BATCH_COMPARE_DIR = os.path.join(DATA_ROOT_DIR, 'batch_compare_result')
-    OFFLINE_DUMP_CONVERT_PATTERN = \
-        r"^([A-Za-z0-9_-]+)\.([A-Za-z0-9_-]+)\.([0-9]+)(\.[0-9]+)?\.([0-9]{1,255})" \
-        r"\.([a-z]+)\.([0-9]{1,255})(\.[x0-9]+)?\.npy$"
-    NUMPY_PATTERN = r"^[\w\-_.]+\.npy$"
-    NPY_SUFFIX = ".npy"
-    PKL_SUFFIX = ".pkl"
-    DIRECTORY_LENGTH = 4096
-    FILE_NAME_LENGTH = 255
-    MAX_TRAVERSAL_DEPTH = 5
-    FILE_PATTERN = r'^[a-zA-Z0-9_./-]+$'
-    ONE_GB = 1 * 1024 * 1024 * 1024
-    TEN_GB = 10 * 1024 * 1024 * 1024
-    FLOAT_TYPE = [np.half, np.single, float, np.double, np.float64, np.longdouble, np.float32, np.float16]
-    HEADER = r"""    ____
-       / __ \____ ______________
-      / /_/ / __ `/ ___/ ___/ _ \
-     / ____/ /_/ / /  (__  )  __/
-    /_/    \__,_/_/  /____/\___/
-
-    """

msprobe/pytorch/parse_tool/lib/file_desc.py

@@ -1,45 +0,0 @@
-# Copyright (c) 2024-2025, Huawei Technologies Co., Ltd.
-# All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0  (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import os
-
-
-class FileDesc(object):
-    def __init__(self, file_name, dir_path, timestamp=-1):
-        self.file_name = file_name
-        self.dir_path = dir_path
-        self.path = os.path.join(dir_path, file_name)
-        self.timestamp = timestamp
-        self.idx = 0
-        if self.timestamp == -1:
-            self.timestamp = os.path.getmtime(self.path)
-
-
-class NpuDumpFileDesc(FileDesc):
-    def __init__(self, file_name, dir_path, timestamp, op_name, op_type, task_id, stream_id=0):
-        super(NpuDumpFileDesc, self).__init__(file_name, dir_path, timestamp)
-        self.op_name = op_name
-        self.op_type = op_type
-        self.task_id = task_id
-        stream_id = 0 if stream_id is None else int(stream_id)
-        self.stream_id = stream_id
-        self.idx = dir_path.split(os.sep)[-1]
-
-
-class DumpDecodeFileDesc(NpuDumpFileDesc):
-    def __init__(self, file_name, dir_path, timestamp, op_name, op_type, task_id, anchor_type, anchor_idx):
-        super(DumpDecodeFileDesc, self).__init__(file_name, dir_path, timestamp, op_name, op_type, task_id)
-        self.type = anchor_type
-        self.idx = anchor_idx

msprobe/pytorch/parse_tool/lib/interactive_cli.py

@@ -1,97 +0,0 @@
-# Copyright (c) 2024-2025, Huawei Technologies Co., Ltd.
-# All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0  (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import argparse
-import cmd
-
-from msprobe.pytorch.parse_tool.lib.config import Const
-from msprobe.pytorch.parse_tool.lib.parse_exception import catch_exception
-from msprobe.pytorch.parse_tool.lib.parse_tool import ParseTool
-from msprobe.pytorch.parse_tool.lib.utils import Util
-
-
-class InteractiveCli(cmd.Cmd):
-    def __init__(self):
-        super().__init__()
-        self.prompt = "Parse >>> "
-        self.parse_tool = ParseTool()
-        self.util = Util()
-        self.util.print_panel(Const.HEADER)
-        self.prepare()
-
-    @staticmethod
-    def _parse_argv(line, insert=None):
-        argv = line.split() if line != "" else []
-        if "-h" in argv:
-            return argv
-        if insert is not None and len(argv) and argv[0] != insert:
-            argv.insert(0, insert)
-        return argv
-
-    def prepare(self):
-        self.parse_tool.prepare()
-
-    @catch_exception
-    def default(self, line=""):
-        self.stdout.write("Command invalid, Only support command start with cad/vc/dc/pk/cn/pt\n")
-
-    @catch_exception
-    def do_vc(self, line=""):
-        parser = argparse.ArgumentParser()
-        parser.add_argument(
-            "-m", "--my_dump_path", dest="my_dump_path", default=None,
-            help="<Required> my dump path, the data compared with golden data",
-            required=True
-        )
-        parser.add_argument(
-            "-g", "--golden_dump_path", dest="golden_dump_path", default=None,
-            help="<Required> the golden dump data path",
-            required=True
-        )
-        parser.add_argument(
-            "-out", "--output_path", dest="output_path", default=None,
-            help="<Optional> the output path",
-            required=False
-        )
-        parser.add_argument(
-            "-cmp_path", "--msaccucmp_path", dest="msaccucmp_path", default=None,
-            help="<Optional> the msaccucmp.py file path",
-            required=False
-        )
-        args = parser.parse_args(self._parse_argv(line))
-        self.util.check_path_valid(args.my_dump_path)
-        self.util.check_path_valid(args.golden_dump_path)
-        self.util.check_files_in_path(args.my_dump_path)
-        self.util.check_files_in_path(args.golden_dump_path)
-        if self.util.dir_contains_only(args.my_dump_path, ".npy") and \
-                self.util.dir_contains_only(args.golden_dump_path, ".npy"):
-            self.parse_tool.do_compare_converted_dir(args)
-        else:
-            self.parse_tool.do_vector_compare(args)
-
-    def do_dc(self, line=""):
-        self.parse_tool.do_convert_dump(self._parse_argv(line))
-
-    def do_pt(self, line=""):
-        self.parse_tool.do_print_data(self._parse_argv(line))
-
-    def do_pk(self, line=""):
-        self.parse_tool.do_parse_pkl(self._parse_argv(line))
-
-    def do_cn(self, line=''):
-        self.parse_tool.do_compare_data(self._parse_argv(line))
-
-    def do_cad(self, line=''):
-        self.parse_tool.do_convert_api_dir(self._parse_argv(line))

msprobe/pytorch/parse_tool/lib/parse_exception.py

@@ -1,54 +0,0 @@
-# Copyright (c) 2024-2025, Huawei Technologies Co., Ltd.
-# All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0  (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import logging
-
-from msprobe.core.common.exceptions import FileCheckException
-
-
-class ParseException(Exception):
-    PARSE_INVALID_PATH_ERROR = 0
-    PARSE_NO_FILE_ERROR = 1
-    PARSE_NO_MODULE_ERROR = 2
-    PARSE_INVALID_DATA_ERROR = 3
-    PARSE_INVALID_FILE_FORMAT_ERROR = 4
-    PARSE_UNICODE_ERROR = 5
-    PARSE_JSONDECODE_ERROR = 6
-    PARSE_MSACCUCMP_ERROR = 7
-    PARSE_LOAD_NPY_ERROR = 8
-    PARSE_INVALID_PARAM_ERROR = 9
-
-    def __init__(self, code, error_info=""):
-        super(ParseException, self).__init__()
-        self.error_info = error_info
-        self.code = code
-
-
-def catch_exception(func):
-    def inner(*args, **kwargs):
-        log = logging.getLogger()
-        line = args[-1] if len(args) == 2 else ""
-        result = None
-        try:
-            result = func(*args, **kwargs)
-        except OSError:
-            log.error("%s: command not found" % line)
-        except ParseException:
-            log.error("Command execution failed")
-        except FileCheckException:
-            log.error("Command execution failed")
-        return result
-
-    return inner

msprobe/pytorch/parse_tool/lib/parse_tool.py

@@ -1,161 +0,0 @@
-# Copyright (c) 2024-2025, Huawei Technologies Co., Ltd.
-# All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0  (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import argparse
-import os
-from collections import namedtuple
-
-from msprobe.core.common.file_utils import create_directory
-from msprobe.pytorch.parse_tool.lib.compare import Compare
-from msprobe.pytorch.parse_tool.lib.config import Const
-from msprobe.pytorch.parse_tool.lib.parse_exception import catch_exception, ParseException
-from msprobe.pytorch.parse_tool.lib.utils import Util
-from msprobe.pytorch.parse_tool.lib.visualization import Visualization
-
-
-class ParseTool:
-    def __init__(self):
-        self.util = Util()
-        self.compare = Compare()
-        self.visual = Visualization()
-
-    @catch_exception
-    def prepare(self):
-        create_directory(Const.DATA_ROOT_DIR)
-
-    @catch_exception
-    def do_vector_compare(self, args):
-        if not args.output_path:
-            result_dir = os.path.join(Const.COMPARE_DIR)
-        else:
-            result_dir = args.output_path
-        my_dump_path = args.my_dump_path
-        golden_dump_path = args.golden_dump_path
-        if not os.path.isdir(my_dump_path) or not os.path.isdir(golden_dump_path):
-            self.util.log.error("Please enter a directory not a file")
-            raise ParseException(ParseException.PARSE_INVALID_PATH_ERROR)
-        msaccucmp_path = self.util.path_strip(args.msaccucmp_path) if args.msaccucmp_path else Const.MS_ACCU_CMP_PATH
-        self.util.check_path_valid(msaccucmp_path)
-        self.util.check_executable_file(msaccucmp_path)
-        self.compare.npu_vs_npu_compare(my_dump_path, golden_dump_path, result_dir, msaccucmp_path)
-
-    @catch_exception
-    def do_convert_dump(self, argv=None):
-        parser = argparse.ArgumentParser()
-        parser.add_argument(
-            '-n', '--name', dest='path', default=None, required=True, help='dump file or dump file directory')
-        parser.add_argument(
-            '-f', '--format', dest='format', default=None, required=False, help='target format')
-        parser.add_argument(
-            '-out', '--output_path', dest='output_path', required=False, default=None, help='output path')
-        parser.add_argument(
-            "-cmp_path", "--msaccucmp_path", dest="msaccucmp_path", default=None,
-            help="<Optional> the msaccucmp.py file path", required=False)
-        args = parser.parse_args(argv)
-        self.util.check_path_valid(args.path)
-        self.util.check_files_in_path(args.path)
-        msaccucmp_path = self.util.path_strip(args.msaccucmp_path) if args.msaccucmp_path else Const.MS_ACCU_CMP_PATH
-        self.util.check_path_valid(msaccucmp_path)
-        self.util.check_executable_file(msaccucmp_path)
-        if args.format:
-            self.util.check_str_param(args.format)
-        self.compare.convert_dump_to_npy(args.path, args.format, args.output_path, msaccucmp_path)
-
-    @catch_exception
-    def do_print_data(self, argv=None):
-        """print tensor data"""
-        parser = argparse.ArgumentParser()
-        parser.add_argument('-n', '--name', dest='path', default=None, required=True, help='File name')
-        args = parser.parse_args(argv)
-        self.visual.print_npy_data(args.path)
-
-    @catch_exception
-    def do_parse_pkl(self, argv=None):
-        parser = argparse.ArgumentParser()
-        parser.add_argument(
-            '-f', '--file', dest='file_name', default=None, required=True, help='PKL file path')
-        parser.add_argument(
-            '-n', '--name', dest='api_name', default=None, required=True, help='API name')
-        args = parser.parse_args(argv)
-        self.visual.parse_pkl(args.file_name, args.api_name)
-
-    @catch_exception
-    def do_compare_data(self, argv):
-        """compare two tensor"""
-        parser = argparse.ArgumentParser()
-        parser.add_argument(
-            "-m", "--my_dump_path", dest="my_dump_path", default=None,
-            help="<Required> my dump path, the data compared with golden data",
-            required=True
-        )
-        parser.add_argument(
-            "-g", "--golden_dump_path", dest="golden_dump_path", default=None,
-            help="<Required> the golden dump data path",
-            required=True
-        )
-        parser.add_argument('-p', '--print', dest='count', default=20, type=int, help='print err data num')
-        parser.add_argument('-s', '--save', dest='save', action='store_true', help='save data in txt format')
-        parser.add_argument('-al', '--atol', dest='atol', default=0.001, type=float, help='set rtol')
-        parser.add_argument('-rl', '--rtol', dest='rtol', default=0.001, type=float, help='set atol')
-        args = parser.parse_args(argv)
-        self.util.check_positive(args.count)
-        self.util.check_positive(args.rtol)
-        self.util.check_positive(args.atol)
-        self.util.check_path_valid(args.my_dump_path)
-        self.util.check_path_valid(args.golden_dump_path)
-        self.util.check_file_path_format(args.my_dump_path, Const.NPY_SUFFIX)
-        self.util.check_file_path_format(args.golden_dump_path, Const.NPY_SUFFIX)
-        compare_data_args = namedtuple('compare_data_args',
-                                       ['my_dump_path', 'golden_dump_path', 'save', 'rtol', 'atol', 'count'])
-        compare_data_args.__new__.__defaults__ = (False, 0.001, 0.001, 20)
-        res = compare_data_args(args.my_dump_path, args.golden_dump_path, args.save, args.rtol, args.atol, args.count)
-        self.compare.compare_data(res)
-
-    @catch_exception
-    def do_compare_converted_dir(self, args):
-        """compare two dir"""
-        my_dump_dir = self.util.path_strip(args.my_dump_path)
-        golden_dump_dir = self.util.path_strip(args.golden_dump_path)
-        if my_dump_dir == golden_dump_dir:
-            self.util.log.error("My directory path and golden directory path is same. Please check parameter"
-                                " '-m' and '-g'.")
-            raise ParseException("My directory path and golden directory path is same.")
-        output_path = self.util.path_strip(args.output_path) if args.output_path else Const.BATCH_COMPARE_DIR
-        create_directory(output_path)
-        self.compare.compare_converted_dir(my_dump_dir, golden_dump_dir, output_path)
-
-    @catch_exception
-    def do_convert_api_dir(self, argv=None):
-        parser = argparse.ArgumentParser()
-        parser.add_argument(
-            "-m", "--my_dump_path", dest="my_dump_path", default=None,
-            help="<Required> my dump path, the data need to convert to npy files.",
-            required=True
-        )
-        parser.add_argument(
-            '-out', '--output_path', dest='output_path', required=False, default=None, help='output path')
-        parser.add_argument(
-            "-asc", "--msaccucmp_path", dest="msaccucmp_path", default=None,
-            help="<Optional> the msaccucmp.py file path", required=False)
-        args = parser.parse_args(argv)
-        self.util.check_path_valid(args.my_dump_path)
-        self.util.check_files_in_path(args.my_dump_path)
-        output_path = self.util.path_strip(args.output_path) if args.output_path else \
-            os.path.join(Const.BATCH_DUMP_CONVERT_DIR, self.util.localtime_str())
-        msaccucmp_path = self.util.path_strip(
-            args.msaccucmp_path) if args.msaccucmp_path else Const.MS_ACCU_CMP_PATH
-        self.util.check_path_valid(msaccucmp_path)
-        self.util.check_executable_file(msaccucmp_path)
-        self.compare.convert_api_dir_to_npy(args.my_dump_path, None, output_path, msaccucmp_path)