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

msprobe/msaccucmp/vector_cmp/fusion_manager/quant_filter.py

@@ -0,0 +1,187 @@
+# 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:
+Quant Filter class, process the fusion json file
+"""
+import re
+
+from msprobe.msaccucmp.cmp_utils import log
+
+
+class QuantFilter:
+    """
+    the class for recognize and filter the quant/dequant ops
+    """
+
+    NORMAL_OP = 0
+    MIDDLE_OP = 1
+    QUANT_OP = 2
+    DEQUANT_OP = 3
+    QUANT_DEQUANT_OP = 5
+
+    def __init__(self: any, op_list: list) -> None:
+        """
+        :param op_list: the list of parsed ops
+        """
+        self._op_list = op_list
+        self._op_output_type_map = {}  # structure like {op_name: [out1_type, out2_type]}
+        self._quant_name_pattern = r"_quant_layer|/AscendQuant|/AscendWeightQuant|\.quant|\.weight_quant"
+        self._dequant_name_pattern = \
+            r"_dequant_layer|_anti_quant_layer|/AscendDequant|/AntiQuant|\.dequant|\.anti_quant"
+
+    @staticmethod
+    def _check_out_type(op_name: str, name_type: int, in_pairs: bool, output_node: any) -> int:
+        data_type = output_node.data_type
+        _out_type = QuantFilter._match_existing_type(name_type, data_type, in_pairs)
+
+        # Not matched type, treat as a normal op
+        if _out_type is None:
+            log.print_warn_log("[{}] this op looks like a quantization op, but it does not have proper output type"
+                               .format(op_name))
+            if in_pairs:
+                _out_type = QuantFilter.MIDDLE_OP
+            else:
+                _out_type = QuantFilter.NORMAL_OP
+        return _out_type
+
+    @staticmethod
+    def _match_existing_type(name_type: int, data_type: str, in_pairs: bool) -> int:
+        _matched_type = None
+        if name_type == QuantFilter.NORMAL_OP:
+            if in_pairs:
+                _matched_type = QuantFilter.MIDDLE_OP
+            else:
+                _matched_type = QuantFilter.NORMAL_OP
+        elif name_type == QuantFilter.QUANT_OP:
+            if data_type == "DT_INT8":
+                _matched_type = QuantFilter.QUANT_OP
+        elif name_type == QuantFilter.DEQUANT_OP:
+            if data_type == "DT_FLOAT16":
+                _matched_type = QuantFilter.DEQUANT_OP
+        elif name_type == QuantFilter.QUANT_DEQUANT_OP:
+            # 5--quant & dequant
+            if data_type == "DT_INT8":
+                _matched_type = QuantFilter.QUANT_OP
+            if data_type == "DT_FLOAT16":
+                _matched_type = QuantFilter.DEQUANT_OP
+
+        return _matched_type
+
+    def process_filtering(self: any) -> None:
+        """
+        check through the op list, mark in attr.is_quant_filter the ops should be filtered.
+        """
+        self._op_output_type_map = {}
+
+        # fetch ops in order
+        for op in self._op_list:
+
+            _op_name = op.op_name
+
+            # check name type using regex
+            _name_type = self._check_name_type(op)
+
+            # check inputs to determine if in middle of pairs
+            _in_pairs = self._check_in_pairs(op)
+
+            # store the output type of each output desc
+            self._op_output_type_map[_op_name] = []
+
+            for output in op.output_desc:
+                # combine the conditions above to determine filtering or not
+                _out_type = QuantFilter._check_out_type(_op_name, _name_type, _in_pairs, output)
+                self._op_output_type_map[_op_name].append(_out_type)
+
+            # store filter result in result set
+            self._add_filter_list(op, _in_pairs)
+
+    def get_out_type_map(self: any) -> dict:
+        """
+        get output type map
+
+        :return: output map
+        """
+        return self._op_output_type_map
+
+    def _check_in_pairs(self: any, op: any) -> bool:
+        _inputs = op.input_list
+
+        _is_in_pair = False
+        for _input in _inputs:
+            if ':' not in _input:
+                continue
+            last_colon_index = _input.rfind(':')
+            _input_name = _input[:last_colon_index]
+            if _input[last_colon_index + 1:].isdigit():
+                _input_out_index = int(_input[last_colon_index + 1:])
+            else:
+                log.print_warn_log("[{}] the input operator of op with index {} is invalid."
+                                   .format(op.op_name, _input))
+                continue
+            _out_list = self._op_output_type_map.get(_input_name)
+            if _out_list is None or len(_out_list) <= _input_out_index:
+                log.print_warn_log("[{}] the input operator of op {} does not exist in previous graph."
+                                   .format(op.op_name, _input_name))
+                continue
+            _input_out_type = _out_list[_input_out_index]
+            if _input_out_type in (QuantFilter.QUANT_OP, QuantFilter.MIDDLE_OP):
+                _is_in_pair = True
+                break
+
+        return _is_in_pair
+
+    def _add_filter_list(self: any, op: any, in_pairs: bool) -> None:
+        _outputs = self._op_output_type_map.get(op.op_name)
+        _is_dequant = True
+        for _output in _outputs:
+            if _output != QuantFilter.DEQUANT_OP:
+                _is_dequant = False
+                break
+        _need_filter = in_pairs and not _is_dequant
+
+        op.attr.quant_filter = _need_filter
+
+    def _check_name_type(self, op) -> int:
+        """
+        check the op type with name, using regex
+
+        :param op: the op name need to be checked
+        :return: type of this op, Quant=2/Dequant=3/Quant&Dequant=5/Normal=0
+        """
+
+        _op_type = QuantFilter.NORMAL_OP
+
+        # All the keywords of quant/dequant ops:
+        # caffe: "_quant_layer", "_dequant_layer", "_anti_quant_layer"
+        # tensorflow: "/AscendQuant", "/AscendWeightQuant", "/AscendDequant", "/AntiQuant"
+        # onnx: ".quant", ".weight_quant", ".dequant", ".anti_quant"
+
+        # find quant keywords
+        if re.search(self._quant_name_pattern, op.op_name):
+            _op_type += QuantFilter.QUANT_OP
+        elif re.search(self._quant_name_pattern, ''.join(op.attr.original_op_names)):
+            _op_type += QuantFilter.QUANT_OP
+
+        # find dequant keywords
+        if re.search(self._dequant_name_pattern, op.op_name):
+            _op_type += QuantFilter.DEQUANT_OP
+        elif re.search(self._dequant_name_pattern, ''.join(op.attr.original_op_names)):
+            _op_type += QuantFilter.DEQUANT_OP
+
+        return _op_type

msprobe/msaccucmp/vector_cmp/range_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.
+# -------------------------------------------------------------------------
+

msprobe/msaccucmp/vector_cmp/range_manager/range_manager.py

@@ -0,0 +1,100 @@
+# 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:
+RangeManager class.
+This class mainly involves the get function.
+"""
+
+import sys
+from abc import ABC, abstractmethod
+
+from msprobe.msaccucmp.cmp_utils.constant.const_manager import ConstManager
+from msprobe.msaccucmp.vector_cmp.fusion_manager.compare_rule import CompareRule
+
+
+class RangeManager(ABC):
+    """
+    The class for range manager
+    """
+
+    def __init__(self: any, input_str: str) -> None:
+        self.input_str = input_str
+
+    @staticmethod
+    def adjust_header(header: list) -> None:
+        """
+        adjust header by range
+        :param header: the header
+        """
+        if RangeManager._has_cmd():
+            header.insert(ConstManager.OP_SEQUENCE_INDEX, ConstManager.OP_SEQUENCE)
+
+    @staticmethod
+    def adjust_data(data: list, op_sequence: int) -> None:
+        """
+        adjust data by range
+        :param data: the data
+        :param op_sequence: the op_sequence
+        """
+        if RangeManager._has_cmd():
+            data.insert(ConstManager.OP_SEQUENCE_INDEX, str(op_sequence))
+
+    @staticmethod
+    def _get_op_list(op_list: list, compare_rule: CompareRule) -> list:
+        range_op_name = []
+        for op in op_list:
+            fusion_op_name = compare_rule.fusion_info.op_name_to_fusion_op_name_map.get(op.op_name)
+            if fusion_op_name not in range_op_name:
+                range_op_name.append(fusion_op_name)
+        return range_op_name
+
+    @staticmethod
+    def _has_cmd() -> bool:
+        """
+        Check the argument has range
+        :return: bool
+        """
+        # excluding compare_vector.py commands of old versions
+        support_cmd_list = ['-r', '-s', '--range', '--select']
+        match = False
+        for item in sys.argv:
+            if item in support_cmd_list:
+                match = True
+                break
+        return match and 'compare_vector.py' not in sys.argv[0]
+
+    @staticmethod
+    def _parse_input_str(input_str: str):
+        pass
+
+    @abstractmethod
+    def get_all_ops(self: any, compare_rule: CompareRule):
+        """
+        Get all operators:
+        :param compare_rule: the compare rule
+        """
+        pass
+
+    @abstractmethod
+    def check_input_valid(self: any, op_count: int):
+        """
+        Check range valid:
+        :param op_count: the op count
+        """
+        pass

msprobe/msaccucmp/vector_cmp/range_manager/range_mode.py

@@ -0,0 +1,94 @@
+# 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:
+RangeMode class.
+This class mainly involves functions for selecting operators.
+"""
+
+from msprobe.msaccucmp.cmp_utils.constant.const_manager import ConstManager
+from msprobe.msaccucmp.cmp_utils.reg_manager import RegManager
+from msprobe.msaccucmp.cmp_utils import log
+from msprobe.msaccucmp.vector_cmp.fusion_manager.compare_rule import CompareRule
+from msprobe.msaccucmp.cmp_utils.constant.compare_error import CompareError
+from msprobe.msaccucmp.vector_cmp.range_manager import range_manager
+
+
+class RangeMode(range_manager.RangeManager):
+    """
+    The subclass of range manager
+    """
+
+    def __init__(self: any, input_str: str) -> None:
+        super(range_manager.RangeManager, self).__init__()
+        self.start, self.end, self.step = self._parse_input_str(input_str)
+
+    @staticmethod
+    def _parse_input_str(input_str: str) -> (int, int, int):
+        cur_range = [ConstManager.DEFAULT_START, ConstManager.DEFAULT_END, ConstManager.DEFAULT_STEP]
+        range_list = input_str.split(',')
+        if len(range_list) != len(cur_range):
+            log.print_error_log('The range (%s) is invalid, just supports "start,end,step".' % input_str)
+            raise CompareError(CompareError.MSACCUCMP_INVALID_PARAM_ERROR)
+        for index, item in enumerate(range_list):
+            value = item.strip()
+            if not value:
+                continue
+            if index == ConstManager.END_INDEX and value == '-1':
+                continue
+            if not RegManager.match_pattern(RegManager.NUMBER_PATTERN, value):
+                log.print_error_log('The range (%s) is invalid, just supports '
+                                    '"start,end,step", the value is number.' % input_str)
+                raise CompareError(CompareError.MSACCUCMP_INVALID_PARAM_ERROR)
+            cur_range[index] = int(value)
+        return (x for x in cur_range)
+
+    def get_all_ops(self: any, compare_rule: CompareRule) -> list:
+        """
+        Get all operators according to [start, end, step]:
+        :param compare_rule: the compare rule
+        :return: operator list
+        """
+        op_list = []
+        for op in compare_rule.fusion_info.op_list:
+            op_sequence = op.attr.get_op_sequence()
+            if op_sequence > self.end:
+                break
+            if op_sequence < self.start:
+                continue
+            if self.start == op_sequence or self.end == op_sequence or ((op_sequence - self.start) % self.step) == 0:
+                op_list.append(op)
+        return self._get_op_list(op_list, compare_rule)
+
+    def check_input_valid(self: any, op_count: int) -> None:
+        """
+        Check range valid:
+        :param op_count: the op count
+        """
+        if self.start < 1 or self.start > op_count:
+            log.print_out_of_range_error('', 'start', self.start, '[1, %d]' % op_count)
+            raise CompareError(CompareError.MSACCUCMP_INDEX_OUT_OF_BOUNDS_ERROR)
+        if self.end == -1:
+            self.end = op_count
+        if self.end < self.start or self.end > op_count:
+            log.print_out_of_range_error('', 'end', self.end, '[1, %d]' % op_count)
+            raise CompareError(CompareError.MSACCUCMP_INDEX_OUT_OF_BOUNDS_ERROR)
+        if self.step < 1 or self.step >= op_count:
+            log.print_out_of_range_error('', 'step', self.step, '[1, %d)' % op_count)
+            raise CompareError(CompareError.MSACCUCMP_INDEX_OUT_OF_BOUNDS_ERROR)
+        log.print_info_log('The range compare for [%d,%d,%d].' % (self.start, self.end, self.step))

msprobe/msaccucmp/vector_cmp/range_manager/select_mode.py

@@ -0,0 +1,86 @@
+# 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:
+SelectMode class.
+This class mainly involves functions for selecting operators.
+"""
+
+from msprobe.msaccucmp.cmp_utils.reg_manager import RegManager
+from msprobe.msaccucmp.cmp_utils import log
+from msprobe.msaccucmp.vector_cmp.fusion_manager.compare_rule import CompareRule
+from msprobe.msaccucmp.cmp_utils.constant.compare_error import CompareError
+from msprobe.msaccucmp.vector_cmp.range_manager import range_manager
+
+
+class SelectMode(range_manager.RangeManager):
+    """
+    The subclass of range manager
+    """
+
+    def __init__(self: any, input_str: str) -> None:
+        super(range_manager.RangeManager, self).__init__()
+        self.selected_op = self._parse_input_str(input_str)
+
+    @staticmethod
+    def _parse_input_str(input_str: str) -> list:
+        input_operators = []
+        index_list = input_str.split(',')
+        for item in index_list:
+            value = item.strip()
+            if not value:
+                continue
+            if not RegManager.match_pattern(RegManager.NUMBER_PATTERN, value):
+                log.print_error_log('The index (%s) is invalid, just supports '
+                                    '"index_1, index_2, ...", the value is zero or a positive number.' % input_str)
+                raise CompareError(CompareError.MSACCUCMP_INVALID_PARAM_ERROR)
+            input_operators.append(int(value))
+        selected_operators = list(set(input_operators))
+        index_list_sorted = sorted(selected_operators)
+        return index_list_sorted
+
+    def get_all_ops(self: any, compare_rule: CompareRule) -> list:
+        """
+        Get all operators according to indexes:
+        :param compare_rule: the compare rule
+        :return: operator list
+        """
+        op_list = [op for op in compare_rule.fusion_info.op_list if op.attr.get_op_sequence() in self.selected_op]
+        return self._get_op_list(op_list, compare_rule)
+
+    def check_input_valid(self: any, op_count: int) -> None:
+        """
+        Check range valid:
+        :param op_count: the op count
+        """
+        op_list = []
+        out_of_range_list = []
+        for value in self.selected_op:
+            if value <= op_count:
+                op_list.append(value)
+            else:
+                out_of_range_list.append(value)
+        if out_of_range_list:
+            invalid_ops = str(out_of_range_list)
+            message = 'Index %s out of range ' % invalid_ops + '[1,%d].' % op_count
+            if not op_list:
+                log.print_error_log(message)
+                raise CompareError(CompareError.MSACCUCMP_INVALID_PARAM_ERROR)
+            log.print_warn_log(message)
+        self.selected_op = op_list
+        log.print_info_log('Operator list %s is valid.' % (str(self.selected_op)))