mindstudio-probe 1.0.1__py3-none-any.whl

msprobe/mindspore/debugger/precision_debugger.py

@@ -0,0 +1,32 @@
+import os
+from msprobe.mindspore.ms_config import parse_json_config
+from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
+from msprobe.mindspore.task_handler_factory import TaskHandlerFactory
+
+
+class PrecisionDebugger:
+    _instance = None
+
+    def __new__(cls, config_path=None):
+        if not cls._instance:
+            cls._instance = super().__new__(cls)
+            cls._instance.initialized = False
+            cls._instance.config = None
+        return cls._instance
+
+    def __init__(self, config_path=None):
+        if self.initialized:
+            return
+        if not config_path:
+            config_path = os.path.join(os.path.dirname(__file__), "../../config/config.json")
+        common_config, task_config = parse_json_config(config_path)
+        self.config = DebuggerConfig(common_config, task_config)
+        self.initialized = True
+
+    @classmethod
+    def start(cls, target=None):
+        instance = cls._instance
+        if not instance:
+            raise Exception("No instance of PrecisionDebugger found.")
+        handler = TaskHandlerFactory.create(instance.config)
+        handler.handle()

msprobe/mindspore/doc/dump.md

@@ -0,0 +1,65 @@
+# **精度数据采集**
+
+msprobe工具主要通过在训练脚本内添加dump接口并启动训练的方式来采集精度数据。
+
+执行dump操作需要安装msprobe工具。详见《[MindStudio精度调试工具](../../README.md)》的“工具安装”章节。
+
+## dump接口介绍
+
+### PrecisionDebugger
+
+**功能说明**
+
+通过加载dump配置文件的方式来确定dump操作的详细配置。
+
+可以在from msprobe.mindspore import PrecisionDebugger和模型初始化之间的任意位置添加该接口。
+
+**原型**
+
+```Python
+PrecisionDebugger(config_path=None)
+```
+
+**参数说明**
+
+| 参数名      | 说明                                                         | 是否必选 |
+| ----------- | ------------------------------------------------------------ | -------- |
+| config_path | 指定dump配置文件路径，String类型。参数示例："./config.json"。未配置该路径时，默认使用[config.json](../../config)文件的默认配置。config.json文件可以配置更多参数，若需要进行更多场景的精度数据dump，建议配置[config.json](../../config/config.json)文件。 | 否       |
+
+### start函数
+
+**功能说明**
+
+启动函数。
+
+**原型**
+
+```Python
+debugger.start()
+```
+
+该函数为类函数，可以使用debugger.start()也可以使用PrecisionDebugger.start()。
+
+## 示例代码
+
+```Python
+from msprobe.mindspore import PrecisionDebugger
+debugger = PrecisionDebugger(config_path="./config.json")
+# 请勿将以上初始化流程插入到循环代码中
+# 下面代码也可以用PrecisionDebugger.start()
+debugger.start()
+...
+```
+
+## dump结果文件介绍
+
+训练结束后，工具将dump的数据保存在dump_path参数指定的目录下。
+
+- level为L1时
+
+  dump结果目录请参见MindSpore官网中的《[同步Dump数据对象目录](https://www.mindspore.cn/tutorials/experts/zh-CN/r2.3.0rc2/debug/dump.html#%E5%90%8C%E6%AD%A5dump%E6%95%B0%E6%8D%AE%E5%AF%B9%E8%B1%A1%E7%9B%AE%E5%BD%95)》。
+
+- level为L2时
+
+  dump结果目录请参见MindSpore官网中的《[异步Dump数据对象目录](https://www.mindspore.cn/tutorials/experts/zh-CN/r2.3.0rc2/debug/dump.html#%E5%BC%82%E6%AD%A5dump%E6%95%B0%E6%8D%AE%E5%AF%B9%E8%B1%A1%E7%9B%AE%E5%BD%95)》。
+

msprobe/mindspore/dump/api_kbk_dump.py

@@ -0,0 +1,55 @@
+import os
+import json
+from msprobe.core.common.utils import make_dump_path_if_not_exists
+from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
+from msprobe.core.common.log import logger
+from msprobe.core.common.file_check import FileOpen
+
+
+class ApiKbkDump:
+    def __init__(self, config: DebuggerConfig):
+        self.dump_json = dict()
+        self.dump_json["common_dump_settings"] = dict()
+        self.dump_json["common_dump_settings"]["dump_mode"] = 0
+        self.dump_json["common_dump_settings"]["path"] = ""
+        self.dump_json["common_dump_settings"]["net_name"] = "Net"
+        self.dump_json["common_dump_settings"]["iteration"] = "all"
+        self.dump_json["common_dump_settings"]["saved_data"] = "statistic"
+        self.dump_json["common_dump_settings"]["input_output"] = 0
+        self.dump_json["common_dump_settings"]["kernels"] = []
+        self.dump_json["common_dump_settings"]["support_device"] = [0,1,2,3,4,5,6,7]
+        self.dump_json["e2e_dump_settings"] = dict()
+        self.dump_json["e2e_dump_settings"]["enable"] = True
+        self.dump_json["e2e_dump_settings"]["trans_flag"] = True
+
+
+        if len(config.list) > 0:
+            self.dump_json["common_dump_settings"]["dump_mode"] = 1
+            self.dump_json["common_dump_settings"]["kernels"] = config.list
+        self.dump_json["common_dump_settings"]["path"] = config.dump_path
+        if len(config.step) > 0:
+            step_str = ""
+            for s in config.step:
+                step_str += (str(s) + '|')
+            self.dump_json["common_dump_settings"]["iteration"] = step_str[:-1]
+        if len(config.rank) > 0:
+            self.dump_json["common_dump_settings"]["support_device"] = config.rank
+        if config.task == "tensor":
+            self.dump_json["common_dump_settings"]["saved_data"] = "tensor"
+        if len(config.data_mode) == 1:
+            if config.data_mode[0] == "input":
+                self.dump_json["common_dump_settings"]["input_output"] = 1
+            if config.data_mode[0] == "output":
+                self.dump_json["common_dump_settings"]["input_output"] = 2
+
+    def handle(self):
+        json_path = self.dump_json["common_dump_settings"]["path"]
+        make_dump_path_if_not_exists(json_path)
+        json_path = os.path.join(json_path, "api_kbk_dump.json")
+        with FileOpen(json_path, 'w') as f:
+            json.dump(self.dump_json, f)
+        logger.info(json_path + " has been created.")
+        os.environ["GRAPH_OP_RUN"] = "1"
+        os.environ["MINDSPORE_DUMP_CONFIG"] = json_path
+        if "MS_ACL_DUMP_CFG_PATH" in os.environ:
+            del os.environ["MS_ACL_DUMP_CFG_PATH"]

msprobe/mindspore/dump/dump_tool_factory.py

@@ -0,0 +1,38 @@
+from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
+from msprobe.mindspore.dump.api_kbk_dump import ApiKbkDump
+from msprobe.mindspore.dump.kernel_graph_dump import KernelGraphDump
+
+
+class DumpToolFactory:
+    tools = {
+        "cell": {
+            "kbk": None,
+            "graph": None,
+            "pynative": None
+        },
+        "api": {
+            "kbk": ApiKbkDump,
+            "graph": None,
+            "pynative": None
+        },
+        "kernel": {
+            "kbk": None,
+            "graph": KernelGraphDump,
+            "pynative": None
+        }
+    }
+
+    @staticmethod
+    def create(config: DebuggerConfig):
+        tool = DumpToolFactory.tools.get(config.level)
+        if not tool:
+            raise Exception("valid level is needed.")
+        if config.level == "api":
+            tool = tool.get("kbk")
+        elif config.level == "kernel":
+            tool = tool.get("graph")
+        elif config.level == "cell":
+            raise Exception("Cell dump in not supported now.")
+        if not tool:
+            raise Exception("Data dump in not supported in this mode.")
+        return tool(config)

msprobe/mindspore/dump/kernel_graph_dump.py

@@ -0,0 +1,60 @@
+import os
+import json
+from msprobe.core.common.utils import make_dump_path_if_not_exists
+from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
+from msprobe.core.common.log import logger
+from msprobe.core.common.file_check import FileOpen
+
+
+class KernelGraphDump:
+    def __init__(self, config: DebuggerConfig):
+        self.dump_json = dict()
+        self.dump_json["common_dump_settings"] = dict()
+        self.dump_json["common_dump_settings"]["dump_mode"] = 0
+        self.dump_json["common_dump_settings"]["path"] = ""
+        self.dump_json["common_dump_settings"]["net_name"] = "Net"
+        self.dump_json["common_dump_settings"]["iteration"] = "all"
+        self.dump_json["common_dump_settings"]["saved_data"] = "statistic"
+        self.dump_json["common_dump_settings"]["input_output"] = 0
+        self.dump_json["common_dump_settings"]["kernels"] = []
+        self.dump_json["common_dump_settings"]["support_device"] = [0, 1, 2, 3, 4, 5, 6, 7]
+        self.dump_json["common_dump_settings"]["op_debug_mode"] = 0
+        self.dump_json["common_dump_settings"]["file_format"] = "npy"
+
+        if len(config.list) > 0:
+            self.dump_json["common_dump_settings"]["dump_mode"] = 1
+            self.dump_json["common_dump_settings"]["kernels"] = config.list
+        self.dump_json["common_dump_settings"]["path"] = config.dump_path
+        if len(config.step) > 0:
+            step_str = ""
+            for s in config.step:
+                step_str += (str(s) + '|')
+            self.dump_json["common_dump_settings"]["iteration"] = step_str[:-1]
+        if len(config.rank) > 0:
+            self.dump_json["common_dump_settings"]["support_device"] = config.rank
+        if config.task == "tensor":
+            self.dump_json["common_dump_settings"]["saved_data"] = "tensor"
+            self.dump_json["common_dump_settings"]["file_format"] = config.file_format
+        if len(config.data_mode) == 1:
+            if config.data_mode[0] == "input":
+                self.dump_json["common_dump_settings"]["input_output"] = 1
+            if config.data_mode[0] == "output":
+                self.dump_json["common_dump_settings"]["input_output"] = 2
+
+    def handle(self):
+        if os.getenv("GRAPH_OP_RUN") == "1":
+            raise Exception("Must run in graph mode, not kbk mode")
+        json_path = self.dump_json["common_dump_settings"]["path"]
+        make_dump_path_if_not_exists(json_path)
+        json_path = os.path.join(json_path, "kernel_graph_dump.json")
+        with FileOpen(json_path, 'w') as f:
+            json.dump(self.dump_json, f)
+        logger.info(json_path + " has been created.")
+        os.environ["MINDSPORE_DUMP_CONFIG"] = json_path
+        if self.dump_json["common_dump_settings"]["dump_mode"] == 0:
+            if self.dump_json["common_dump_settings"]["iteration"] != "all" or \
+               len(self.dump_json["common_dump_settings"]["kernels"]) == 0:
+                os.environ["MS_ACL_DUMP_CFG_PATH"] = json_path
+        else:
+            if "MS_ACL_DUMP_CFG_PATH" in os.environ:
+                del os.environ["MS_ACL_DUMP_CFG_PATH"]

msprobe/mindspore/ms_config.py

@@ -0,0 +1,78 @@
+import json
+from msprobe.core.common_config import CommonConfig, BaseConfig
+from msprobe.core.common.file_check import FileOpen
+
+
+class TensorConfig(BaseConfig):
+    def __init__(self, json_config):
+        super().__init__(json_config)
+        self.check_mode = None
+        self.file_format = json_config.get("file_format")
+        self.check_config()
+        self._check_config()
+
+    def _check_config(self):
+        if self.data_mode is not None and len(self.data_mode) > 0:
+            if len(self.data_mode) > 1 or self.data_mode[0] not in ["all", "input", "output"]:
+                raise Exception("data_mode must be all, input or output")
+        if self.file_format and self.file_format not in ["npy", "bin"]:
+            raise Exception("file_format is invalid")
+
+
+class StatisticsConfig(BaseConfig):
+    def __init__(self, json_config):
+        super().__init__(json_config)
+        self.file_format = None
+        self.check_mode = None
+        self.check_config()
+        self._check_config()
+
+    def _check_config(self):
+        if self.data_mode is not None and len(self.data_mode) > 0:
+            if len(self.data_mode) > 1 or self.data_mode[0] not in ["all", "input", "output"]:
+                raise Exception("data_mode must be all, input or output")
+
+
+class OverflowCheck(BaseConfig):
+    def __init__(self, json_config):
+        super().__init__(json_config)
+        self.file_format = None
+        self.check_mode = json_config.get("check_mode")
+        self._check_config()
+
+    def _check_config(self):
+        if self.data_mode is not None and len(self.data_mode) > 0:
+            if len(self.data_mode) > 1 or self.data_mode[0] not in ["all", "input", "output"]:
+                raise Exception("data_mode must be all, input or output")
+        if self.check_mode and self.check_mode not in ["all", "aicore", "atomic"]:
+            raise Exception("check_mode is invalid")
+
+
+def parse_common_config(json_config):
+    return CommonConfig(json_config)
+
+
+def parse_task_config(task, json_config):
+    task_map = json_config[task]
+    if not task_map:
+        task_map = dict()
+    if task == "tensor":
+        return TensorConfig(task_map)
+    elif task == "statistics":
+        return StatisticsConfig(task_map)
+    elif task == "overflow_check":
+        return OverflowCheck(task_map)
+    else:
+        raise Exception("task is invalid.")
+
+
+def parse_json_config(json_file_path):
+    if not json_file_path:
+        raise Exception("json file path is None")
+    with FileOpen(json_file_path, 'r') as file:
+        json_config = json.load(file)
+    common_config = parse_common_config(json_config)
+    if not common_config.task:
+        common_config.task = "statistics"
+    task_config = parse_task_config(common_config.task, json_config)
+    return common_config, task_config

msprobe/mindspore/overflow_check/kernel_graph_overflow_check.py

@@ -0,0 +1,45 @@
+import os
+import json
+from msprobe.core.common.utils import make_dump_path_if_not_exists
+from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
+from msprobe.core.common.log import logger
+from msprobe.core.common.file_check import FileOpen
+
+
+class KernelGraphOverflowCheck:
+    def __init__(self, config: DebuggerConfig):
+        self.dump_json = dict()
+        self.dump_json["common_dump_settings"] = dict()
+        self.dump_json["common_dump_settings"]["dump_mode"] = 0
+        self.dump_json["common_dump_settings"]["path"] = ""
+        self.dump_json["common_dump_settings"]["net_name"] = "Net"
+        self.dump_json["common_dump_settings"]["iteration"] = "all"
+        self.dump_json["common_dump_settings"]["saved_data"] = "full"
+        self.dump_json["common_dump_settings"]["input_output"] = 0
+        self.dump_json["common_dump_settings"]["kernels"] = []
+        self.dump_json["common_dump_settings"]["support_device"] = [0,1,2,3,4,5,6,7]
+        self.dump_json["common_dump_settings"]["op_debug_mode"] = 3
+        self.dump_json["common_dump_settings"]["file_format"] = "npy"
+
+        self.dump_json["common_dump_settings"]["path"] = config.dump_path
+        if len(config.step) > 0:
+            logger.warning("Step would change to all in this task.")
+        if len(config.rank) > 0:
+            self.dump_json["common_dump_settings"]["support_device"] = config.rank
+        if config.check_mode == "aicore":
+            self.dump_json["common_dump_settings"]["op_debug_mode"] = 1
+        elif config.check_mode == "atomic":
+            self.dump_json["common_dump_settings"]["op_debug_mode"] = 2
+
+    def handle(self):
+        if os.getenv("GRAPH_OP_RUN") == "1":
+            raise Exception("Must run in graph mode, not kbk mode")
+        json_path = self.dump_json["common_dump_settings"]["path"]
+        make_dump_path_if_not_exists(json_path)
+        json_path = os.path.join(json_path, "kernel_graph_overflow_check.json")
+        with FileOpen(json_path, 'w') as f:
+            json.dump(self.dump_json, f)
+        logger.info(json_path + " has been created.")
+        os.environ["MINDSPORE_DUMP_CONFIG"] = json_path
+        if "MS_ACL_DUMP_CFG_PATH" in os.environ:
+            del os.environ["MS_ACL_DUMP_CFG_PATH"]

msprobe/mindspore/overflow_check/overflow_check_tool_factory.py

@@ -0,0 +1,32 @@
+from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
+from msprobe.mindspore.overflow_check.kernel_graph_overflow_check import KernelGraphOverflowCheck
+
+
+class OverflowCheckToolFactory:
+    tools = {
+        "cell": {
+            "kbk": None,
+            "graph": None,
+            "pynative": None
+        },
+        "api": {
+            "kbk": None,
+            "graph": None,
+            "pynative": None
+        },
+        "kernel": {
+            "kbk": None,
+            "graph": KernelGraphOverflowCheck,
+            "pynative": None
+        }
+    }
+
+    @staticmethod
+    def create(config: DebuggerConfig):
+        tool = OverflowCheckToolFactory.tools.get(config.level)
+        if not tool:
+            raise Exception("valid level is needed.")
+        tool = tool.get("graph")
+        if not tool:
+            raise Exception("Overflow check in not supported in this mode.")
+        return tool(config)

msprobe/mindspore/task_handler_factory.py

@@ -0,0 +1,21 @@
+from msprobe.mindspore.debugger.debugger_config import DebuggerConfig
+from msprobe.mindspore.dump.dump_tool_factory import DumpToolFactory
+from msprobe.mindspore.overflow_check.overflow_check_tool_factory import OverflowCheckToolFactory
+
+
+class TaskHandlerFactory:
+    tasks = {
+        "tensor": DumpToolFactory,
+        "statistics": DumpToolFactory,
+        "overflow_check": OverflowCheckToolFactory
+    }
+
+    @staticmethod
+    def create(config: DebuggerConfig):
+        task = TaskHandlerFactory.tasks.get(config.task)
+        if not task:
+            raise Exception("valid task is needed.")
+        handler = task.create(config)
+        if not handler:
+            raise Exception("Can not find task handler")
+        return handler

msprobe/msprobe.py

@@ -0,0 +1,67 @@
+# 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 argparse
+import sys
+from msprobe.pytorch.api_accuracy_checker.run_ut.run_ut import _run_ut_parser, run_ut_command
+from msprobe.pytorch.parse_tool.cli import parse as cli_parse
+from msprobe.pytorch.api_accuracy_checker.run_ut.multi_run_ut import prepare_config, run_parallel_ut
+from msprobe.pytorch.api_accuracy_checker.compare.api_precision_compare import _api_precision_compare_parser, \
+    _api_precision_compare_command
+from msprobe.pytorch.api_accuracy_checker.run_ut.run_overflow_check import _run_overflow_check_parser, \
+    _run_overflow_check_command
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        description="msprobe(mindstudio probe), [Powered by MindStudio].\n"
+                    "Providing one-site accuracy difference debugging toolkit for training on Ascend Devices.\n"
+                    f"For any issue, refer README.md first",
+    )
+    parser.set_defaults(print_help=parser.print_help)
+    parser.add_argument('-f', '--framework', required=True, choices=['pytorch'],
+                        help='Deep learning framework.')
+    subparsers = parser.add_subparsers()
+    subparsers.add_parser('parse')
+    run_ut_cmd_parser = subparsers.add_parser('run_ut')
+    multi_run_ut_cmd_parser = subparsers.add_parser('multi_run_ut')
+    api_precision_compare_cmd_parser = subparsers.add_parser('api_precision_compare')
+    run_overflow_check_cmd_parser = subparsers.add_parser('run_overflow_check')
+    _run_ut_parser(run_ut_cmd_parser)
+    _run_ut_parser(multi_run_ut_cmd_parser)
+    multi_run_ut_cmd_parser.add_argument('-n', '--num_splits', type=int, choices=range(1, 65), default=8,
+                                         help='Number of splits for parallel processing. Range: 1-64')
+    _api_precision_compare_parser(api_precision_compare_cmd_parser)
+    _run_overflow_check_parser(run_overflow_check_cmd_parser)
+    if len(sys.argv) == 1:
+        parser.print_help()
+        sys.exit(0)
+    args = parser.parse_args(sys.argv[1:])
+    if sys.argv[3] == "run_ut":
+        run_ut_command(args)
+    elif sys.argv[3] == "parse":
+        cli_parse()
+    elif sys.argv[3] == "multi_run_ut":
+        config = prepare_config(args)
+        run_parallel_ut(config)
+    elif sys.argv[3] == "api_precision_compare":
+        _api_precision_compare_command(args)
+    elif sys.argv[3] == "run_overflow_check":
+        _run_overflow_check_command(args)
+
+
+if __name__ == "__main__":
+    main()

msprobe/pytorch/__init__.py

@@ -0,0 +1,4 @@
+from .debugger.precision_debugger import PrecisionDebugger
+from .common.utils import seed_all
+from .compare.acc_compare import compare
+from .compare.distributed_compare import compare_distributed

msprobe/pytorch/advisor/advisor.py

@@ -0,0 +1,124 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+# Copyright (C) 2022-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
+
+from msprobe.pytorch.advisor.advisor_result import AdvisorResult
+from msprobe.pytorch.advisor.advisor_const import AdvisorConst
+from msprobe.pytorch.common.log import logger
+from msprobe.core.common.utils import CompareException
+from msprobe.core.common.file_check import FileChecker
+from msprobe.core.common.const import Const, CompareConst, FileCheckConst
+
+class Advisor:
+    """
+    Class for generate advisor
+    """
+
+    def __init__(self, input_data, out_path=""):
+        self.input_data = input_data
+        self.out_path = os.path.realpath(out_path)
+        self.file_type = None
+
+    @staticmethod
+    def deterministic_advisor(message, node_name):
+        for api_name in AdvisorConst.NEED_DETERMINISTIC_API:
+            if api_name in node_name:
+                return AdvisorConst.DETERMINISTIC_SUGGEST
+        return message
+
+    @staticmethod
+    def batch_norm_advisor(message, node_name):
+        if AdvisorConst.FUNC_BATCH_NORM in node_name and AdvisorConst.FORWARD_INPUT_1 in node_name:
+            message = AdvisorConst.BATCH_NORM_SUGGEST
+        return message
+
+    def analyze_unmatched(self, analyze_data):
+        if self.file_type == Const.ALL:
+            accuracy_unmatched = analyze_data[
+                analyze_data[CompareConst.ACCURACY] == CompareConst.ACCURACY_CHECK_UNMATCH]
+        else:
+            accuracy_unmatched = analyze_data[(analyze_data[CompareConst.NPU_SHAPE] == CompareConst.NAN) |
+                                              (analyze_data[CompareConst.BENCH_SHAPE] == CompareConst.NAN)]
+        num_unmatch = len(accuracy_unmatched)
+        if num_unmatch != 0:
+            for i in range(len(accuracy_unmatched)):
+                item = accuracy_unmatched.iloc[i]
+                logger.warning("The tensor name matches but the shape or dtype does not match: {}"
+                            .format(item[CompareConst.NPU_NAME]))
+
+    def gen_advisor_result(self, pd_data):
+        first_failing_data = pd_data.iloc[0]
+        node_name = first_failing_data[CompareConst.NPU_NAME]
+        index = first_failing_data['index']
+        message = self.gen_advisor_message(node_name)
+        logger.warning("Find %s accuracy not reached, the line is %s" % (node_name, index))
+        result = AdvisorResult(node_name, index, message)
+        return result
+
+    def gen_advisor_message(self, node_name):
+        if AdvisorConst.FORWARD in node_name:
+            if AdvisorConst.INPUT in node_name:
+                message = AdvisorConst.FORWARD_INPUT_SUGGEST
+            else:
+                message = AdvisorConst.FORWARD_OUTPUT_SUGGEST
+                message = self.deterministic_advisor(message, node_name)
+        else:
+            if AdvisorConst.INPUT in node_name:
+                message = AdvisorConst.BACKWARD_INPUT_SUGGEST
+            else:
+                message = AdvisorConst.BACKWARD_OUTPUT_SUGGEST
+                message = self.deterministic_advisor(message, node_name)
+        message = self.batch_norm_advisor(message, node_name)
+        return message
+
+    def analysis(self):
+        self._check_path_vaild()
+        analyze_data = self._parse_input_data()
+        logger.info("Start analyzing the comparison result: %s" % self.file_type)
+        self.analyze_unmatched(analyze_data)
+        if self.file_type == Const.ALL:
+            failing_data = analyze_data[analyze_data[CompareConst.ACCURACY] == CompareConst.ACCURACY_CHECK_NO]
+        elif self.file_type == Const.MD5:
+            failing_data = analyze_data[analyze_data[CompareConst.RESULT] == CompareConst.DIFF]
+        elif self.file_type == Const.SUMMARY:
+            failing_data = analyze_data[analyze_data[CompareConst.RESULT] == CompareConst.WARNING]
+        if failing_data.empty:
+            logger.info("All data from api input/output accuracy reached")
+            result = AdvisorResult(AdvisorConst.NO_ERROR_API, AdvisorConst.NO_ERROR_API, AdvisorConst.NO_ERR_SUGGEST)
+        else:
+            result = self.gen_advisor_result(failing_data)
+        message_list = result.print_advisor_log()
+        result.gen_summary_file(self.out_path, message_list)
+
+    def _parse_input_data(self):
+        data_columns = self.input_data.columns.values
+        if {CompareConst.ACCURACY, CompareConst.NPU_NAME}.issubset(data_columns):
+            self.file_type = Const.ALL
+        elif {CompareConst.RESULT, CompareConst.NPU_MD5}.issubset(data_columns):
+            self.file_type = Const.MD5
+        elif {CompareConst.MAX_DIFF, CompareConst.RESULT}.issubset(data_columns):
+            self.file_type = Const.SUMMARY
+        else:
+            logger.error('Compare result does not meet the required conditions.')
+            raise CompareException(CompareException.INVALID_DATA_ERROR)
+        df = self.input_data.reset_index()
+        return df
+
+    def _check_path_vaild(self):
+        out_path_checker = FileChecker(self.out_path, FileCheckConst.DIR, FileCheckConst.WRITE_ABLE)
+        out_path_checker.common_check()