Add android target recipes and extensive model tests using ios and android recipes (pytorch#14290)

Summary:

Changes in this diff:
1. Adds android target recipes using QNN backend.
2. Add extensive model lowering and accuracy checks using torchvision models.

```
from executorch.export import export
qnn_android_recipe = get_android_recipe()

# lower a model to pte
session = export(model, recipe, example_inputs)

out = session.run_method("forward", *example_inputs)
```

Differential Revision: D82284987

Author: abhinaykukkadapu

backends/qualcomm/_passes/TARGETS

@@ -15,5 +15,6 @@ runtime.python_library(
         "//executorch/backends/transforms:decompose_sdpa",
         "//executorch/exir/backend:backend_details",
         "//executorch/exir/backend:compile_spec_schema",
+        "//executorch/backends/qualcomm/quantizer:quantizer",
     ],
 )

export/TARGETS

@@ -117,9 +117,19 @@ runtime.python_library(
         "target_recipes.py",
     ],
     deps = [
+        ":export_utils",
         "fbsource//third-party/pypi/coremltools:coremltools",
         "//executorch/export:recipe",
         "//executorch/backends/xnnpack/recipes:xnnpack_recipes",
         "//executorch/backends/apple/coreml:coreml_recipes",
+        "//executorch/backends/qualcomm/recipes:qnn_recipes",
+    ]
+)
+
+runtime.python_library(
+    name = "export_utils",
+    srcs = ["utils.py"],
+    deps = [
+        "//caffe2:torch",
     ]
 )

export/target_recipes.py

@@ -11,31 +11,13 @@
 selection and combine multiple backends optimally for target hardware.
 """
 
-import sys
 from typing import Dict, List
 
-if sys.platform != "win32":
-    import coremltools as ct
-    from executorch.backends.apple.coreml.recipes import CoreMLRecipeType
-
-# pyre-ignore
 from executorch.backends.xnnpack.recipes import XNNPackRecipeType
 from executorch.export.recipe import ExportRecipe, RecipeType
-
-
-## IOS Target configs
-# The following list of recipes are not exhaustive for CoreML; refer to CoreMLRecipeType for more detailed recipes.
-IOS_CONFIGS: Dict[str, List[RecipeType]] = (
-    {
-        # pyre-ignore
-        "ios-arm64-coreml-fp32": [CoreMLRecipeType.FP32, XNNPackRecipeType.FP32],
-        # pyre-ignore
-        "ios-arm64-coreml-fp16": [CoreMLRecipeType.FP16],
-        # pyre-ignore
-        "ios-arm64-coreml-int8": [CoreMLRecipeType.PT2E_INT8_STATIC],
-    }
-    if sys.platform != "win32"
-    else {}
+from executorch.export.utils import (
+    is_supported_platform_for_coreml_lowering,
+    is_supported_platform_for_qnn_lowering,
 )
 
 
@@ -46,7 +28,7 @@ def _create_target_recipe(
     Create a combined recipe for a target.
 
     Args:
-        target: Human-readable hardware configuration name
+        target_config: Human-readable hardware configuration name
         recipes: List of backend recipe types to combine
         **kwargs: Additional parameters - each backend will use what it needs
 
@@ -67,7 +49,6 @@ def _create_target_recipe(
                 f"Failed to create {recipe_type.value} recipe for {target_config}: {e}"
             ) from e
 
-    # Combine into single recipe
     if len(backend_recipes) == 1:
         return backend_recipes[0]
 
@@ -100,8 +81,24 @@ def get_ios_recipe(
         recipe = get_ios_recipe('ios-arm64-coreml-int8')
         session = export(model, recipe, example_inputs)
     """
-    if target_config not in IOS_CONFIGS:
-        supported = list(IOS_CONFIGS.keys())
+
+    if not is_supported_platform_for_coreml_lowering():
+        raise ValueError("CoreML is not supported on this platform")
+
+    import coremltools as ct
+    from executorch.backends.apple.coreml.recipes import CoreMLRecipeType
+
+    ios_configs: Dict[str, List[RecipeType]] = {
+        # pyre-ignore
+        "ios-arm64-coreml-fp32": [CoreMLRecipeType.FP32, XNNPackRecipeType.FP32],
+        # pyre-ignore
+        "ios-arm64-coreml-fp16": [CoreMLRecipeType.FP16],
+        # pyre-ignore
+        "ios-arm64-coreml-int8": [CoreMLRecipeType.PT2E_INT8_STATIC],
+    }
+
+    if target_config not in ios_configs:
+        supported = list(ios_configs.keys())
         raise ValueError(
             f"Unsupported iOS configuration: '{target_config}'. "
             f"Supported: {supported}"
@@ -113,5 +110,68 @@ def get_ios_recipe(
         if "minimum_deployment_target" not in kwargs:
             kwargs["minimum_deployment_target"] = ct.target.iOS17
 
-    backend_recipes = IOS_CONFIGS[target_config]
+    backend_recipes = ios_configs[target_config]
+    return _create_target_recipe(target_config, backend_recipes, **kwargs)
+
+
+# Android Recipe
+def get_android_recipe(
+    target_config: str = "android-arm64-snapdragon-fp16", **kwargs
+) -> ExportRecipe:
+    """
+    Get Android-optimized recipe for specified hardware configuration.
+
+    Supported configurations:
+    - 'android-arm64-snapdragon-fp16': QNN fp16 recipe
+
+    Args:
+        target_config: Android configuration string
+        **kwargs: Additional parameters for backend recipes
+
+    Returns:
+        ExportRecipe configured for Android deployment
+
+    Raises:
+        ValueError: If target configuration is not supported
+
+    Example:
+        recipe = get_android_recipe('android-arm64-snapdragon-fp16')
+        session = export(model, recipe, example_inputs)
+    """
+
+    if not is_supported_platform_for_qnn_lowering():
+        raise ValueError(
+            "QNN is not supported or not properly configured on this platform"
+        )
+
+    try:
+        # Qualcomm QNN backend runs various sdk downloads on first use
+        # with a pip install, so wrap it in a try/except
+        # pyre-ignore
+        from executorch.backends.qualcomm.recipes import QNNRecipeType
+    except:
+        raise ValueError(
+            "QNN backend is not available. Please ensure the Qualcomm backend "
+            "is properly installed and configured, "
+        )
+
+    android_configs: Dict[str, List[RecipeType]] = {
+        # pyre-ignore
+        "android-arm64-snapdragon-fp16": [QNNRecipeType.FP16],
+    }
+
+    if target_config not in android_configs:
+        supported = list(android_configs.keys())
+        raise ValueError(
+            f"Unsupported Android configuration: '{target_config}'. "
+            f"Supported: {supported}"
+        )
+
+    kwargs = kwargs or {}
+
+    if target_config == "android-arm64-snapdragon-fp16":
+        if "soc_model" not in kwargs:
+            kwargs["soc_model"] = "SM8650"
+
+    backend_recipes = android_configs[target_config]
     return _create_target_recipe(target_config, backend_recipes, **kwargs)

export/tests/TARGETS

@@ -1,4 +1,5 @@
 load("@fbsource//xplat/executorch/build:runtime_wrapper.bzl", "runtime")
+load("@fbsource//xplat/executorch/backends/qualcomm/qnn_version.bzl", "get_qnn_library_version")
 
 oncall("executorch")
 
@@ -37,11 +38,23 @@ runtime.python_test(
     srcs = [
         "test_target_recipes.py",
     ],
+    env = {
+        "LD_LIBRARY_PATH": "$(location fbsource//third-party/qualcomm/qnn/qnn-{0}:qnn_offline_compile_libs)".format(get_qnn_library_version()),
+        "QNN_SDK_ROOT": "$(location fbsource//third-party/qualcomm/qnn/qnn-{0}:__dir__)".format(get_qnn_library_version()),
+        "HTTP_PROXY": "http://fwdproxy:8080",
+        "HTTPS_PROXY": "http://fwdproxy:8080",
+    },
+    labels = ["long_running"],
     deps = [
         "//executorch/export:lib",
         "//executorch/export:target_recipes",
+        "//executorch/export:export_utils",
         "//executorch/runtime:runtime",
         "//executorch/backends/xnnpack/recipes:xnnpack_recipes",
         "//executorch/backends/apple/coreml:coreml_recipes",
+        "//executorch/backends/qualcomm/recipes:qnn_recipes",
+        "//executorch/examples/models:models",
+        "//executorch/backends/xnnpack/test/tester:tester",
+        "fbsource//third-party/pypi/coremltools:coremltools"
     ]
 )