mindstudio-probe 1.0.4__py3-none-any.whl → 1.1.1__py3-none-any.whl

msprobe/visualization/graph/node_colors.py

@@ -0,0 +1,95 @@
+# Copyright (c) 2024-2024, 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.
+
+from enum import Enum
+from msprobe.visualization.utils import GraphConst, ToolTip
+
+SUMMARY_DESCRIPTION = "此节点所有输入输出的统计量相对误差, 值越大代表测量值与标杆值的偏差越大, 相对误差计算方式:|(测量值-标杆值)/标杆值|"
+REAL_DATA_DESCRIPTION = (f"此节点所有输入的最小双千分之一和所有输出的最小双千分之一的差值的绝对值, 代表双千指标的变化情况, "
+                         f"值越大代表测量值与标杆值的偏差越大, 双千分之一指标计算方式：{ToolTip.ONE_THOUSANDTH_ERR_RATIO}")
+MD5_DESCRIPTION_N = "与标杆相比, 此节点任意输入输出的md5值不同"
+MD5_DESCRIPTION_Y = "与标杆相比, 此节点所有输入输出的md5值相同"
+NOT_MATCHED = "比对过程中节点未匹配上"
+
+
+class NodeColors(Enum):
+    # 枚举值后缀数字越小, 颜色越浅
+    # value值左闭右开, 两个值相同代表固定值
+    YELLOW_1 = ("#FFFCF3", {
+        GraphConst.SUMMARY_COMPARE: {GraphConst.VALUE: [0, 0.2], GraphConst.DESCRIPTION: SUMMARY_DESCRIPTION},
+        GraphConst.REAL_DATA_COMPARE: {GraphConst.VALUE: [0, 0.05], GraphConst.DESCRIPTION: REAL_DATA_DESCRIPTION},
+        GraphConst.MD5_COMPARE: {GraphConst.VALUE: [1, 1], GraphConst.DESCRIPTION: MD5_DESCRIPTION_Y},
+    })
+    YELLOW_2 = ("#FFEDBE", {
+        GraphConst.SUMMARY_COMPARE: {GraphConst.VALUE: [0.2, 0.4], GraphConst.DESCRIPTION: SUMMARY_DESCRIPTION},
+        GraphConst.REAL_DATA_COMPARE: {GraphConst.VALUE: [0.05, 0.1], GraphConst.DESCRIPTION: REAL_DATA_DESCRIPTION}
+    })
+    ORANGE_1 = ("#FFDC7F", {
+        GraphConst.SUMMARY_COMPARE: {GraphConst.VALUE: [0.4, 0.6], GraphConst.DESCRIPTION: SUMMARY_DESCRIPTION},
+        GraphConst.REAL_DATA_COMPARE: {GraphConst.VALUE: [0.1, 0.15], GraphConst.DESCRIPTION: REAL_DATA_DESCRIPTION}
+    })
+    ORANGE_2 = ("#FFC62E", {
+        GraphConst.SUMMARY_COMPARE: {GraphConst.VALUE: [0.6, 0.8], GraphConst.DESCRIPTION: SUMMARY_DESCRIPTION},
+        GraphConst.REAL_DATA_COMPARE: {GraphConst.VALUE: [0.15, 0.2], GraphConst.DESCRIPTION: REAL_DATA_DESCRIPTION}
+    })
+    RED = ("#FF704D", {
+        GraphConst.SUMMARY_COMPARE: {GraphConst.VALUE: [0.8, 1], GraphConst.DESCRIPTION: SUMMARY_DESCRIPTION},
+        GraphConst.REAL_DATA_COMPARE: {GraphConst.VALUE: [0.2, 1], GraphConst.DESCRIPTION: REAL_DATA_DESCRIPTION},
+        GraphConst.MD5_COMPARE: {GraphConst.VALUE: [0, 0], GraphConst.DESCRIPTION: MD5_DESCRIPTION_N},
+    })
+    GREY = ("#C7C7C7", {
+        GraphConst.VALUE: [], GraphConst.DESCRIPTION: NOT_MATCHED
+    })
+
+    def __init__(self, hex_value, mode_info):
+        self.hex_value = hex_value
+        self.mode_info = mode_info
+
+    @staticmethod
+    def get_node_colors(mode):
+        """
+        获取不同比对模式下的颜色说明
+        Args:
+            mode: 比对模式
+        Returns: 颜色说明
+        """
+        return {
+            color.hex_value: color.get_info_by_mode(mode) for color in NodeColors if color.get_info_by_mode(mode)
+        }
+
+    @staticmethod
+    def get_node_error_status(mode, value):
+        """
+        判断精度数据比对指标是否大于基准值
+        Args:
+            mode: 比对模式
+            value: 精度数据比对指标
+        Returns: bool
+        """
+        info = NodeColors.ORANGE_1.get_info_by_mode(mode)
+        if info and GraphConst.VALUE in info:
+            value_range = info[GraphConst.VALUE]
+            return value > value_range[0]
+        return False
+
+    def get_info_by_mode(self, mode):
+        if isinstance(self.mode_info, dict):
+            # 检查是否是模式特定的信息
+            if isinstance(next(iter(self.mode_info.values())), dict):
+                return self.mode_info.get(mode, {})
+            else:
+                # 所有模式共享相同的信息
+                return self.mode_info
+        return {}

msprobe/visualization/graph/node_op.py

@@ -0,0 +1,39 @@
+# Copyright (c) 2024-2024, 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.
+
+from enum import Enum
+import re
+from msprobe.visualization.builder.msprobe_adapter import op_patterns
+
+
+class NodeOp(Enum):
+    module = 0
+    function_api = 1
+    api_collection = 9
+
+
+    @staticmethod
+    def get_node_op(node_name: str):
+        """
+        基于代表节点的字符串，解析节点种类
+        """
+        for op in NodeOp:
+            index = op.value
+            if index < 0 or index >= len(op_patterns):
+                raise Exception("NodeOp and op_patterns in MsprobeAdapter do not match")
+            pattern = op_patterns[index]
+            if re.match(pattern, node_name):
+                return op
+        raise Exception(f"Cannot parse node_name {node_name} into NodeOp")

msprobe/visualization/graph_service.py

@@ -0,0 +1,214 @@
+# Copyright (c) 2024, 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
+import json
+from msprobe.core.common.file_utils import (FileOpen, check_file_type, create_directory, FileChecker,
+                                            check_file_or_directory_path)
+from msprobe.core.common.const import FileCheckConst, Const
+from msprobe.core.common.utils import CompareException
+from msprobe.core.overflow_check.checker import AnomalyDetector
+from msprobe.visualization.compare.graph_comparator import GraphComparator
+from msprobe.visualization.utils import GraphConst, check_directory_content
+from msprobe.visualization.builder.graph_builder import GraphBuilder, GraphExportConfig
+from msprobe.core.common.log import logger
+from msprobe.visualization.graph.node_colors import NodeColors
+from msprobe.core.compare.layer_mapping import generate_api_mapping_by_layer_mapping
+from msprobe.core.compare.utils import check_and_return_dir_contents
+
+current_time = time.strftime("%Y%m%d%H%M%S")
+
+
+def _compare_graph(input_param, args, output_file_name=f'compare_{current_time}.vis'):
+    logger.info('Start building model graphs...')
+    # 对两个数据进行构图
+    dump_path_n = input_param.get('npu_path')
+    dump_path_b = input_param.get('bench_path')
+    construct_path_n = FileChecker(os.path.join(dump_path_n, GraphConst.CONSTRUCT_FILE),
+                                   FileCheckConst.FILE, FileCheckConst.READ_ABLE).common_check()
+    construct_path_b = FileChecker(os.path.join(dump_path_b, GraphConst.CONSTRUCT_FILE),
+                                   FileCheckConst.FILE, FileCheckConst.READ_ABLE).common_check()
+    data_path_n = FileChecker(os.path.join(dump_path_n, GraphConst.DUMP_FILE), FileCheckConst.FILE,
+                              FileCheckConst.READ_ABLE).common_check()
+    data_path_b = FileChecker(os.path.join(dump_path_b, GraphConst.DUMP_FILE), FileCheckConst.FILE,
+                              FileCheckConst.READ_ABLE).common_check()
+    stack_path_n = FileChecker(os.path.join(dump_path_n, GraphConst.STACK_FILE), FileCheckConst.FILE,
+                               FileCheckConst.READ_ABLE).common_check()
+    stack_path_b = FileChecker(os.path.join(dump_path_b, GraphConst.STACK_FILE), FileCheckConst.FILE,
+                               FileCheckConst.READ_ABLE).common_check()
+    graph_n = GraphBuilder.build(construct_path_n, data_path_n, stack_path_n)
+    graph_b = GraphBuilder.build(construct_path_b, data_path_b, stack_path_b)
+    logger.info('Model graphs built successfully, start Comparing graphs...')
+    # 基于graph、stack和data进行比较
+    dump_path_param = {
+        'npu_json_path': data_path_n,
+        'bench_json_path': data_path_b,
+        'stack_json_path': stack_path_n,
+        'is_print_compare_log': input_param.get("is_print_compare_log", True)
+    }
+    mapping_dict = None
+    if args.layer_mapping:
+        yaml_path = FileChecker(args.layer_mapping, FileCheckConst.FILE, FileCheckConst.READ_ABLE).common_check()
+        try:
+            mapping_dict = generate_api_mapping_by_layer_mapping(data_path_n, data_path_b, yaml_path)
+        except Exception:
+            logger.warning('The layer mapping file parsing failed, please check file format, mapping is not effective.')
+    graph_comparator = GraphComparator([graph_n, graph_b], dump_path_param, args.output_path, args.framework,
+                                       mapping_dict=mapping_dict)
+    graph_comparator.compare()
+    micro_steps = graph_n.paging_by_micro_step(graph_b)
+    # 开启溢出检测
+    if args.overflow_check:
+        graph_n.overflow_check()
+        graph_b.overflow_check()
+
+    create_directory(args.output_path)
+    output_path = os.path.join(args.output_path, output_file_name)
+    task = GraphConst.GRAPHCOMPARE_MODE_TO_DUMP_MODE_TO_MAPPING.get(graph_comparator.ma.compare_mode)
+    export_config = GraphExportConfig(graph_n, graph_b, graph_comparator.ma.get_tool_tip(),
+                                      NodeColors.get_node_colors(graph_comparator.ma.compare_mode), micro_steps, task)
+    GraphBuilder.to_json(output_path, export_config)
+    logger.info(f'Model graphs compared successfully, the result file is saved in {output_path}')
+
+
+def _build_graph(dump_path, out_path, overflow_check=False, output_file_name=f'build_{current_time}.vis'):
+    logger.info('Start building model graph...')
+    construct_path = FileChecker(os.path.join(dump_path, GraphConst.CONSTRUCT_FILE), FileCheckConst.FILE,
+                                 FileCheckConst.READ_ABLE).common_check()
+    data_path = FileChecker(os.path.join(dump_path, GraphConst.DUMP_FILE), FileCheckConst.FILE,
+                            FileCheckConst.READ_ABLE).common_check()
+    stack_path = FileChecker(os.path.join(dump_path, GraphConst.STACK_FILE), FileCheckConst.FILE,
+                             FileCheckConst.READ_ABLE).common_check()
+    create_directory(out_path)
+    output_path = os.path.join(out_path, output_file_name)
+    graph = GraphBuilder.build(construct_path, data_path, stack_path)
+    micro_steps = graph.paging_by_micro_step()
+    # 开启溢出检测
+    if overflow_check:
+        graph.overflow_check()
+    GraphBuilder.to_json(output_path, GraphExportConfig(graph, micro_steps=micro_steps))
+    logger.info(f'Model graph built successfully, the result file is saved in {output_path}')
+
+
+def _compare_graph_ranks(input_param, args, step=None):
+    dump_rank_n = input_param.get('npu_path')
+    dump_rank_b = input_param.get('bench_path')
+    npu_ranks = sorted(check_and_return_dir_contents(dump_rank_n, Const.RANK))
+    bench_ranks = sorted(check_and_return_dir_contents(dump_rank_b, Const.RANK))
+    if npu_ranks != bench_ranks:
+        logger.error('The number of ranks in the two runs are different. Unable to match the ranks.')
+        raise CompareException(CompareException.INVALID_PATH_ERROR)
+    for nr, br in zip(npu_ranks, bench_ranks):
+        logger.info(f'Start processing data for {nr}...')
+        input_param['npu_path'] = os.path.join(dump_rank_n, nr)
+        input_param['bench_path'] = os.path.join(dump_rank_b, br)
+        output_file_name = f'compare_{step}_{nr}_{current_time}.vis' if step else f'compare_{nr}_{current_time}.vis'
+        _compare_graph(input_param, args, output_file_name=output_file_name)
+
+
+def _compare_graph_steps(input_param, args):
+    dump_step_n = input_param.get('npu_path')
+    dump_step_b = input_param.get('bench_path')
+
+    npu_steps = sorted(check_and_return_dir_contents(dump_step_n, Const.STEP))
+    bench_steps = sorted(check_and_return_dir_contents(dump_step_b, Const.STEP))
+
+    if npu_steps != bench_steps:
+        logger.error('The number of steps in the two runs are different. Unable to match the steps.')
+        raise CompareException(CompareException.INVALID_PATH_ERROR)
+
+    for folder_step in npu_steps:
+        logger.info(f'Start processing data for {folder_step}...')
+        input_param['npu_path'] = os.path.join(dump_step_n, folder_step)
+        input_param['bench_path'] = os.path.join(dump_step_b, folder_step)
+
+        _compare_graph_ranks(input_param, args, step=folder_step)
+
+
+def _build_graph_ranks(dump_ranks_path, out_path, overflow_check=False, step=None):
+    ranks = sorted(check_and_return_dir_contents(dump_ranks_path, Const.RANK))
+    for rank in ranks:
+        logger.info(f'Start processing data for {rank}...')
+        dump_path = os.path.join(dump_ranks_path, rank)
+        output_file_name = f'build_{step}_{rank}_{current_time}.vis' if step else f'build_{rank}_{current_time}.vis'
+        _build_graph(dump_path, out_path, overflow_check, output_file_name)
+
+
+def _build_graph_steps(dump_steps_path, out_path, overflow_check=False):
+    steps = sorted(check_and_return_dir_contents(dump_steps_path, Const.STEP))
+    for step in steps:
+        logger.info(f'Start processing data for {step}...')
+        dump_ranks_path = os.path.join(dump_steps_path, step)
+        _build_graph_ranks(dump_ranks_path, out_path, overflow_check, step)
+
+
+def _graph_service_parser(parser):
+    parser.add_argument("-i", "--input_path", dest="input_path", type=str,
+                        help="<Required> The compare input path, a dict json.", required=True)
+    parser.add_argument("-o", "--output_path", dest="output_path", type=str,
+                        help="<Required> The compare task result out path.", required=True)
+    parser.add_argument("-lm", "--layer_mapping", dest="layer_mapping", type=str,
+                        help="<optional> The layer mapping file path.", required=False)
+    parser.add_argument("-oc", "--overflow_check", dest="overflow_check", action="store_true",
+                        help="<Optional> whether open overflow_check for graph.", required=False)
+
+
+def _graph_service_command(args):
+    with FileOpen(args.input_path, "r") as file:
+        input_param = json.load(file)
+    npu_path = input_param.get("npu_path")
+    bench_path = input_param.get("bench_path")
+    check_file_or_directory_path(npu_path, isdir=True)
+    if bench_path:
+        check_file_or_directory_path(bench_path, isdir=True)
+    if check_file_type(npu_path) == FileCheckConst.DIR and not bench_path:
+        content = check_directory_content(npu_path)
+        if content == GraphConst.RANKS:
+            _build_graph_ranks(npu_path, args.output_path, args.overflow_check)
+        elif content == GraphConst.STEPS:
+            _build_graph_steps(npu_path, args.output_path, args.overflow_check)
+        else:
+            _build_graph(npu_path, args.output_path, args.overflow_check)
+    elif check_file_type(npu_path) == FileCheckConst.DIR and check_file_type(bench_path) == FileCheckConst.DIR:
+        content_n = check_directory_content(npu_path)
+        content_b = check_directory_content(bench_path)
+        if content_n != content_b:
+            raise ValueError('The directory structures of npu_path and bench_path are inconsistent.')
+        if content_n == GraphConst.RANKS:
+            _compare_graph_ranks(input_param, args)
+        elif content_n == GraphConst.STEPS:
+            _compare_graph_steps(input_param, args)
+        else:
+            _compare_graph(input_param, args)
+    else:
+        logger.error("The npu_path or bench_path should be a folder.")
+        raise CompareException(CompareException.INVALID_COMPARE_MODE)
+
+
+def _pt_graph_service_parser(parser):
+    _graph_service_parser(parser)
+
+
+def _pt_graph_service_command(args):
+    _graph_service_command(args)
+
+
+def _ms_graph_service_parser(parser):
+    _graph_service_parser(parser)
+
+
+def _ms_graph_service_command(args):
+    _graph_service_command(args)

msprobe/visualization/utils.py

@@ -0,0 +1,232 @@
+# Copyright (c) 2024, 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 re
+import json
+from msprobe.core.common.file_utils import FileOpen
+from msprobe.core.common.const import CompareConst, Const
+from msprobe.core.compare.acc_compare import Comparator
+
+
+def load_json_file(file_path):
+    """
+    加载json文件
+    """
+    try:
+        with FileOpen(file_path, 'r') as f:
+            file_dict = json.load(f)
+            if not isinstance(file_dict, dict):
+                return {}
+            return file_dict
+    except json.JSONDecodeError:
+        return {}
+
+
+def load_data_json_file(file_path):
+    """
+    加载dump.json中的data字段
+    """
+    return load_json_file(file_path).get(GraphConst.DATA_KEY, {})
+
+
+def save_json_file(file_path, data):
+    """
+    保存json文件
+    """
+    with FileOpen(file_path, 'w') as f:
+        f.write(json.dumps(data, indent=4))
+
+
+def get_csv_df(stack, csv_data, compare_mode):
+    """
+    调用acc接口写入csv
+    """
+    dump_mode = GraphConst.GRAPHCOMPARE_MODE_TO_DUMP_MODE_TO_MAPPING.get(compare_mode)
+    return Comparator.make_result_table(csv_data, stack, dump_mode)
+
+
+def str2float(percentage_str):
+    """
+    百分比字符串转换转换为浮点型
+    Args:
+        percentage_str: '0.00%', '23.4%'
+    Returns: float 0.00, 0.234
+    """
+    try:
+        percentage_str = percentage_str.strip('%')
+        return float(percentage_str) / 100
+    except (ValueError, AttributeError):
+        return 0
+
+
+def is_integer(s):
+    try:
+        int(s)
+        return True
+    except Exception:
+        return False
+
+
+def check_directory_content(input_path):
+    """
+    检查input_path内容, 是否全是step{数字}命名的文件夹(例如step0), 或者全是rank{数字}命名的文件夹(例如rank0), 或者全是文件
+    """
+    contents = os.listdir(input_path)
+    if not contents:
+        raise ValueError(f'The path {input_path} is empty.')
+
+    # 真实数据dump会有dump_tensor_data文件夹
+    if os.path.exists(os.path.join(input_path, Const.DUMP_TENSOR_DATA)):
+        return GraphConst.FILES
+
+    # 检查是否全是文件
+    if all(os.path.isfile(os.path.join(input_path, item)) for item in contents):
+        return GraphConst.FILES
+
+    rank_pattern = re.compile(r'^rank\d+$')
+    step_pattern = re.compile(r'^step\d+$')
+
+    rank_all = True
+    step_all = True
+
+    for item in contents:
+        item_path = os.path.join(input_path, item)
+        if not os.path.isdir(item_path):
+            continue
+        if not rank_pattern.match(item):
+            rank_all = False
+        if not step_pattern.match(item):
+            step_all = False
+
+    if rank_all:
+        return GraphConst.RANKS
+    if step_all:
+        return GraphConst.STEPS
+
+    raise ValueError("The input path content does not conform to the expected naming convention. "
+                     "It is expected to be all step{number} named folders (such as step0), "
+                     "all rank{number} named folders (such as rank0), or all files.")
+
+
+class ToolTip:
+    MAX_DIFF = 'NPU与标杆API统计信息比对，最大值的差值'
+    MIN_DIFF = 'NPU与标杆API统计信息比对，最小值的差值'
+    MEAN_DIFF = 'NPU与标杆API统计信息比对，平均值的差值'
+    NORM_DIFF = 'NPU与标杆API统计信息比对，2范数（平方根）的差值'
+    MD5 = '数据MD5信息，用于比较两个数据信息是否完全一致'
+    ONE_THOUSANDTH_ERR_RATIO = 'Tensor中的元素逐个与对应的标杆数据对比，相对误差小于千分之一的比例占总元素个数的比例，比例越接近1越好'
+    FIVE_THOUSANDTHS_ERR_RATIO = 'Tensor中的元素逐个与对应的标杆数据对比，相对误差小于千分之五的比例占总元素个数的比例，比例越接近1越好'
+    COSINE = (
+        '通过计算两个向量的余弦值来判断其相似度，数值越接近于1说明计算出的两个张量越相似，实际可接受阈值为大于0.99。'
+        '在计算中可能会存在nan，主要由于可能会出现其中一个向量为0'
+    )
+    MAX_ABS_ERR = '当最大绝对误差越接近0表示其计算的误差越小，实际可接受阈值为小于0.001'
+    MAX_RELATIVE_ERR = (
+        '当最大相对误差越接近0表示其计算的误差越小。'
+        '当dump数据中存在0或Nan时，比对结果中最大相对误差则出现inf或Nan的情况，属于正常现象'
+    )
+    SMALL_VALUE_TIP = '{}, 由于{}小于{}, 建议不参考此相对误差，请参考绝对误差'
+
+
+class Suggestions:
+    Module = '此模块精度比对结果疑似异常，请使用msprobe工具的数据采集功能对模块中的api进行dump比对'
+    API = '此api精度比对结果疑似异常，请使用msprobe工具的预检功能对api进行精度检测'
+    DUMP = 'msprobe工具的数据采集功能'
+    DUMP_URL = 'https://gitee.com/ascend/mstt/blob/master/debug/accuracy_tools/msprobe/pytorch/doc/dump.md'
+    API_ACCURACY_CHECKER = 'msprobe工具的预检功能'
+    API_ACCURACY_CHECKER_URL = \
+        'https://gitee.com/ascend/mstt/blob/master/debug/accuracy_tools/msprobe/pytorch/doc/api_accuracy_checker.md'
+
+
+class GraphConst:
+    CONSTRUCT_FILE = 'construct.json'
+    DUMP_FILE = 'dump.json'
+    STACK_FILE = 'stack.json'
+    GRAPH_FILE = 'graph.vis'
+    ERROR_KEY = 'error_key'
+    SUMMARY_COMPARE = 0
+    MD5_COMPARE = 1
+    REAL_DATA_COMPARE = 2
+    JSON_NPU_KEY = 'NPU'
+    JSON_BENCH_KEY = 'Bench'
+    JSON_TIP_KEY = 'ToolTip'
+    JSON_ROOT_KEY = 'root'
+    JSON_NODE_KEY = 'node'
+    JSON_DATA_KEY = 'dump_data_dir'
+    JSON_TASK_KEY = 'task'
+    DATA_KEY = 'data'
+    REAL_DATA_TH = 0.1
+    MAX_RELATIVE_ERR_TH = 0.5
+    ROUND_TH = 6
+    JSON_INDEX_KEY = 'precision_index'
+    MAX_INDEX_KEY = 1
+    MIN_INDEX_KEY = 0
+    SUGGEST_KEY = 'text'
+    TAG_NA = 'na'
+    OUTPUT_INDEX_TWO = -2
+    OUTPUT_INDEX_THREE = -3
+    OUTPUT_MIN_LEN = 3
+    INPUT = '.input.'
+    OUTPUT = '.output.'
+    STR_MAX_LEN = 50
+    SMALL_VALUE = 1e-3
+    MD5_INDEX_LIST = [CompareConst.RESULT]
+    REAL_DATA_INDEX_LIST = [CompareConst.COSINE, CompareConst.MAX_ABS_ERR, CompareConst.MAX_RELATIVE_ERR,
+                            CompareConst.ONE_THOUSANDTH_ERR_RATIO, CompareConst.FIVE_THOUSANDTHS_ERR_RATIO]
+    SUMMARY_INDEX_LIST = [CompareConst.MAX_DIFF, CompareConst.MIN_DIFF, CompareConst.MEAN_DIFF,
+                          CompareConst.NORM_DIFF, CompareConst.MAX_RELATIVE_ERR, CompareConst.MIN_RELATIVE_ERR,
+                          CompareConst.MEAN_RELATIVE_ERR, CompareConst.NORM_RELATIVE_ERR]
+    VALUE_INDEX_LIST = [Const.MAX, Const.MIN, Const.MEAN, Const.NORM]
+    APIS_BETWEEN_MODULES = 'Apis_Between_Modules'
+    NULL = 'null'
+    NONE = 'None'
+    VALUE = 'value'
+    BRACE = '{}'
+    DESCRIPTION = 'description'
+    COLORS = 'Colors'
+    MICRO_STEPS = 'MicroSteps'
+
+    DUMP_MODE_TO_GRAPHCOMPARE_MODE_MAPPING = {
+        Const.ALL: REAL_DATA_COMPARE,
+        Const.SUMMARY: SUMMARY_COMPARE,
+        Const.MD5: MD5_COMPARE
+    }
+
+    GRAPHCOMPARE_MODE_TO_DUMP_MODE_TO_MAPPING = {
+        REAL_DATA_COMPARE: Const.ALL,
+        SUMMARY_COMPARE: Const.SUMMARY,
+        MD5_COMPARE: Const.MD5
+    }
+    SMALL_VALUES = {
+        Const.TORCH_FLOAT32: 1e-6,
+        Const.TORCH_FLOAT16: 1e-3,
+        Const.TORCH_BFLOAT16: 1e-3,
+        Const.FLOAT32: 1e-6,
+        Const.FLOAT16: 1e-3,
+        Const.BFLOAT16: 1e-3
+    }
+    SMALL_VALUES_ABS_ERROR = {
+        Const.TORCH_FLOAT32: 1e-6,
+        Const.TORCH_FLOAT16: 1e-3,
+        Const.TORCH_BFLOAT16: 1e-3,
+        Const.FLOAT32: 1e-6,
+        Const.FLOAT16: 1e-3,
+        Const.BFLOAT16: 1e-3
+    }
+
+    RANKS = 'ranks'
+    STEPS = 'steps'
+    FILES = 'files'