[Executorch][target recipes] Add target based recipes for lowering models to a target device

Pull Request resolved: #13791

This diff introduces multi backend/ target based recipes to lower a model with very less code. Target recipes provide pre-configured backend recipes to use them and retarget if needed.

See RFC: #13732

## Usage

```
from executorch.export import export, ExportRecipe, IOSTargetRecipeType

# CoreML + XNNPACK
coreml_xnnpack_recipe = ExportRecipe.get_recipe(IOSTargetRecipeType.IOS_ARM64_COREML_FP32)
session = export(model, coreml_xnnpack_recipe, example_inputs)
session.save_pte_file("model.pte")
```

## Advanced usage
one can directly use `ExportRecipe.combine_recipes()` to combine specific backend recipes.
```
recipe1 = ExportRecipe.get_recipe(AndroidRecipeType.XYZ)
recipe2 = ExportRecipe.get_recipe(XNNPackRecipeType.FP32)
combined_recipe = ExportRecipe.combine(
                     [recipe1, recipe2],
                     recipe_name="multi_backend_coreml_xnnpack_fp32"
                  )
session = export(model, combined_recipe, example_inputs)
```

Fixes: #13732
ghstack-source-id: 306438497
@exported-using-ghexport

Differential Revision: [D81297451](https://our.internmc.facebook.com/intern/diff/D81297451/)

Author: abhinaykukkadapu

backends/apple/coreml/TARGETS

@@ -61,16 +61,21 @@ runtime.python_library(
 )
 
 runtime.python_library(
-    name = "recipes",
-    srcs = glob([
-        "recipes/*.py",
-    ]),
+    name = "coreml_recipes",
+    srcs = [
+        "recipes/__init__.py",
+        "recipes/coreml_recipe_provider.py"
+    ],
     visibility = [
         "@EXECUTORCH_CLIENTS",
+        "//executorch/export/...",
     ],
     deps = [
         "fbsource//third-party/pypi/coremltools:coremltools",
+        ":coreml_recipe_types",
         ":backend",
+        ":partitioner",
+        ":quantizer",
         "//caffe2:torch",
         "//executorch/exir:lib",
         "//executorch/exir/backend:compile_spec_schema",
@@ -80,6 +85,20 @@ runtime.python_library(
     ],
 )
 
+runtime.python_library(
+    name = "coreml_recipe_types",
+    srcs = [
+        "recipes/coreml_recipe_types.py",
+    ],
+    visibility = [
+        "@EXECUTORCH_CLIENTS",
+        "//executorch/export/...",
+    ],
+    deps = [
+        "//executorch/export:recipe",
+    ],
+)
+
 runtime.cxx_python_extension(
     name = "executorchcoreml",
     srcs = [
@@ -124,7 +143,7 @@ runtime.python_test(
         "fbsource//third-party/pypi/pytest:pytest",
         ":partitioner",
         ":quantizer",
-        ":recipes",
+        ":coreml_recipes",
         "//caffe2:torch",
         "//pytorch/vision:torchvision",
         "fbsource//third-party/pypi/scikit-learn:scikit-learn",

backends/apple/coreml/recipes/coreml_recipe_provider.py

@@ -121,7 +121,13 @@ def _validate_recipe_kwargs(self, recipe_type: RecipeType, **kwargs: Any) -> Non
 
     def _get_expected_keys(self, recipe_type: RecipeType) -> set:
         """Get expected parameter keys for a recipe type"""
-        common_keys = {"minimum_deployment_target", "compute_unit"}
+        common_keys = {
+            "minimum_deployment_target",
+            "compute_unit",
+            "skip_ops_for_coreml_delegation",
+            "lower_full_graph",
+            "take_over_constant_data",
+        }
 
         if recipe_type in [
             CoreMLRecipeType.TORCHAO_INT4_WEIGHT_ONLY_PER_GROUP,
@@ -377,9 +383,19 @@ def _get_coreml_lowering_recipe(
         if minimum_deployment_target and minimum_deployment_target < ct.target.iOS18:
             take_over_mutable_buffer = False
 
+        # Extract additional partitioner parameters
+        skip_ops_for_coreml_delegation = kwargs.get(
+            "skip_ops_for_coreml_delegation", None
+        )
+        lower_full_graph = kwargs.get("lower_full_graph", False)
+        take_over_constant_data = kwargs.get("take_over_constant_data", True)
+
         partitioner = CoreMLPartitioner(
             compile_specs=compile_specs,
             take_over_mutable_buffer=take_over_mutable_buffer,
+            skip_ops_for_coreml_delegation=skip_ops_for_coreml_delegation,
+            lower_full_graph=lower_full_graph,
+            take_over_constant_data=take_over_constant_data,
         )
 
         edge_compile_config = EdgeCompileConfig(

backends/xnnpack/recipes/TARGETS

@@ -30,6 +30,6 @@ runtime.python_library(
         "@EXECUTORCH_CLIENTS",
     ],
     deps = [
-        "//executorch/export:lib",
+        "//executorch/export:recipe",
     ],
 )

export/multi_backend_recipes/TARGETS

@@ -0,0 +1,43 @@
+load("@fbsource//xplat/executorch/build:runtime_wrapper.bzl", "runtime")
+
+oncall("executorch")
+
+runtime.python_library(
+    name = "multi_backend_recipe_provider",
+    srcs = [
+        "__init__.py",
+        "multi_backend_recipe_provider.py",
+    ],
+    deps = [
+        ":target_recipe_types",
+         "//executorch/export:lib",
+    ]
+)
+
+runtime.python_library(
+    name = "target_recipe_types",
+    srcs = [
+        "target_recipe_types.py",
+    ],
+    deps = [
+         "//executorch/export:recipe",
+        "//executorch/backends/xnnpack/recipes:xnnpack_recipe_types",
+        "//executorch/backends/apple/coreml:coreml_recipes",
+    ]
+)
+
+runtime.python_test(
+    name = "test_multi_backend_target_recipes",
+    srcs = [
+        "tests/test_multi_backend_target_recipes.py",
+    ],
+    deps = [
+        "//executorch/export:lib",
+        ":multi_backend_recipe_provider",
+        "//executorch/backends/apple/coreml:coreml_recipe_types",
+        "//executorch/backends/xnnpack:xnnpack_delegate",
+        "fbsource//third-party/pypi/coremltools:coremltools",
+        "fbsource//third-party/pypi/scikit-learn:scikit-learn",
+        "//executorch/backends/xnnpack/test/tester:tester",
+    ]
+)

export/multi_backend_recipes/__init__.py

@@ -0,0 +1,20 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# 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.
+
+# pyre-strict
+
+from executorch.export import recipe_registry
+
+from .multi_backend_recipe_provider import MultiBackendRecipeProvider
+from .target_recipe_types import TargetRecipeType
+
+# Auto-register MultiBackendRecipeProvider
+recipe_registry.register_backend_recipe_provider(MultiBackendRecipeProvider())
+
+__all__ = [
+    "MultiBackendRecipeProvider",
+    "TargetRecipeType",
+]

export/multi_backend_recipes/multi_backend_recipe_provider.py

@@ -0,0 +1,120 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# 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.
+
+"""
+Multi-backend recipe provider for target-specific deployment.
+
+This module provides the recipe provider that combines multiple backends
+for optimized deployment on specific targets.
+"""
+
+import logging
+from typing import Any, Optional, Sequence
+
+from executorch.export import BackendRecipeProvider, ExportRecipe, RecipeType
+
+from .target_recipe_types import IOSTargetRecipeType, TargetRecipeType
+
+
+class MultiBackendRecipeProvider(BackendRecipeProvider):
+    """
+    Recipe provider that combines multiple backends for target-specific deployment.
+    """
+
+    @property
+    def backend_name(self) -> str:
+        return "multi_backend"
+
+    def get_supported_recipes(self) -> Sequence[RecipeType]:
+        """
+        Returns all available target recipe types.
+        """
+        # Collect all target recipe types from all target classes
+        recipes = []
+        for target_class in [IOSTargetRecipeType]:
+            recipes.extend(list(target_class.__members__.values()))
+
+        return recipes
+
+    def create_recipe(
+        self, recipe_type: RecipeType, **kwargs: Any
+    ) -> Optional[ExportRecipe]:
+        """
+        Create a multi-backend recipe for the given target recipe type.
+
+        Args:
+            recipe_type: Target recipe type (e.g., IOSTargetRecipeType.IOS_ARM64_COREML_FP32)
+            **kwargs: Additional parameters to pass to individual backend recipes
+
+        Returns:
+            ExportRecipe configured for multi-backend deployment
+        """
+        if not isinstance(recipe_type, TargetRecipeType):
+            return None
+
+        # Get the backend combination for this target
+        backend_recipe_types = recipe_type.get_backend_combination()
+        if not backend_recipe_types:
+            logging.warning(
+                f"No backend recipes available for target: {recipe_type.value}"
+            )
+            return None
+
+        # Create individual backend recipes using the existing recipe registry
+        backend_recipes = []
+        for backend_recipe_type in backend_recipe_types:
+            # Extract backend-specific kwargs
+            backend_recipe_kwargs = self._extract_backend_recipe_kwargs(
+                backend_recipe_type.get_backend_name(), kwargs
+            )
+
+            backend_recipe = ExportRecipe.get_recipe(
+                backend_recipe_type, **backend_recipe_kwargs
+            )
+            backend_recipes.append(backend_recipe)
+
+        if not backend_recipes:
+            raise ValueError(
+                f"No available backend recipes for target '{recipe_type.value}'. "
+                f"Ensure required backend dependencies are installed."
+            )
+
+        # Combine the recipes into a single multi-backend recipe
+        return ExportRecipe.combine(backend_recipes, recipe_type.value)
+
+    def _extract_backend_recipe_kwargs(self, backend_name: str, kwargs: dict) -> dict:
+        """
+        Extract backend-specific kwargs using nested dictionary structure.
+
+        Args:
+            backend_name: Name of the backend (e.g., "xnnpack", "coreml")
+            kwargs: All kwargs passed to the target recipe
+
+        Returns:
+            Dict of kwargs specific to this backend
+        """
+        backend_kwargs = {}
+
+        # Extract from nested backend_configs structure
+        backend_configs = kwargs.get("backend_configs", {})
+        if backend_name in backend_configs:
+            backend_kwargs.update(backend_configs[backend_name])
+
+        # Include common kwargs (parameters passed directly without backend_configs)
+        common_kwargs = self._get_common_kwargs(kwargs)
+        backend_kwargs.update(common_kwargs)
+
+        return backend_kwargs
+
+    def _get_common_kwargs(self, kwargs: dict) -> dict:
+        excluded_keys = {
+            "backend_configs",  # Skip, represents nested backend recipe kwargs
+        }
+        common_kwargs = {}
+        for key, value in kwargs.items():
+            if key not in excluded_keys:
+                common_kwargs[key] = value
+        return common_kwargs

export/multi_backend_recipes/target_recipe_types.py

@@ -0,0 +1,95 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# 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.
+
+"""
+Target-specific recipe types for multi-backend deployment.
+
+This module defines target-specific recipe types that combine multiple backends
+for optimized deployment on specific platforms and hardware configurations.
+"""
+
+from abc import abstractmethod
+from typing import List
+
+# pyre-ignore
+from executorch.backends.apple.coreml.recipes.coreml_recipe_types import (
+    CoreMLRecipeType,
+)
+
+from executorch.backends.xnnpack import XNNPackRecipeType
+
+from executorch.export.recipe import RecipeType, RecipeTypeMeta
+
+
+class TargetRecipeTypeMeta(RecipeTypeMeta):
+    """Metaclass that extends RecipeTypeMeta for target recipe types"""
+
+    pass
+
+
+class TargetRecipeType(RecipeType, metaclass=TargetRecipeTypeMeta):
+    """
+    Base class for target-specific recipe types that combine multiple backends.
+    Target recipes define optimal backend combinations for specific deployment scenarios.
+    """
+
+    @abstractmethod
+    def get_backend_combination(self) -> List[RecipeType]:
+        """
+        Return the backend combination for this target recipe type.
+
+        Returns:
+            List of RecipeType enums in order of precedence.
+            Earlier backends get first chance at partitioning operations.
+        """
+        pass
+
+    @classmethod
+    @abstractmethod
+    def get_target_platform(cls) -> str:
+        """
+        Return the target platform for this recipe type.
+
+        Returns:
+            str: The target platform (e.g., "android", "ios", "linux")
+        """
+        pass
+
+    @classmethod
+    def get_backend_name(cls) -> str:
+        return "multi_backend"
+
+
+class IOSTargetRecipeType(TargetRecipeType):
+    """iOS-specific target recipe types, refer individual backend recipes for customization"""
+
+    # FP32 - iOS with CoreML backend as primary, fallback XNNPACK
+    IOS_ARM64_COREML_FP32 = "ios-arm64-coreml-fp32"
+
+    # FP16 - iOS with CoreML backend as primary, fallback XNNPACK
+    IOS_ARM64_COREML_FP16 = "ios-arm64-coreml-fp16"
+
+    # INT8 Static Quantization (weights + activations)
+    # No xnnpack fallback for quantization as coreml uses torch.ao quantizer vs xnnpack uses torchao quantizer
+    IOS_ARM64_COREML_INT8_STATIC = "ios-arm64-coreml-int8-static"
+
+    @classmethod
+    def get_target_platform(cls) -> str:
+        return "ios"
+
+    def get_backend_combination(self) -> List[RecipeType]:
+        """
+        Get backend combinations for iOS targets.
+
+        Returns combinations optimized for iOS deployment scenarios.
+        """
+        if self == IOSTargetRecipeType.IOS_ARM64_COREML_FP32:
+            return [CoreMLRecipeType.FP32, XNNPackRecipeType.FP32]
+        elif self == IOSTargetRecipeType.IOS_ARM64_COREML_FP16:
+            return [CoreMLRecipeType.FP16, XNNPackRecipeType.FP32]
+        elif self == IOSTargetRecipeType.IOS_ARM64_COREML_INT8_STATIC:
+            return [CoreMLRecipeType.PT2E_INT8_STATIC]
+        return []