Class QnnQuantizer

backends/qualcomm/quantizer/quantizer.py:290–598

QnnQuantizer is a quantization annotator designed for QNN backends. It utilizes the rules_map found in the respective {backend}_rules.py file, which is a dictionary that links OpOverload to both annotator and validation functions. This mapping guides how each node is annotated and v

class QnnQuantizer(Quantizer):
    """
    QnnQuantizer is a quantization annotator designed for QNN backends.
    It utilizes the rules_map found in the respective {backend}_rules.py file,
    which is a dictionary that links OpOverload to both annotator and validation functions.
    This mapping guides how each node is annotated and validated for quantization.

    During validation, the backend_opinfo pybind library containing operation details
    from the QNN SDK is used to verify quantization constraints and maintain backend compatibility.
    This library is available with QNN SDK version 2.41 or later.
    If the library is unavailable, QnnQuantizer will not validate quantization constraints for operations.

    Args:
        backend: QnnQuantizer uses the backend_type to dynamically load the appropriate backend rules as needed.
        soc_model: QnnQuantizer checks each operation according to the soc_model. For example, LPBQ requires V69 or a newer version.
        strict:
          When enabled (default), the validation stage raises a ValueError if quantization constraints are not met.
          In this mode, all quantization constraints must be satisfied to fully delegate to the QNN Backend.
          When disabled, only warnings will be logged.

    Example usage:
        quantizer = QnnQuantizer(
            backend=QnnExecuTorchBackendType.kHtpBackend,
            soc_model=QcomChipset.SM8750
        )
        quantizer.set_default_quant_config(
            quant_dtype=QuantDtype.use_8a8w,
            is_qat=False,
            is_conv_per_channel=True,
            is_linear_per_channel=True,
            act_observer=MovingAverageMinMaxObserver,
        )
        quantizer.set_block_size_map({"conv2d": (1, 128, 1, 1)})
        quantizer.set_submodule_qconfig_list([
            (get_submodule_type_predicate("Add"), ModuleQConfig(quant_dtype=QuantDtype.use_16a4w))
        ])
        quantizer.add_custom_quant_annotations(...)
        quantizer.add_discard_nodes([node.name to skip annotation])
        quantizer.add_discard_ops([node.target to skip annotation])

    """

    def __init__(
        self,
        backend: QnnExecuTorchBackendType = QnnExecuTorchBackendType.kHtpBackend,
        soc_model: QcomChipset = QcomChipset.SM8750,
        strict: bool = True,
    ):
        super().__init__()
        self.strict = strict
        self.backend = str(backend)
        self.soc_info = _soc_info_table[soc_model]

        # Lazy load rules and constraints of current backend
        self._rules_map, self._constraint_cache = load_backend_rules_and_constraints(
            self.backend
        )
        self.supported_ops: Set[OpOverload] = set(self._rules_map.keys())