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

msprobe/msaccucmp/advisor/advisor_result.py

@@ -0,0 +1,73 @@
+# 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 class mainly involves the advisor result function.
+"""
+import os
+
+from msprobe.msaccucmp.advisor.advisor_const import AdvisorConst
+from msprobe.msaccucmp.cmp_utils.constant.const_manager import ConstManager
+from msprobe.msaccucmp.cmp_utils import path_check
+from msprobe.msaccucmp.cmp_utils import log
+
+
+class AdvisorResult:
+    """
+    Class for generate advisor result
+    """
+
+    def __init__(self, match_advisor=False, advisor_type="NA", operator_index="NA", advisor_message="NA"):
+        self.match_advisor = match_advisor
+        self.advisor_type = advisor_type
+        self.operator_index = operator_index
+        self.advisor_message = advisor_message
+
+    @staticmethod
+    def gen_summary_file(out_path, message_list):
+        """
+        Generate advisor summary file
+        :param out_path: advisor summary file out path
+        :param  message_list: summary message
+        """
+        result_file = os.path.join(out_path, "advisor_summary.txt")
+        try:
+            path_check.check_write_path_secure(result_file)
+            with os.fdopen(os.open(result_file, ConstManager.WRITE_FLAGS, ConstManager.WRITE_MODES),
+                           'w+') as output_file:
+                output_file.truncate(0)
+                message_list = [message + AdvisorConst.NEW_LINE for message in message_list]
+                output_file.writelines(message_list)
+        except IOError as io_error:
+            log.print_error_log("Failed to save the advisor summary, the reason is %s." % io_error)
+        else:
+            log.print_info_log('The advisor summary (.txt) is saved in: "%r" .' % result_file)
+
+    def print_advisor_log(self):
+        """
+        Log and print advisor summary
+        """
+        log.print_info_log("The summary of the expert advice is as follows: ")
+        message_list = [
+            AdvisorConst.DETECTION_TYPE + AdvisorConst.COLON + self.advisor_type,
+            AdvisorConst.OPERATOR_INDEX + AdvisorConst.COLON + self.operator_index,
+            AdvisorConst.ADVISOR_SUGGEST + AdvisorConst.COLON + self.advisor_message
+        ]
+        for message in message_list:
+            log.print_info_log(message)
+        return message_list

msprobe/msaccucmp/advisor/compare_advisor.py

@@ -0,0 +1,99 @@
+# 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:
+Make advisor, perform comparative analysis, This class mainly involves the main function.
+"""
+
+import pandas as pd
+
+from msprobe.msaccucmp.cmp_utils import log
+from msprobe.msaccucmp.cmp_utils.constant.compare_error import CompareError
+from msprobe.msaccucmp.advisor.advisor_const import AdvisorConst
+from msprobe.msaccucmp.advisor.advisor_result import AdvisorResult
+from msprobe.msaccucmp.advisor.input_advisor import InputAdvisor
+from msprobe.msaccucmp.advisor.node_advisor import NodeAdvisor
+from msprobe.msaccucmp.advisor.overflow_advisor import OverflowAdvisor
+
+
+class CompareAdvisor:
+    """
+    Class for generate advisor
+    """
+
+    def __init__(self, input_file, input_nodes=None, out_path=""):
+        self.input_file = input_file
+        self.input_nodes = input_nodes
+        self.out_path = out_path
+
+    @staticmethod
+    def _overflow_check(advisor_result, analyze_data):
+        if not advisor_result.match_advisor:
+            overflow_advisor = OverflowAdvisor(analyze_data, advisor_result)
+            advisor_result = overflow_advisor.start_analyze()
+            if advisor_result.match_advisor:
+                log.print_info_log("The FP16 Overflow detection matches successfully.")
+            log.print_info_log("End FP16 Overflow detection.")
+        return advisor_result
+
+    @staticmethod
+    def _net_nodes_check(advisor_result, analyze_data):
+        if not advisor_result.match_advisor:
+            node_advisor = NodeAdvisor(analyze_data, advisor_result)
+            advisor_result = node_advisor.start_analyze()
+            if advisor_result.match_advisor:
+                log.print_info_log("The Global Consistency detection matches successfully.")
+            log.print_info_log("End Global Consistency detection.")
+        return advisor_result
+
+    def advisor(self):
+        analyze_data = self._parse_input_file()
+        log.print_info_log('Start analyzing the comparison results: "%r" .' % self.input_file)
+        advisor_result = AdvisorResult()
+        advisor_result = self._overflow_check(advisor_result, analyze_data)
+        advisor_result = self._input_check(advisor_result, analyze_data)
+        advisor_result = self._net_nodes_check(advisor_result, analyze_data)
+        log.print_info_log("Comparison result analysis is over.")
+        return advisor_result
+
+    def _input_check(self, advisor_result, analyze_data):
+        if not advisor_result.match_advisor and self.input_nodes:
+            input_advisor = InputAdvisor(analyze_data, advisor_result, self.input_nodes)
+            advisor_result = input_advisor.start_analyze()
+            if advisor_result.match_advisor:
+                log.print_info_log("The Input Inconsistent detection matches successfully.")
+            log.print_info_log("End Input Inconsistent detection.")
+        return advisor_result
+
+    def _parse_input_file(self):
+        if self.input_file.endswith(".csv"):
+            try:
+                df = pd.read_csv(self.input_file, on_bad_lines='skip')
+            except (OSError, SystemError, ValueError, TypeError, RuntimeError, MemoryError) as io_err:
+                log.print_error_log('Failed to parse the input file %r. %s'
+                                    % (self.input_file, str(io_err)))
+                raise CompareError(CompareError.MSACCUCMP_OPEN_FILE_ERROR) from io_err
+            data_columns = df.columns.values
+            if not {AdvisorConst.INDEX, AdvisorConst.NPU_DUMP}.issubset(data_columns):
+                log.print_error_log('Input csv file does not contain %s, %s columns.'
+                                    % (AdvisorConst.INDEX, AdvisorConst.NPU_DUMP))
+                raise CompareError(CompareError.MSACCUCMP_INVALID_FILE_ERROR)
+            return df
+        else:
+            log.print_error_log("Advisor only support csv file from msaccucmp result.")
+            raise CompareError(CompareError.MSACCUCMP_INVALID_FILE_ERROR)

msprobe/msaccucmp/advisor/input_advisor.py

@@ -0,0 +1,66 @@
+# 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 input advisor function.
+"""
+
+from msprobe.msaccucmp.cmp_utils import log
+from msprobe.msaccucmp.advisor.advisor_const import AdvisorConst
+from msprobe.msaccucmp.advisor.advisor_result import AdvisorResult
+
+
+class InputAdvisor:
+    """
+    Class for generate input advisor
+    """
+
+    def __init__(self, input_file, result, input_nodes):
+        self.analyze_data = input_file
+        self.result = result
+        self.input_nodes = input_nodes
+
+    def start_analyze(self):
+        """
+        Analyze result by input detection
+        """
+        log.print_info_log('Start Input Inconsistent detection.')
+        data_columns = self.analyze_data.columns.values
+        if AdvisorConst.COSINE_SIMILARITY not in data_columns:
+            log.print_warn_log('Input csv file does not contain %s columns, Skip Input Inconsistent detection.'
+                               % AdvisorConst.COSINE_SIMILARITY)
+            return self.result
+        else:
+            have_cos_df = self.analyze_data.dropna(subset=[AdvisorConst.COSINE_SIMILARITY])
+            # check cosine dataframe lines
+            if have_cos_df.shape[0] == 0:
+                log.print_warn_log('After analysis, input csv file %s column, does not have valid value. '
+                                   'May all values be NAN, please check.'
+                                   % AdvisorConst.COSINE_SIMILARITY)
+                return self.result
+            err_cos_df = have_cos_df[have_cos_df['CosineSimilarity'] < AdvisorConst.ACCURACY_THRESHOLD]
+            for input_node in self.input_nodes:
+                err_input_df = err_cos_df[err_cos_df[AdvisorConst.NPU_DUMP] == input_node]
+                err_input_df.reset_index(drop=True, inplace=True)
+                if err_input_df.shape[0] > 0:
+                    index = err_input_df.at[0, AdvisorConst.INDEX]
+                    return AdvisorResult(True, AdvisorConst.INPUT_DETECTION, str(index),
+                                         AdvisorConst.INPUT_SUGGEST)
+            return self.result
+
+

msprobe/msaccucmp/advisor/node_advisor.py

@@ -0,0 +1,68 @@
+# 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 node advisor function.
+"""
+
+from msprobe.msaccucmp.cmp_utils import log
+from msprobe.msaccucmp.advisor.advisor_const import AdvisorConst
+from msprobe.msaccucmp.advisor.advisor_result import AdvisorResult
+
+
+class NodeAdvisor:
+    """
+    Class for generate node advisor
+    """
+
+    def __init__(self, input_file, result):
+        self.analyze_data = input_file
+        self.result = result
+
+    def start_analyze(self):
+        """
+        Analyze result by node detection
+        """
+        log.print_info_log('Start Global Consistency detection.')
+        data_columns = self.analyze_data.columns.values
+        if AdvisorConst.COSINE_SIMILARITY not in data_columns:
+            log.print_warn_log('Input csv file does not contain %s columns, Skip Global Consistency detection.'
+                               % AdvisorConst.COSINE_SIMILARITY)
+            return self.result
+        else:
+            have_cos_df = self.analyze_data.dropna(subset=[AdvisorConst.COSINE_SIMILARITY])
+            # check cosine dataframe lines
+            if have_cos_df.shape[0] == 0:
+                log.print_warn_log('After analysis, input csv file %s column, does not have valid value. '
+                                   'May all values be NAN, please check.'
+                                   % AdvisorConst.COSINE_SIMILARITY)
+                return self.result
+            cos_df = have_cos_df.reset_index(drop=True, inplace=False)
+            err_cos_df = have_cos_df[have_cos_df[AdvisorConst.COSINE_SIMILARITY] < AdvisorConst.ACCURACY_THRESHOLD]
+            if err_cos_df.shape[0] == 0:
+                return AdvisorResult(True, AdvisorConst.CONSISTENCY_DETECTION,
+                                     AdvisorConst.NO_ERROR_OP, AdvisorConst.CONSISTENCY_SUGGEST)
+            err_cos_df.reset_index(drop=True, inplace=True)
+            index = err_cos_df.at[0, AdvisorConst.INDEX]
+            cos_df_len = cos_df.shape[0]
+            last_line_cos = cos_df.at[cos_df_len - 1, AdvisorConst.COSINE_SIMILARITY]
+            if last_line_cos < AdvisorConst.ACCURACY_THRESHOLD:
+                return AdvisorResult(True, AdvisorConst.CONSISTENCY_DETECTION,
+                                     str(index), AdvisorConst.PROBLEM_SUGGEST)
+            return AdvisorResult(True, AdvisorConst.CONSISTENCY_DETECTION,
+                                 str(index), AdvisorConst.DEVIATION_SUGGEST)

msprobe/msaccucmp/advisor/overflow_advisor.py

@@ -0,0 +1,58 @@
+# 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 overflow advisor function.
+"""
+
+from msprobe.msaccucmp.cmp_utils import log
+from msprobe.msaccucmp.advisor.advisor_const import AdvisorConst
+from msprobe.msaccucmp.advisor.advisor_result import AdvisorResult
+
+
+class OverflowAdvisor:
+    """
+    Class for generate overflow advisor
+    """
+
+    def __init__(self, input_file, result):
+        self.analyze_data = input_file
+        self.result = result
+
+    def start_analyze(self):
+        """
+        Analyze result by overflow detection
+        """
+        log.print_info_log('Start FP16 Overflow detection.')
+        data_columns = self.analyze_data.columns.values
+        if AdvisorConst.OVERFLOW not in data_columns:
+            log.print_warn_log('Input csv file does not contain %s columns, Skip FP16 Overflow detection.'
+                               % AdvisorConst.OVERFLOW)
+        else:
+            overflow_df = self.analyze_data[self.analyze_data[AdvisorConst.OVERFLOW] == "YES"]
+            # check overflow dataframe lines
+            if overflow_df.shape[0] == 0:
+                log.print_info_log('After analysis, input csv file does not have FP16 Overflow problem.')
+                return self.result
+            overflow_df.reset_index(drop=True, inplace=True)
+            index = overflow_df.at[0, AdvisorConst.INDEX]
+            self.result = AdvisorResult(True, AdvisorConst.OVERFLOW_DETECTION, str(index),
+                                        AdvisorConst.OVERFLOW_SUGGEST)
+        return self.result
+
+

msprobe/msaccucmp/algorithm_manager/__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.
+# -------------------------------------------------------------------------
+