Add qnn recipe

cccclai · cccclai · commit a704ac37eceb · 2025-08-06T15:25:24.000-07:00
diff --git a/install_dev.py b/install_dev.py
@@ -5,21 +5,21 @@
 
 def install_torch_nightly_deps():
     """Install torch related dependencies from pinned nightly"""
-    EXECUTORCH_NIGHTLY_VERSION = "dev20250625"
-    TORCHAO_NIGHTLY_VERSION = "dev20250620"
+    EXECUTORCH_NIGHTLY_VERSION = "dev20250801"
+    TORCHAO_NIGHTLY_VERSION = "dev20250801"
     # Torch nightly is aligned with pinned nightly in https://github.com/pytorch/executorch/blob/main/install_requirements.py#L74
-    TORCH_NIGHTLY_VERSION = "dev20250601"
+    TORCH_NIGHTLY_VERSION = "dev20250801"
     subprocess.check_call(
         [
             sys.executable,
             "-m",
             "pip",
             "install",
-            f"executorch==0.7.0.{EXECUTORCH_NIGHTLY_VERSION}",
-            f"torch==2.8.0.{TORCH_NIGHTLY_VERSION}",
-            f"torchvision==0.23.0.{TORCH_NIGHTLY_VERSION}",
+            f"executorch==0.8.0.{EXECUTORCH_NIGHTLY_VERSION}",
+            f"torch==2.9.0.{TORCH_NIGHTLY_VERSION}",
+            f"torchvision==0.24.0.{TORCH_NIGHTLY_VERSION}",
             f"torchaudio==2.8.0.{TORCH_NIGHTLY_VERSION}",
-            f"torchao==0.12.0.{TORCHAO_NIGHTLY_VERSION}",
+            f"torchao==0.13.0.{TORCHAO_NIGHTLY_VERSION}",
             "--extra-index-url",
             "https://download.pytorch.org/whl/nightly/cpu",
         ]
diff --git a/optimum/exporters/executorch/recipe_registry.py b/optimum/exporters/executorch/recipe_registry.py
@@ -45,6 +45,7 @@ def my_new_recipe(...):
     """
 
     def decorator(func):
+        print("recipe_name: ", recipe_name)
         recipe_registry[recipe_name] = func
         return func
 
diff --git a/optimum/exporters/executorch/recipes/__init__.py b/optimum/exporters/executorch/recipes/__init__.py
@@ -12,4 +12,4 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from . import xnnpack
+from . import qnn, xnnpack
diff --git a/optimum/exporters/executorch/recipes/qnn.py b/optimum/exporters/executorch/recipes/qnn.py
@@ -0,0 +1,225 @@
+# Copyright 2025 The HuggingFace Team. 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 logging
+from itertools import product
+from typing import Any, Dict, Union
+
+from executorch.backends.qualcomm._passes.qnn_pass_manager import QnnPassManager
+from executorch.backends.qualcomm.partition.qnn_partitioner import (
+    generate_qnn_executorch_option,
+    get_skip_decomp_table,
+    QnnPartitioner,
+)
+
+# Import here because QNNtools might not be available in all environments
+from executorch.backends.qualcomm.qnn_preprocess import QnnBackend
+from executorch.backends.qualcomm.quantizer.quantizer import QnnQuantizer
+from executorch.backends.qualcomm.utils.utils import (
+    generate_htp_compiler_spec,
+    generate_qnn_executorch_compiler_spec,
+    get_soc_to_chipset_map,
+    qnn_edge_config,
+    to_edge_transform_and_lower_to_qnn,
+)
+
+from executorch.devtools.backend_debug import get_delegation_info
+from executorch.exir import (
+    EdgeCompileConfig,
+    ExecutorchBackendConfig,
+    ExecutorchProgram,
+    to_edge_transform_and_lower,
+)
+
+from tabulate import tabulate
+from torch.export import ExportedProgram
+
+from ..integrations import (
+    CausalLMExportableModule,
+    MaskedLMExportableModule,
+    Seq2SeqLMExportableModule,
+)
+from ..recipe_registry import register_recipe
+
+
+def _export_to_executorch(
+    model: Union[
+        CausalLMExportableModule, MaskedLMExportableModule, Seq2SeqLMExportableModule
+    ],
+    **kwargs,
+):
+    """
+    Export a PyTorch model to ExecuTorch w/ delegation to QNN backend.
+
+    This function also write metadata required by the ExecuTorch runtime to the model.
+
+    Args:
+        model (Union[CausalLMExportableModule, MaskedLMExportableModule, Seq2SeqLMExportableModule]):
+            The PyTorch model to be exported to ExecuTorch.
+        **kwargs:
+            Additional keyword arguments for recipe-specific configurations, e.g. export using different example inputs, or different compile/bechend configs.
+
+    Returns:
+        Dict[str, ExecutorchProgram]:
+            A map of exported and optimized program for ExecuTorch.
+            For encoder-decoder models or multimodal models, it may generate multiple programs.
+    """
+
+    def _lower_to_executorch(
+        exported_programs: Dict[str, ExportedProgram],
+        metadata,
+        dtype,
+        soc,
+    ) -> Dict[str, ExecutorchProgram]:
+
+        et_progs = {}
+        backend_config_dict = {}
+        compiler_spec = generate_qnn_executorch_compiler_spec(
+            soc_model=get_soc_to_chipset_map()[soc],
+            backend_options=generate_htp_compiler_spec(use_fp16=True),
+        )
+        aten_programs = {}
+        transform_passes = {}
+        qnn_partitioner = QnnPartitioner(
+            compiler_specs=compiler_spec,
+            skip_node_id_set=None,
+            skip_node_op_set=None,
+            skip_mutable_buffer=None,
+        )
+
+        for pte_name, exported_program in exported_programs.items():
+            logging.debug(f"\nExported program for {pte_name}.pte: {exported_program}")
+            exported_program = QnnPassManager().transform_for_export_pipeline(
+                exported_program
+            )
+            transform_passes = QnnPassManager().get_to_edge_transform_passes(
+                exported_program
+            )
+            et_progs[pte_name] = to_edge_transform_and_lower(
+                programs=exported_program,
+                transform_passes=transform_passes,
+                partitioner=[qnn_partitioner],
+                constant_methods=None,
+                compile_config=qnn_edge_config(),
+            ).to_executorch(
+                config=ExecutorchBackendConfig(**backend_config_dict),
+            )
+            logging.debug(
+                f"\nExecuTorch program for {pte_name}.pte: {et_progs[pte_name].exported_program().graph_module}"
+            )
+            delegation_info = get_delegation_info(
+                et_progs[pte_name].exported_program().graph_module
+            )
+            logging.debug(
+                f"\nDelegation info Summary for {pte_name}.pte: {delegation_info.get_summary()}"
+            )
+            logging.debug(
+                f"\nDelegation info for {pte_name}.pte: {tabulate(delegation_info.get_operator_delegation_dataframe(), headers='keys', tablefmt='fancy_grid')}"
+            )
+        return et_progs
+
+    exported_progs = model.export()
+    print("model.metadata: ", model.metadata)
+    print("len(exported_progs): ", len(exported_progs))
+    for pte_name, exported_program in exported_progs.items():
+        print(
+            "\nExported program for ",
+            pte_name,
+            ".pte: ",
+            len(exported_program.graph_module.graph.nodes),
+        )
+
+    et_progs = {}
+    backend_config_dict = {}
+    compiler_spec = generate_qnn_executorch_compiler_spec(
+        soc_model=get_soc_to_chipset_map()[soc],
+        backend_options=generate_htp_compiler_spec(use_fp16=True),
+    )
+    aten_programs = {}
+    transform_passes = {}
+    qnn_partitioner = QnnPartitioner(
+        compiler_specs=compiler_spec,
+        skip_node_id_set=None,
+        skip_node_op_set=None,
+        skip_mutable_buffer=None,
+    )
+
+    for pte_name, exported_program in exported_progs.items():
+        print(f"\nExported program for {pte_name}.pte")
+        print("start QnnPassManager().transform_for_export_pipeline...")
+        exported_program = QnnPassManager().transform_for_export_pipeline(
+            exported_program
+        )
+        print("end QnnPassManager().transform_for_export_pipeline...")
+        print("start QnnPassManager().get_to_edge_transform_passes...")
+        transform_passes = QnnPassManager().get_to_edge_transform_passes(
+            exported_program
+        )
+        print("end QnnPassManager().get_to_edge_transform_passes...")
+        print("start to_edge_transform_and_lower...")
+        print("to_edge_transform_and_lower: ", to_edge_transform_and_lower)
+        et_progs[pte_name] = to_edge_transform_and_lower(
+            programs=exported_program,
+            transform_passes=transform_passes,
+            partitioner=[qnn_partitioner],
+            constant_methods=None,
+            compile_config=qnn_edge_config(),
+        ).to_executorch(
+            config=ExecutorchBackendConfig(**backend_config_dict),
+        )
+        print(
+            f"\nExecuTorch program for {pte_name}.pte: {et_progs[pte_name].exported_program().graph_module}"
+        )
+        delegation_info = get_delegation_info(
+            et_progs[pte_name].exported_program().graph_module
+        )
+        print(
+            f"\nDelegation info Summary for {pte_name}.pte: {delegation_info.get_summary()}"
+        )
+        print(
+            f"\nDelegation info for {pte_name}.pte: {tabulate(delegation_info.get_operator_delegation_dataframe(), headers='keys', tablefmt='fancy_grid')}"
+        )
+    return et_progs
+
+    # return _lower_to_executorch(exported_progs, model.metadata, **kwargs)
+
+
+def _get_recipe_kwargs(dtype: str, soc: str) -> Dict[str, Any]:
+    recipe_kwargs = {
+        "dtype": dtype,
+        "soc": soc,
+    }
+    return recipe_kwargs
+
+
+def _make_recipe(recipe_name, recipe_kwargs):
+    @register_recipe(recipe_name)
+    def recipe_fn(exported_programs: Dict[str, ExportedProgram], **kwargs):
+        print(
+            "register_recipe, recipe_name, recipe_kwargs: ", recipe_name, recipe_kwargs
+        )
+        return _export_to_executorch(
+            exported_programs,
+            **recipe_kwargs,
+        )
+
+    return recipe_fn
+
+
+# Register recipes for qnn backend
+for dtype, soc in product(["fp16"], ["SM8650", "SM8550", "SM8450"]):
+    recipe_name = f"qnn_{dtype}"
+    recipe_name += f"_{soc}"
+    recipe_kwargs = _get_recipe_kwargs(dtype=dtype, soc=soc)
+    _make_recipe(recipe_name, recipe_kwargs)
diff --git a/scripts/install_executorch_qnn.py b/scripts/install_executorch_qnn.py
@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+
+import os
+import shutil
+import subprocess
+import sys
+
+# Configuration
+COMMIT_HASH = "b29a627c958eca2d4ff89db90fa7206ee8d94d37"
+REPO_URL = "https://github.com/pytorch/executorch.git"
+TARGET_DIR = "/tmp/executorch"
+INSTALL_SCRIPT = "install_executorch.py"
+INSTALL_MARKER = ".installed_successfully"
+QNN_INSTALL_SCRIPT = "backends/qualcomm/scripts/install_qnn_sdk.sh"
+BUILD_SCRIPT = "backends/qualcomm/scripts/build.sh"
+
+
+def run_command(cmd, cwd=None):
+    """Run a shell command with real-time output streaming"""
+    print(f"$ {' '.join(cmd)}")
+    if cwd:
+        print(f"  [in {cwd}]")
+
+    # Start the process
+    process = subprocess.Popen(
+        cmd,
+        cwd=cwd,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+        bufsize=1,  # Line buffered
+        universal_newlines=True,
+    )
+
+    # Stream output line by line
+    for line in process.stdout:
+        print(line, end="", flush=True)
+
+    # Wait for process to finish and get exit code
+    return_code = process.wait()
+
+    if return_code != 0:
+        print(f"\nERROR: Command failed with exit code {return_code}: {' '.join(cmd)}")
+        sys.exit(1)
+
+
+def main():
+    print(f"Cloning ExecuTorch repository to {TARGET_DIR}")
+    print(f"Using commit: {COMMIT_HASH}")
+
+    # Clean up existing directory
+    if os.path.exists(TARGET_DIR):
+        print(f"Removing existing directory: {TARGET_DIR}")
+        shutil.rmtree(TARGET_DIR)
+
+    # Clone repository (shallow clone)
+    run_command(["git", "clone", "--depth", "1", REPO_URL, TARGET_DIR])
+
+    # Checkout specific commit
+    run_command(["git", "fetch", "--depth=1", "origin", COMMIT_HASH], cwd=TARGET_DIR)
+    run_command(["git", "checkout", COMMIT_HASH], cwd=TARGET_DIR)
+
+    # Check if installation has already completed
+    install_marker_path = os.path.join(TARGET_DIR, INSTALL_MARKER)
+    install_script_path = os.path.join(TARGET_DIR, INSTALL_SCRIPT)
+
+    if not os.path.exists(install_marker_path):
+        # Run installation script
+        print(f"Running installation script: {install_script_path}")
+        print("=" * 50)
+        run_command([sys.executable, install_script_path], cwd=TARGET_DIR)
+        print("=" * 50)
+
+        # Create success marker
+        open(install_marker_path, "w").close()
+        print("Installation completed successfully!")
+    else:
+        print("Installation already completed - skipping install_executorch.py")
+
+    # Run Qualcomm SDK installation
+    qnn_script_path = os.path.join(TARGET_DIR, QNN_INSTALL_SCRIPT)
+    print(f"Running Qualcomm SDK installation: {qnn_script_path}")
+    print("=" * 50)
+    run_command(["bash", QNN_INSTALL_SCRIPT], cwd=TARGET_DIR)
+    print("=" * 50)
+
+    # Run Qualcomm build script
+    build_script_path = os.path.join(TARGET_DIR, BUILD_SCRIPT)
+    print(f"Running build script: {build_script_path}")
+    print("=" * 50)
+    run_command(["bash", BUILD_SCRIPT], cwd=TARGET_DIR)
+    print("=" * 50)
+
+    print("\nAll steps completed successfully!")
+    print(f"ExecuTorch installed at: {TARGET_DIR}")
+    print(f"Commit: {COMMIT_HASH}")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/tests/models/test_modeling_dit.py b/tests/models/test_modeling_dit.py
