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

msprobe/msaccucmp/vector_cmp/batch_compare.py

@@ -0,0 +1,197 @@
+# coding=utf-8
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
+#
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#          http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
+
+"""
+Function:
+This file mainly involves xxxx function.
+"""
+import os
+import re
+import time
+
+from msprobe.msaccucmp.cmp_utils import log
+from msprobe.msaccucmp.cmp_utils.file_utils import FileUtils
+from msprobe.msaccucmp.cmp_utils import path_check as path_utils
+from msprobe.msaccucmp.cmp_utils.constant.const_manager import ConstManager
+from msprobe.msaccucmp.cmp_utils.constant.compare_error import CompareError
+from msprobe.msaccucmp.compare_vector import VectorComparison
+from msprobe.msaccucmp.vector_cmp.fusion_manager.fusion_rule_parser import FusionRuleParser
+
+
+class BatchCompare:
+    """
+    The class for batch compare
+    """
+    DUMP_FILE_PATH_FORMAT = "dump_path/time/device_id/model_name/model_id/dump_step/dump_file"
+
+    def __init__(self: any) -> None:
+        self.model_name_to_json_map = {}
+        self.json_path_to_dump_path_map = {}
+
+    @staticmethod
+    def _check_path_valid(path: str) -> None:
+        ret = path_utils.check_path_valid(path, True, False, path_utils.PathType.Directory)
+        if ret != CompareError.MSACCUCMP_NONE_ERROR:
+            raise CompareError(ret)
+
+    def check_fusion_rule_json_dir(self: any, fusion_rule_json_dir: str) -> bool:
+        """
+        Check fusion rule is dir or not
+        :param fusion_rule_json_dir: the path for fusion rule json
+        :return:bool
+        """
+        fusion_rule_path = os.path.realpath(fusion_rule_json_dir)
+        if os.path.isfile(fusion_rule_path):
+            return False
+        self._check_path_valid(fusion_rule_json_dir)
+        return True
+
+    def check_argument_valid(self: any, arguments: any) -> None:
+        """
+        Check argument valid
+        """
+        if arguments.op_name:
+            log.print_error_log(
+                "the {} single operator comparison is not supported for batch network comparison.".format(
+                    arguments.op_name))
+            raise CompareError(CompareError.MSACCUCMP_INVALID_PARAM_ERROR)
+
+        npu_dump_path = os.path.realpath(arguments.my_dump_path)
+        self._check_path_valid(npu_dump_path)
+        # check whether the path ends with a timestamp.
+        path = os.path.split(npu_dump_path)
+        # path[1]:last level directory
+        if not path[1].isdigit():
+            log.print_error_log("The {} path must end with a timestamp.".format(npu_dump_path))
+            raise CompareError(CompareError.MSACCUCMP_INVALID_PATH_ERROR)
+
+    def compare(self: any, arguments: any) -> int:
+        """
+        Compare the entire network in batches
+        :param arguments: the command parameters
+        :return: the compare finish status code
+        """
+        self.check_argument_valid(arguments)
+        self._make_model_name_to_json_map(os.path.realpath(arguments.fusion_rule_file))
+        self._make_json_path_to_dump_path_map(os.path.realpath(arguments.my_dump_path))
+        return self._execute_batch_compare(arguments)
+
+    def _make_model_name_to_json_map(self: any, json_dir_path: str) -> None:
+        for json_file_name in os.listdir(json_dir_path):
+            json_file_path = os.path.join(json_dir_path, json_file_name)
+            if json_file_path.endswith(".json"):
+                self._parse_json_file(json_file_path)
+
+        if not self.model_name_to_json_map:
+            log.print_error_log('There is no fusion rule json file in "%r".' % json_dir_path)
+            raise CompareError(CompareError.MSACCUCMP_INVALID_PATH_ERROR)
+
+    def _parse_json_file(self: any, json_file_path: str) -> None:
+        fusion_rule_parse = FusionRuleParser(json_file_path)
+        json_object = FileUtils.load_json_file(json_file_path)
+        fusion_rule_parse.check_array_object_valid(json_object, ConstManager.GRAPH_OBJECT)
+        for graph in json_object[ConstManager.GRAPH_OBJECT]:
+            fusion_rule_parse.check_string_object_valid(graph, ConstManager.NAME_OBJECT)
+            model_name = graph[ConstManager.NAME_OBJECT]
+            self.model_name_to_json_map[model_name] = json_file_path
+
+    def _make_map_for_inconsistent_timestamp(self: any, graph_name: str, dump_file_path_map: dict,
+                                             npu_dump_dir: str) -> None:
+        # 1.get the number list from graph name.
+        # graph_name:'ge_default_20210420113943_73',graph_name_number_list:['20210420113943', '73'].
+        graph_name_number_list = re.findall(r"\d+", graph_name)
+        for _, model_name in enumerate(dump_file_path_map):
+            # 1.get the number list from model name.for example:
+            # model_name:'ge_default_20210420113944_73',model_name_number_list:['20210420113944', '73'].
+            model_name_number_list = re.findall(r"\d+", model_name)
+            # check graph_name and model_name inconsistent timestamps
+            if len(graph_name_number_list) != 2 or len(graph_name_number_list) != len(model_name_number_list):
+                log.print_npu_path_valid_message(npu_dump_dir, self.DUMP_FILE_PATH_FORMAT)
+                raise CompareError(CompareError.MSACCUCMP_INVALID_PATH_ERROR)
+            if graph_name_number_list[1] == model_name_number_list[1]:
+                dump_file_path = dump_file_path_map.get(model_name)
+                log.print_warn_log(
+                    "The {0} and in {1} dump data are not generated at the same time. "
+                    "The result may be incorrect.".format(graph_name, ",".join(dump_file_path)))
+                self.json_path_to_dump_path_map[self.model_name_to_json_map.get(graph_name)] = dump_file_path
+
+    def _make_json_path_to_dump_path_map(self: any, npu_dump_dir: str) -> None:
+        dump_file_path_map = self._get_npu_dump_file_map(npu_dump_dir)
+        graph_name_list = self.model_name_to_json_map.keys()
+        for graph_name in graph_name_list:
+            dump_file_path = dump_file_path_map.get(graph_name)
+            if dump_file_path:
+                self.json_path_to_dump_path_map[self.model_name_to_json_map.get(graph_name)] = dump_file_path
+            else:
+                self._make_map_for_inconsistent_timestamp(graph_name, dump_file_path_map, npu_dump_dir)
+
+        if not self.json_path_to_dump_path_map:
+            log.print_error_log("The {} not match fusion rule file".format(npu_dump_dir))
+            raise CompareError(CompareError.MSACCUCMP_INVALID_PATH_ERROR)
+
+    def _execute_batch_compare(self: any, arguments: any) -> int:
+        if os.path.islink(os.path.abspath(arguments.output_path)):
+            log.print_error_log('The path "%r" is a softlink, not permitted.' % arguments.output_path)
+            raise CompareError(CompareError.MSACCUCMP_INVALID_PATH_ERROR)
+        output_path = os.path.realpath(arguments.output_path)
+        my_dump_path = os.path.realpath(arguments.my_dump_path)
+        ret = CompareError.MSACCUCMP_NONE_ERROR
+        for key, value in self.json_path_to_dump_path_map.items():
+            for dump_path in value:
+                path_data = dump_path.replace(my_dump_path, "").split("/")
+                # remove model_id from path_data,path_data:['0', 'ge_default_20210420113943_71', '10', '1']
+                model_id_index = len(path_data) - 2
+                path_data.pop(model_id_index)
+                if "" in path_data:
+                    path_data.remove("")
+                result_csv = 'result_%s.csv' % time.strftime("%Y%m%d%H%M%S", time.localtime(time.time()))
+                # generate result file,for example:'0_ge_default_20210420113943_71_1_result_20210715022552.csv'
+                file_name = "".join(["_".join(path_data), "_", result_csv])
+                arguments.my_dump_path = dump_path
+                arguments.fusion_rule_file = key
+                compare = VectorComparison(arguments)
+                compare.set_output_path(os.path.join(output_path, file_name))
+                ret = compare.compare()
+        return ret
+
+    def _get_npu_dump_file_map_by_model_id(self: any, model_name_dir: str, dump_file_path_map: dict) -> None:
+        for model_id in os.listdir(model_name_dir):
+            model_id_dir = os.path.join(model_name_dir, model_id)
+            self._check_path_valid(model_id_dir)
+            model_id_list = os.listdir(model_id_dir)
+            model_name = os.path.basename(model_name_dir)
+            if len(model_id_list) != 0:
+                step = max(model_id_list) if len(model_id_list) > 1 else model_id_list[0]
+                dump_step_path = os.path.join(model_id_dir, step)
+                if dump_file_path_map.get(model_name):
+                    dump_file_path_map.get(model_name).append(dump_step_path)
+                else:
+                    dump_file_path_map[model_name] = [dump_step_path]
+
+    def _get_npu_dump_file_map(self: any, npu_dump_dir: str) -> dict:
+        dump_file_path_map = {}
+        for device_id in os.listdir(npu_dump_dir):
+            device_id_dir = os.path.join(npu_dump_dir, device_id)
+            self._check_path_valid(device_id_dir)
+            for model_name in os.listdir(device_id_dir):
+                model_name_dir = os.path.join(device_id_dir, model_name)
+                self._check_path_valid(model_name_dir)
+                self._get_npu_dump_file_map_by_model_id(model_name_dir, dump_file_path_map)
+        if not dump_file_path_map:
+            log.print_npu_path_valid_message(npu_dump_dir, self.DUMP_FILE_PATH_FORMAT)
+            raise CompareError(CompareError.MSACCUCMP_INVALID_PATH_ERROR)
+        return dump_file_path_map

msprobe/msaccucmp/vector_cmp/compare_detail/__init__.py

@@ -0,0 +1,16 @@
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
+#
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#          http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
+

msprobe/msaccucmp/vector_cmp/compare_detail/compare_detail.py

@@ -0,0 +1,245 @@
+# coding=utf-8
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
+#
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#          http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
+
+"""
+Function:
+DetailComparison class. This class mainly involves the compare function.
+"""
+
+import os
+
+from msprobe.msaccucmp.vector_cmp.fusion_manager import fusion_rule_parser
+from msprobe.msaccucmp.cmp_utils import utils, utils_type, path_check
+from msprobe.msaccucmp.cmp_utils import log
+from msprobe.msaccucmp.cmp_utils.constant.compare_error import CompareError
+from msprobe.msaccucmp.cmp_utils.constant.const_manager import ConstManager
+from msprobe.msaccucmp.dump_parse import dump, mapping
+from msprobe.msaccucmp.vector_cmp.compare_detail.detail_writer import DetailWriter
+from msprobe.msaccucmp.vector_cmp.compare_detail.detail import DetailInfo
+from msprobe.msaccucmp.vector_cmp.fusion_manager.compare_fusion_op import FusionOpComparison
+from msprobe.msaccucmp.conversion.tensor_conversion import TensorConversion
+
+
+class DetailComparison:
+    """
+    The class for fusion op compare
+    """
+
+    def __init__(self: any, detail_info: DetailInfo, fusion_op_comparison: FusionOpComparison,
+                 output_path: str) -> None:
+        self.detail_info = detail_info
+        self.fusion_op_comparison = fusion_op_comparison
+        self.detail_writer = DetailWriter(output_path, detail_info)
+        self.fusion_op = None
+
+    def check_index_valid(self: any, my_output_data: any) -> None:
+        """
+        Check index valid
+        :param my_output_data: my output data
+        """
+        if self.detail_info.tensor_id.is_input():
+            count = len(my_output_data.input_data)
+        else:
+            count = len(my_output_data.output_data)
+        if self.detail_info.tensor_id.index >= count:
+            log.print_out_of_range_error(self.fusion_op.op_name, self.detail_info.tensor_id.tensor_type,
+                                         self.detail_info.tensor_id.index, '[0, %d)' % count)
+            raise CompareError(CompareError.MSACCUCMP_INDEX_OUT_OF_BOUNDS_ERROR)
+
+    def compare(self: any) -> int:
+        """
+        Compare detail by op name
+        :return error_code
+        """
+        tensor_id = self.detail_info.tensor_id.get_tensor_id()
+        log.print_info_log('[%s] Start to compare detail for %s.'
+                           % (self.detail_info.tensor_id.op_name, tensor_id))
+        # get fusion op list by op name
+        tensor_list, dump_file_name = self._get_my_output_tensor_list()
+
+        # delete old result
+        try:
+            self.detail_writer.delete_old_detail_result_files()
+        except (OSError, SystemError, ValueError, TypeError, RuntimeError,
+                MemoryError, KeyError, IOError) as error:
+            log.print_error_log('Failed to delete the old detail result file. %s' % error)
+            raise CompareError(CompareError.MSACCUCMP_DELETE_FILE_ERROR) from error
+
+        # get right dump data by original op name and index
+        try:
+            ground_truth_tensor = \
+                self.fusion_op_comparison.get_right_dump_data(
+                    self.fusion_op, self.detail_info.tensor_id.index, self.detail_info.tensor_id.is_input())
+        except CompareError as compare_error:
+            if compare_error.code == CompareError.MSACCUCMP_NO_DUMP_FILE_ERROR:
+                log.print_no_right_dump_file_error(self.fusion_op.op_name, tensor_id, is_error=True)
+            raise compare_error
+
+        # get format by right output info
+        self.detail_info.set_detail_format(utils.convert_shape_to_string(
+            tensor_list[self.detail_info.tensor_id.index].shape),
+            tensor_list[self.detail_info.tensor_id.index].tensor_format,
+            ground_truth_tensor.tensor_format
+        )
+        # deserialize output data to array
+        tensor_conversion = TensorConversion(self.fusion_op, self.fusion_op_comparison.format_manager,
+                                             is_detail=True)
+        my_output_array, ground_truth_array, my_output_shape = \
+            tensor_conversion.get_my_output_and_ground_truth_data(
+                self.fusion_op_comparison.compare_data, tensor_list[self.detail_info.tensor_id.index],
+                ground_truth_tensor)
+        self.detail_writer.write(my_output_shape, my_output_array, ground_truth_array, dump_file_name)
+        return CompareError.MSACCUCMP_NONE_ERROR
+
+    def _print_l1_fusion_warning(self: any) -> None:
+        timestamp_list = self.fusion_op_comparison.sort_l1_fusion_dump_file()
+        max_timestamp_op_name = timestamp_list[-1][ConstManager.FUSION_OP_INDEX].op_name
+        if self.fusion_op.op_name != max_timestamp_op_name:
+            log.print_warn_log(
+                'The dump data of %s is incomplete, the comparison may be far away. '
+                'The dump data of %s may be complete, It is best to use %s for comparison.'
+                % (self.fusion_op.op_name, max_timestamp_op_name, max_timestamp_op_name))
+
+    def _get_my_output_tensor_by_op(self: any, relation: int) -> any:
+        my_output_data_path, my_output_data = \
+            self.fusion_op_comparison.compare_data.get_left_dump_data(self.fusion_op.op_name)
+        dump_file = os.path.basename(my_output_data_path)
+        self.check_index_valid(my_output_data)
+        if self.detail_info.tensor_id.is_input():
+            tensor_list = my_output_data.input_data
+        else:
+            if relation == utils_type.FusionRelation.L1Fusion:
+                self._print_l1_fusion_warning()
+            tensor_list = my_output_data.output_data
+        return tensor_list, dump_file
+
+    def _get_my_output_tensor_list(self: any) -> list:
+        self.fusion_op, fusion_op_list = self.detail_info.get_detail_op(
+            self.fusion_op_comparison.compare_rule.fusion_info)
+        if self.fusion_op.is_inner_node():
+            log.print_skip_inner_op_msg(self.fusion_op.op_name, is_error=True)
+            raise CompareError(CompareError.MSACCUCMP_UNSUPPORTED_COMPARE_ERROR)
+        if self.fusion_op.attr.quant_filter:
+            log.print_error_log("[{}] The -op param should not specify an operator in quant/dequant pair."
+                                .format(self.fusion_op.op_name))
+            raise CompareError(CompareError.MSACCUCMP_UNSUPPORTED_COMPARE_ERROR)
+        relation = fusion_rule_parser.get_relation_for_fusion(fusion_op_list)
+        try:
+            tensor_list, dumpfile = self._get_my_output_tensor_by_op(relation)
+        except CompareError as compare_error:
+            if compare_error.code == CompareError.MSACCUCMP_NO_DUMP_FILE_ERROR:
+                log.print_no_left_dump_file_error(self.fusion_op.op_name, self.fusion_op.op_type, True)
+            raise compare_error
+        finally:
+            pass
+        return tensor_list, dumpfile
+
+
+class DumpDetailComparison:
+    """
+    The class for Npu dump op compare
+    """
+
+    def __init__(self: any, detail_info: DetailInfo, compare_data: dump.CompareData,
+                 output_path: str) -> None:
+        self.detail_info = detail_info
+        self.compare_data = compare_data
+        self.detail_writer = DetailWriter(output_path, detail_info)
+        self.fusion_op = None
+
+    @staticmethod
+    def _check_index_valid(tensor_data, op_name, tensor_index, tensor_type):
+        if tensor_index >= len(tensor_data):
+            log.print_out_of_range_error(op_name, tensor_type, tensor_index, '[0, %d)' % len(tensor_data))
+            raise CompareError(CompareError.MSACCUCMP_INDEX_OUT_OF_BOUNDS_ERROR)
+
+    def compare(self: any) -> int:
+        """
+        Compare detail by op name
+        :return error_code
+        """
+        tensor_id = self.detail_info.tensor_id.get_tensor_id()
+        op_name = self.detail_info.tensor_id.op_name
+        tensor_type = self.detail_info.tensor_id.tensor_type
+        tensor_index = self.detail_info.tensor_id.index
+        log.print_info_log('[%s] Start to compare detail for %s.'
+                           % (op_name, tensor_id))
+
+        left_path, left_tensor_data, right_tensor_data = self.get_tensor_data(op_name, tensor_type)
+
+        self._check_index_valid(left_tensor_data, op_name, tensor_index, tensor_type)
+        self._check_index_valid(right_tensor_data, op_name, tensor_index, tensor_type)
+
+        my_output_shape = tuple(left_tensor_data[tensor_index].shape)
+        ground_truth_shape = tuple(right_tensor_data[tensor_index].shape)
+        if my_output_shape != ground_truth_shape:
+            log.print_error_log("My Output data shape %s not equal to Ground Truth data shape %s."
+                                "Can not compare." % (my_output_shape, ground_truth_shape))
+            raise CompareError(CompareError.MSACCUCMP_INVALID_DUMP_DATA_ERROR)
+
+        my_output_array = left_tensor_data[tensor_index].data
+        ground_truth_array = right_tensor_data[tensor_index].data
+
+        self.detail_info.set_detail_ops(op_name, op_name)
+        self.detail_info.check_and_set_format(utils.convert_shape_to_string(
+            left_tensor_data[tensor_index].shape),
+            left_tensor_data[tensor_index].tensor_format,
+            right_tensor_data[tensor_index].tensor_format
+        )
+
+        # delete old result
+        try:
+            self.detail_writer.delete_old_detail_result_files()
+        except (OSError, SystemError, ValueError, TypeError, RuntimeError,
+                MemoryError, KeyError, IOError) as error:
+            log.print_error_log('Failed to delete the old detail result file. %s' % error)
+            raise CompareError(CompareError.MSACCUCMP_DELETE_FILE_ERROR) from error
+
+        dump_file = os.path.basename(left_path)
+        self.detail_writer.write(my_output_shape, my_output_array, ground_truth_array, dump_file)
+        return CompareError.MSACCUCMP_NONE_ERROR
+
+    def get_tensor_data(self, op_name, tensor_type):
+        """
+        Get tensor form dump data
+        :return left_path
+        :return left_tensor_data
+        :return right_tensor_data
+        """
+        try:
+            left_path, left_data = self.compare_data.get_left_dump_data(op_name)
+        except CompareError as compare_error:
+            log.print_error_log('Failed to find %s dump data from -m dump data path.' % op_name)
+            raise compare_error
+        finally:
+            pass
+        try:
+            right_path, right_data = self.compare_data.get_right_dump_data(op_name)
+        except CompareError as compare_error:
+            log.print_error_log('Failed to find %s dump data from -g dump data path.' % op_name)
+            raise compare_error
+        finally:
+            pass
+        log.print_info_log("My Output data path: " + left_path)
+        log.print_info_log("Ground Truth data path: " + right_path)
+        if tensor_type == ConstManager.INPUT:
+            left_tensor_data = left_data.input_data
+            right_tensor_data = right_data.input_data
+        else:
+            left_tensor_data = left_data.output_data
+            right_tensor_data = right_data.output_data
+        return left_path, left_tensor_data, right_tensor_data

msprobe/msaccucmp/vector_cmp/compare_detail/detail.py

@@ -0,0 +1,182 @@
+# coding=utf-8
+# -------------------------------------------------------------------------
+#  This file is part of the MindStudio project.
+# Copyright (c) 2025 Huawei Technologies Co.,Ltd.
+#
+# MindStudio is licensed under Mulan PSL v2.
+# You can use this software according to the terms and conditions of the Mulan PSL v2.
+# You may obtain a copy of Mulan PSL v2 at:
+#
+#          http://license.coscl.org.cn/MulanPSL2
+#
+# THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+# EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+# MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+# See the Mulan PSL v2 for more details.
+# -------------------------------------------------------------------------
+
+"""
+Function:
+This file mainly involves the common function.
+"""
+
+from msprobe.msaccucmp.cmp_utils import common
+from msprobe.msaccucmp.cmp_utils import log
+from msprobe.msaccucmp.cmp_utils.constant.const_manager import ConstManager, DD
+from msprobe.msaccucmp.cmp_utils.constant.compare_error import CompareError
+from msprobe.msaccucmp.cmp_utils.reg_manager import RegManager
+from msprobe.msaccucmp.cmp_utils.path_check import check_name_valid
+from msprobe.msaccucmp.vector_cmp.fusion_manager.fusion_op import FusionOp
+from msprobe.msaccucmp.vector_cmp.fusion_manager.fusion_rule_parser import FusionRuleParser
+from msprobe.msaccucmp.vector_cmp.fusion_manager import fusion_rule_parser
+
+
+class TensorId:
+    """
+    The class for tensor id
+    """
+
+    def __init__(self: any, op_name: str, tensor_type: str, index: str) -> None:
+        self.op_name = op_name
+        self.tensor_type = tensor_type
+        if not RegManager.match_pattern(RegManager.NUMBER_PATTERN, index):
+            log.print_only_support_error('detail index', index, 'natural number')
+            raise CompareError(CompareError.MSACCUCMP_INVALID_PARAM_ERROR)
+        self.index = int(index)
+
+    def check_arguments_valid(self: any) -> None:
+        """
+        check arguments valid, if invalid, throw exception
+        """
+        ret = check_name_valid(self.op_name)
+        if ret != CompareError.MSACCUCMP_NONE_ERROR:
+            raise CompareError(ret)
+        if self.tensor_type not in ConstManager.SUPPORT_DETAIL_TYPE:
+            log.print_only_support_error('detail type', self.tensor_type,
+                                         ConstManager.SUPPORT_DETAIL_TYPE)
+            raise CompareError(CompareError.MSACCUCMP_INVALID_PARAM_ERROR)
+
+    def get_tensor_id(self: any) -> str:
+        """
+        Get tensor id
+        """
+        return "%s:%s:%d" % (self.op_name, self.tensor_type, self.index)
+
+    def is_input(self: any) -> bool:
+        """
+        is input
+        :return: true if input
+        """
+        return self.tensor_type == ConstManager.INPUT
+
+    def get_file_prefix(self: any) -> str:
+        """
+        Get detail file name prefix
+        :return str
+        """
+        return "%s_%s_%d" % (self.op_name.replace('/', '_'), self.tensor_type, self.index)
+
+    def get_tensor_type_index(self: any) -> str:
+        """
+        Get detail file name prefix, like _input_0
+        :return str
+        """
+        return "_%s_%d" % (self.tensor_type, self.index)
+
+
+class DetailInfo:
+    """
+    The class for detail info
+    """
+
+    def __init__(self: any, tensor_id: TensorId, top_n: int, ignore_result: bool, max_line: int) -> None:
+        self.tensor_id = tensor_id
+        self.my_output_ops = ''
+        self.ground_truth_ops = ''
+        self.detail_format = ''
+        self.top_n = top_n
+        self.ignore_result = ignore_result
+        self.max_line = max_line
+
+    def check_arguments_valid(self: any) -> None:
+        """
+        check arguments valid, if invalid, throw exception
+        """
+        self.tensor_id.check_arguments_valid()
+        const_manager = ConstManager()
+        if self.top_n < const_manager.min_top_n or self.top_n > const_manager.max_top_n:
+            log.print_out_of_range_error('', 'top n', self.top_n,
+                                         '[%d, %d]' % (const_manager.min_top_n, const_manager.max_top_n))
+            raise CompareError(CompareError.MSACCUCMP_INDEX_OUT_OF_BOUNDS_ERROR)
+
+    def get_detail_op(self: any, fusion_rule: FusionRuleParser) -> (FusionOp, list):
+        """
+        Get detail op by fusion rule
+        :param: fusion_rule: the fusion rule
+        :return: the fusion op, the fusion op list
+        """
+        fusion_op_list, fusion_op = fusion_rule.get_fusion_op_list(self.tensor_id.op_name)
+        # get the map for {original_op_names, op_list}
+        right_to_left_map = fusion_rule_parser.make_right_to_left_multi_map(
+            fusion_op_list)
+        my_output_ops_str, ground_truth_ops_str = fusion_rule_parser.make_left_and_right_string(right_to_left_map)
+        # if right ops is empty, mark '*' indicates that the left op is a
+        # new operator, and there is no operator on the right that matches it
+        if ground_truth_ops_str == "":
+            ground_truth_ops_str = '*'
+        self.my_output_ops = my_output_ops_str.replace(',', ' ')
+        self.ground_truth_ops = ground_truth_ops_str.replace(',', ' ')
+        return fusion_op, fusion_op_list
+
+    def set_detail_format(self: any, shape_str: str, tensor_format: int, ground_truth_format: str) -> None:
+        """
+        Set detail format by shape
+        :param shape_str: the shape string
+        :param tensor_format: tensor format
+        :param ground_truth_format: ground truth format
+        """
+        if common.contain_depth_dimension(tensor_format):
+            self.detail_format = 'N C D H W'
+        else:
+            if tensor_format == DD.FORMAT_FRACTAL_Z:
+                self.detail_format = ' '.join(ground_truth_format)
+            else:
+                self.detail_format = "N C H W" if shape_str != "()" else "ID"
+
+    def check_and_set_format(self: any, shape_str: str, tensor_format: int, ground_truth_format: int) -> None:
+        """
+        Check and Set detail format by shape
+        :param shape_str: the shape string
+        :param tensor_format: tensor format
+        :param ground_truth_format: ground truth format
+        """
+        if tensor_format != ground_truth_format:
+            log.print_error_log("NPUDump tensor format not match Ground truth tensor format!"
+                                "Cannot be directly compared.")
+            raise CompareError(CompareError.MSACCUCMP_INVALID_FORMAT_ERROR)
+        if common.contain_depth_dimension(tensor_format):
+            self.detail_format = 'N C D H W'
+        else:
+            self.detail_format = "N C H W" if shape_str != "()" else "ID"
+
+    def set_detail_ops(self: any, my_out_ops: str, ground_truth_ops: str) -> None:
+        """
+        Check and Set detail format by shape
+        :param my_out_ops: the opname of my out tensor
+        :param ground_truth_ops: the opname of ground truth tensor
+        """
+        self.my_output_ops = my_out_ops.replace(',', ' ')
+        self.ground_truth_ops = ground_truth_ops.replace(',', ' ')
+
+    def make_detail_header(self: any) -> str:
+        """
+        Make detail header
+        """
+        return "Index,%s,NPUDump,GroundTruth,AbsoluteError,RelativeError\n" % self.detail_format
+
+    def get_detail_info(self: any) -> str:
+        """
+        Get detail_info
+        """
+        return "NPUDump:%s\nGroundTruth:%s\nFormat:%s\n" % (self.my_output_ops, self.ground_truth_ops,
+                                                            self.detail_format)