Qualcomm AI Engine Direct - Support backend awareness pass infrastructure (pytorch#20012)

### Summary

Introduce a backend-aware pass manager infrastructure for the Qualcomm
backend. The monolithic QnnPassManager is refactored into a base class
with overridable classmethods (`get_annotation_passes`,
`get_export_passes`, `get_preprocess_passes`, etc.), enabling
per-backend pass customization through inheritance.

Three backend subclasses pass manager are added:
- HTP / GPU — add `DecomposeReciprocal` (neither supports
ElementWiseUnary with reciprocal operation)
- LPAI — add `DecomposeReciprocal` + new `DecomposeHardsigmoid` pass,
swap `FoldQDQ` for `LpaiFoldQDQ` (preserves I/O Q/DQ to avoid v6
accuracy drop)

All call sites now use `get_qnn_pass_manager_cls(backend_type)()` to get
the correct pass manager instance.

### Test plan
- `python -m pytest
backends/qualcomm/tests/test_passes.py::TestPasses::test_decompose_hardsigmoid_backend_aware
-xvs`
- `python -m pytest
backends/qualcomm/tests/test_passes.py::TestPasses::test_decompose_reciprocal_backend_aware
-xvs`
- `python backends/qualcomm/tests/test_qnn_delegate.py
TestQNNQuantizedOperator.test_qnn_backend_hardsigmoid -b build-android/
-s d809c87f -m SM8850 --seed 1126 --backend lpai`

cc @cccclai @cbilgin @abhinaykukkadapu

Author: zhaoxul-qti

backends/qualcomm/_passes/BUCK

@@ -7,6 +7,7 @@ fbcode_target(_kind = runtime.python_library,
     name = "passes",
     srcs = glob([
         "*.py",
+        "backends/**/*.py",
     ]),
     visibility = ["PUBLIC"],
     deps = [

backends/qualcomm/_passes/__init__.py

@@ -24,6 +24,7 @@
 from .decompose_fill import DecomposeFill
 from .decompose_floor_divide import DecomposeFloorDivide
 from .decompose_glu import DecomposeGlu
+from .decompose_hardsigmoid import DecomposeHardsigmoid
 from .decompose_linalg_vector_norm import DecomposeLinalgVectorNorm
 from .decompose_log_variants import DecomposeLogVariants
 from .decompose_maxpool3d import DecomposeMaxPool3d
@@ -84,6 +85,7 @@
     DecomposeFill,
     DecomposeFloorDivide,
     DecomposeGlu,
+    DecomposeHardsigmoid,
     DecomposeLinalgVectorNorm,
     DecomposeLogVariants,
     DecomposeMaxPool3d,

backends/qualcomm/_passes/backends/__init__.py

@@ -0,0 +1,5 @@
+# Copyright (c) Qualcomm Innovation Center, Inc.
+# All rights reserved
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.

backends/qualcomm/_passes/backends/gpu/__init__.py

@@ -0,0 +1,11 @@
+# Copyright (c) Qualcomm Innovation Center, Inc.
+# All rights reserved
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+from .qnn_gpu_pass_manager import QnnGpuPassManager
+
+__all__ = [
+    QnnGpuPassManager,
+]

backends/qualcomm/_passes/backends/gpu/qnn_gpu_pass_manager.py

@@ -0,0 +1,49 @@
+# Copyright (c) Qualcomm Innovation Center, Inc.
+# All rights reserved
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+from executorch.backends.qualcomm._passes import DecomposeReciprocal, RemoveRedundancy
+from executorch.backends.qualcomm._passes.qnn_pass_manager import QnnPassManager
+
+
+class QnnGpuPassManager(QnnPassManager):
+    """
+    Pass manager for the GPU backend.
+
+    Extends QnnPassManager with GPU-specific graph transformations.
+    """
+
+    @classmethod
+    def get_default_pass_activations(cls):
+        # Reciprocal no longer appears at to_edge stage as it is decomposed in the export pipeline.
+        # The current change is intended to proactively prepare for the upcoming deprecation of the export pipeline.
+        pass_activations = super().get_default_pass_activations()
+        pass_activations.extend([(DecomposeReciprocal, True)])
+        return pass_activations
+
+    @classmethod
+    def get_passes_dependency_for_capture_program(cls):
+        # Reciprocal no longer appears at to_edge stage as it is decomposed in the export pipeline.
+        # The current change is intended to proactively prepare for the upcoming deprecation of the export pipeline.
+        deps = super().get_passes_dependency_for_capture_program()
+        deps.update({DecomposeReciprocal: [RemoveRedundancy]})
+        return deps
+
+    @classmethod
+    def get_annotation_passes(cls):
+        # The annotation pipeline is skipped for the GPU backend, as it does not
+        # support quantized data types. Return an empty list to indicate a no-op.
+        return []
+
+    @classmethod
+    def get_export_passes(
+        cls,
+        convert_linear_to_conv2d: bool = False,
+    ):
+        # DecomposeReciprocal should be placed in the export pipeline, as it depends on
+        # LiftConstantScalarOperands to lift the scalar operand.
+        passes = [DecomposeReciprocal]
+        passes.extend(super().get_export_passes(convert_linear_to_conv2d))
+        return passes

backends/qualcomm/_passes/backends/htp/__init__.py

@@ -0,0 +1,11 @@
+# Copyright (c) Qualcomm Innovation Center, Inc.
+# All rights reserved
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+from .qnn_htp_pass_manager import QnnHtpPassManager
+
+__all__ = [
+    QnnHtpPassManager,
+]

backends/qualcomm/_passes/backends/htp/qnn_htp_pass_manager.py

@@ -0,0 +1,49 @@
+# Copyright (c) Qualcomm Innovation Center, Inc.
+# All rights reserved
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+from executorch.backends.qualcomm._passes import DecomposeReciprocal, RemoveRedundancy
+from executorch.backends.qualcomm._passes.qnn_pass_manager import QnnPassManager
+
+
+class QnnHtpPassManager(QnnPassManager):
+    """
+    Pass manager for the HTP backend.
+
+    Extends QnnPassManager with HTP-specific graph transformations.
+    """
+
+    @classmethod
+    def get_default_pass_activations(cls):
+        # Reciprocal no longer appears at to_edge stage as it is decomposed in the export/annotation pipeline.
+        # The current change is intended to proactively prepare for the upcoming deprecation of the export pipeline.
+        pass_activations = super().get_default_pass_activations()
+        pass_activations.extend([(DecomposeReciprocal, True)])
+        return pass_activations
+
+    @classmethod
+    def get_passes_dependency_for_capture_program(cls):
+        # Reciprocal no longer appears at to_edge stage as it is decomposed in the export/annotation pipeline.
+        # The current change is intended to proactively prepare for the upcoming deprecation of the export pipeline.
+        deps = super().get_passes_dependency_for_capture_program()
+        deps.update({DecomposeReciprocal: [RemoveRedundancy]})
+        return deps
+
+    @classmethod
+    def get_annotation_passes(cls):
+        passes = [DecomposeReciprocal]
+        passes.extend(super().get_annotation_passes())
+        return passes
+
+    @classmethod
+    def get_export_passes(
+        cls,
+        convert_linear_to_conv2d: bool = False,
+    ):
+        # DecomposeReciprocal should be placed in the export pipeline, as it depends on
+        # LiftConstantScalarOperands to lift the scalar operand.
+        passes = [DecomposeReciprocal]
+        passes.extend(super().get_export_passes(convert_linear_to_conv2d))
+        return passes

backends/qualcomm/_passes/backends/lpai/__init__.py

@@ -0,0 +1,13 @@
+# Copyright (c) Qualcomm Innovation Center, Inc.
+# All rights reserved
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+from .fold_qdq import LpaiFoldQDQ
+from .qnn_lpai_pass_manager import QnnLpaiPassManager
+
+__all__ = [
+    LpaiFoldQDQ,
+    QnnLpaiPassManager,
+]

backends/qualcomm/_passes/backends/lpai/fold_qdq.py

@@ -0,0 +1,77 @@
+# Copyright (c) Qualcomm Innovation Center, Inc.
+# All rights reserved
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+import torch
+from executorch.backends.qualcomm._passes.fold_qdq import FoldQDQ
+from executorch.backends.qualcomm._passes.utils import get_quant_attrs
+from executorch.backends.qualcomm.builders.node_visitor import dq_ops
+from executorch.backends.qualcomm.builders.utils import (
+    is_graph_input,
+    is_graph_output,
+    is_parameter,
+)
+from executorch.backends.qualcomm.utils.constants import (
+    QCOM_BYPASS_NODE,
+    QCOM_FALLBACK_NODE,
+    QCOM_QUANT_ATTRS,
+    QCOM_QUANTIZED_IO,
+)
+
+
+class LpaiFoldQDQ(FoldQDQ):
+    """
+    LPAI-specific extension of FoldQDQ.
+
+    In LPAI backend v6, there is an accuracy drop for the quantize and
+    dequantize operations. To address this, keep the quantize/dequantize
+    operations at the model's input and output.
+
+    For example:
+        input -> q_1 (Fallback) -> dq_1 (Bypass) -> graph -> q_2 (Bypass) -> dq_2 (Fallback) -> output
+
+    Here, q_1 and dq_2 will fallback to CPU, while q_2 and dq_1 will be
+    bypassed in qnn_partition and folded in qnn_preprocess.
+    """
+
+    def _preserve_qdq(self, graph_module: torch.fx.GraphModule) -> torch.fx.GraphModule:
+        for n in graph_module.graph.nodes:
+            # skip parameters & buffers (base class logic)
+            if n.target in dq_ops and is_parameter(n.args[0], self.edge_program):
+                self._annotate_bypass(n)
+                continue
+
+            if (
+                is_graph_input(n, self.edge_program)
+                # For tagged quantized I/O, we should not fallback quantize operation.
+                and QCOM_QUANTIZED_IO not in n.meta
+            ):
+                user_list = list(n.users.keys())
+                if len(user_list) > 0:
+                    q_node = user_list[0]
+                    q_node.meta[QCOM_FALLBACK_NODE] = True
+                    # Annotate the q_node since it will serve as the input for the first node during operator validation
+                    q_node.meta[QCOM_QUANT_ATTRS] = get_quant_attrs(
+                        self.edge_program, q_node
+                    )
+                    q_node.meta[QCOM_QUANTIZED_IO] = q_node.args[-1]
+                    dq_node = list(q_node.users.keys())[0]
+                    # Bypass dequantize op for graph validation by torch
+                    dq_node.meta[QCOM_BYPASS_NODE] = True
+                    # Make sure that the quantize operator isn't inserted for input in insert_io_qdq.py
+                    n.meta[QCOM_QUANTIZED_IO] = q_node.args[-1]
+            elif (
+                is_graph_output(n)
+                and n.target in dq_ops
+                # For tagged quantized I/O, we should not fallback dequantize operation.
+                and QCOM_QUANTIZED_IO not in n.args[0].args[0].meta
+            ):
+                n.meta[QCOM_FALLBACK_NODE] = True
+                q_node = n.args[0]
+                # Bypass quantize op for graph validation by torch
+                q_node.meta[QCOM_BYPASS_NODE] = True
+                op_node = q_node.args[0]
+                # Make sure that the dequantize operator isn't inserted for output in insert_io_qdq.py
+                op_node.meta[QCOM_QUANTIZED_IO] = q_node.args[-1]

backends/qualcomm/_passes/backends/lpai/qnn_lpai_pass_manager.py

@@ -0,0 +1,78 @@
+# Copyright (c) Qualcomm Innovation Center, Inc.
+# All rights reserved
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+from executorch.backends.qualcomm._passes import (
+    DecomposeHardsigmoid,
+    DecomposeReciprocal,
+    FoldQDQ,
+    RemoveRedundancy,
+)
+from executorch.backends.qualcomm._passes.backends.lpai.fold_qdq import LpaiFoldQDQ
+from executorch.backends.qualcomm._passes.qnn_pass_manager import QnnPassManager
+
+
+class QnnLpaiPassManager(QnnPassManager):
+    """
+    Pass manager for the LPAI backend.
+
+    Extends QnnPassManager with LPAI-specific graph transformations.
+    """
+
+    @classmethod
+    def get_default_pass_activations(cls):
+        pass_activations = super().get_default_pass_activations()
+        pass_activations = [
+            (LpaiFoldQDQ if p is FoldQDQ else p, act) for p, act in pass_activations
+        ]
+        # Hardsigmoid and Reciprocal no longer appear at to_edge stage as it is decomposed in the export/annotation pipeline.
+        # The current change is intended to proactively prepare for the upcoming deprecation of the export pipeline.
+        pass_activations.extend(
+            [
+                (DecomposeHardsigmoid, True),
+                (DecomposeReciprocal, True),
+            ]
+        )
+        return pass_activations
+
+    @classmethod
+    def get_passes_dependency_for_capture_program(cls):
+        deps = super().get_passes_dependency_for_capture_program()
+        # Replace FoldQDQ with LpaiFoldQDQ in the dependency table
+        if FoldQDQ in deps:
+            deps[LpaiFoldQDQ] = deps.pop(FoldQDQ)
+        for key in deps:
+            deps[key] = [LpaiFoldQDQ if v is FoldQDQ else v for v in deps[key]]
+        # Hardsigmoid and Reciprocal no longer appear at to_edge stage as it is decomposed in the export/annotation pipeline.
+        # The current change is intended to proactively prepare for the upcoming deprecation of the export pipeline.
+        deps.update(
+            {
+                DecomposeHardsigmoid: [RemoveRedundancy],
+                DecomposeReciprocal: [RemoveRedundancy],
+            }
+        )
+        return deps
+
+    @classmethod
+    def get_annotation_passes(cls):
+        passes = [DecomposeHardsigmoid, DecomposeReciprocal]
+        passes.extend(super().get_annotation_passes())
+        return passes
+
+    @classmethod
+    def get_export_passes(
+        cls,
+        convert_linear_to_conv2d: bool = False,
+    ):
+        # Both DecomposeHardSigmoid and DecomposeReciprocal should be placed in the export
+        # pipeline, as they rely on LiftConstantScalarOperands to lift the scalar operand.
+        passes = [DecomposeHardsigmoid, DecomposeReciprocal]
+        passes.extend(super().get_export_passes(convert_linear_to_conv2d))
+        return passes
+
+    @classmethod
+    def get_preprocess_passes(cls, use_mha2sha=False):
+        passes = super().get_preprocess_passes(use_mha2sha)
+        return [LpaiFoldQDQ if p is FoldQDQ else p for p in passes]