Update on "[ET-VK][Ops] aten.tan.default from scratch implementation"

Following the instructions here for creating a new operator from scratch for learning purposes:
https://www.internalfb.com/wiki/ExecuTorch_Vulkan_Backend/Development_0/Adding_a_New_Operator_Implementation/

Goal is to create a tan operator and its test case

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

[ghstack-poisoned]

Author: morelos

.lintrunner.toml

@@ -384,6 +384,23 @@ code = "TORCH_AO_IMPORT"
 include_patterns = ["**/*.py"]
 exclude_patterns = [
     "third-party/**",
+    # TODO: remove exceptions as we migrate
+    # backends
+    "backends/arm/quantizer/**",
+    "backends/arm/test/ops/**",
+    "backends/vulkan/quantizer/**",
+    "backends/vulkan/test/**",
+    "backends/cadence/aot/quantizer/**",
+    "backends/qualcomm/quantizer/**",
+    "examples/qualcomm/**",
+    "backends/xnnpack/quantizer/**",
+    "backends/xnnpack/test/**",
+    "exir/tests/test_passes.py",
+    "extension/llm/export/builder.py",
+    "extension/llm/export/quantizer_lib.py",
+    "exir/tests/test_memory_planning.py",
+    "backends/transforms/duplicate_dynamic_quant_chain.py",
+    "exir/backend/test/demos/test_xnnpack_qnnpack.py",
 ]
 
 command = [
@@ -392,7 +409,7 @@ command = [
   "lintrunner_adapters",
   "run",
   "grep_linter",
-  "--pattern=\\bfrom torch\\.ao\\.quantization\\.(?:quantize_pt2e)(?:\\.[A-Za-z0-9_]+)*\\b",
+  "--pattern=\\bfrom torch\\.ao\\.quantization\\.(?:quantizer|observer|quantize_pt2e|pt2e)(?:\\.[A-Za-z0-9_]+)*\\b",
   "--linter-name=TorchAOImport",
   "--error-name=Prohibited torch.ao.quantization import",
   """--error-description=\

CMakeLists.txt

@@ -362,6 +362,9 @@ add_library(executorch_core ${_executorch_core__srcs})
 add_library(executorch_no_prim_ops ALIAS executorch_core)
 
 target_link_libraries(executorch_core PRIVATE program_schema)
+if(ANDROID)
+  target_link_libraries(executorch_core PUBLIC log)
+endif()
 if(EXECUTORCH_USE_DL)
   # Check if dl exists for this toolchain and only then link it.
   find_library(DL_LIBRARY_EXISTS NAMES dl)
@@ -653,10 +656,6 @@ if(EXECUTORCH_BUILD_PYBIND)
   install(TARGETS portable_lib
           LIBRARY DESTINATION executorch/extension/pybindings
   )
-
-  if(EXECUTORCH_BUILD_EXTENSION_TRAINING)
-
-  endif()
 endif()
 
 if(EXECUTORCH_BUILD_EXTENSION_TRAINING)

CONTRIBUTING.md

@@ -420,7 +420,7 @@ for basics.
 - Use [this](docs/source/backend-delegates-integration.md) guide when
   integrating your delegate with ExecuTorch.
 - Refer to [this](docs/source/backend-delegates-dependencies.md) set of
-  guidelines when including a third-party depenency for your delegate.
+  guidelines when including a third-party dependency for your delegate.
 
  
 

backends/arm/_passes/__init__.py

@@ -15,6 +15,7 @@
 from .convert_any_default_dim_dims_pass import ConvertAnyDefaultDimDimsPass  # noqa
 from .convert_expand_copy_to_repeat import ConvertExpandCopyToRepeatPass  # noqa
 from .convert_full_like_to_full_pass import ConvertFullLikeToFullPass  # noqa
+from .convert_int_pow_to_mul import ConvertIntPowToMuls  # noqa
 from .convert_minmax_pass import ConvertMinMaxPass  # noqa
 from .convert_split_to_slice import ConvertSplitToSlicePass  # noqa
 from .convert_squeezes_to_view import ConvertSqueezesToViewPass  # noqa

backends/arm/_passes/arm_pass_manager.py

@@ -18,6 +18,7 @@
     ConvertAnyDefaultDimDimsPass,
     ConvertExpandCopyToRepeatPass,
     ConvertFullLikeToFullPass,
+    ConvertIntPowToMuls,
     ConvertMinMaxPass,
     ConvertMmToBmmPass,
     ConvertSplitToSlicePass,
@@ -131,14 +132,14 @@ def _tosa_080_BI_pipeline(self, exported_program: ExportedProgram) -> GraphModul
 
     def _tosa_080_MI_pipeline(self, exported_program: ExportedProgram) -> GraphModule:
         self.add_pass(DecomposeSqrtPass())
+        self.add_pass(ConvertIntPowToMuls())
         self.add_pass(ReplaceScalarWithTensorArgPassTOSAMI())
         self.add_pass(FuseQuantizedActivationPass())
         self.add_pass(RemoveGetItemPass())
         self.add_pass(ConvertSplitToSlicePass())
         self.add_pass(FuseBatchnorm2DPass(exported_program))
         self.add_pass(ConvertMmToBmmPass())
         self.add_pass(DecomposeLinearPass())
-        self.add_pass(DecomposeLinearVectorNormPass())
         self.add_pass(DecomposeLeakyReLUPass())
         self.add_pass(DecomposeBatchNormPass())
         self.add_pass(DecomposeLayerNormPass())

backends/arm/_passes/convert_int_pow_to_mul.py

@@ -0,0 +1,52 @@
+# Copyright 2025 Arm Limited and/or its affiliates.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# pyre-unsafe
+
+from executorch.backends.arm._passes import ArmPass
+from executorch.exir.dialects._ops import ops as exir_ops
+
+
+class ConvertIntPowToMuls(ArmPass):
+    """
+    Replaces pow with integer exponent with a series of multiplications.
+    Only handles pow.Tensor_Scalar and not pow.Tensor_Tensor.
+    Needs to be run before doing scalar to tensor conversion.
+    """
+
+    def call_operator(self, op, args, kwargs, meta):
+        if op != exir_ops.edge.aten.pow.Tensor_Scalar:
+            return super().call_operator(op, args, kwargs, meta)
+
+        x = args[0]
+        exp = args[1]
+
+        # Handle zero first and return early
+        if exp == 0:
+            # return a tensor of ones with the same shape as x
+            return super().call_operator(
+                exir_ops.edge.aten.full_like.default, (x, 1), {}, meta, True
+            )
+
+        if not isinstance(exp, int):
+            return super().call_operator(op, args, kwargs, meta)
+
+        # Handle negative exponent
+        if exp < 0:
+            x = super().call_operator(
+                exir_ops.edge.aten.reciprocal.default, (x,), {}, meta, True
+            )
+            exp = -exp
+
+        res = x
+
+        # Consider exponentiation by squaring, if exp turns out to be large.
+        # Now we just roll out the multiplications.
+        for _ in range(exp - 1):
+            res = super().call_operator(
+                exir_ops.edge.aten.mul.Tensor, (res, x), {}, meta, True
+            )
+
+        return res

backends/arm/test/ops/test_eye.py

@@ -0,0 +1,113 @@
+# Copyright 2025 Arm Limited and/or its affiliates.
+#
+# 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.arm.test import common
+from executorch.backends.arm.test.tester.test_pipeline import (
+    EthosU55PipelineBI,
+    EthosU85PipelineBI,
+    OpNotSupportedPipeline,
+    TosaPipelineBI,
+    TosaPipelineMI,
+)
+
+input_t = tuple[torch.Tensor]
+test_data_t = tuple[int, torch.dtype]
+
+
+class EyeAdd(torch.nn.Module):
+    aten_op: str = "torch.ops.aten.eye.default"
+
+    def __init__(self, n: int, dtype: torch.dtype):
+        super().__init__()
+        self.args = (n,)
+        self.dtype = dtype
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return torch.eye(*self.args, dtype=self.dtype) + x
+
+    test_data: dict[str, test_data_t] = {
+        "10x3x3": (lambda: (torch.randn(10, 3, 3),), (3, torch.float32)),
+        "10x1": (lambda: (torch.randn(10, 1),), (10, torch.float32)),
+        "int32_int32": (
+            lambda: (torch.randint(0, 10, [10], dtype=torch.int32),),
+            (10, torch.int32),
+        ),
+    }
+
+    test_data_not_delegated: dict[str, test_data_t] = {
+        "fp32_int64": (lambda: (torch.randn(10),), (10, torch.int64)),
+        "fp32_int32": (lambda: (torch.randn(10),), (10, torch.int32)),
+        "int32_int64": (
+            lambda: (torch.randint(0, 10, [10], dtype=torch.int32),),
+            (10, torch.int64),
+        ),
+    }
+
+
+@common.parametrize("test_data", EyeAdd.test_data)
+def test_eye_tosa_MI(test_data: test_data_t):
+    input_data, init_data = test_data
+    pipeline = TosaPipelineMI[input_t](
+        EyeAdd(*init_data),
+        input_data(),
+        EyeAdd.aten_op,
+    )
+    pipeline.run()
+
+
+@common.parametrize("test_data", EyeAdd.test_data)
+def test_eye_tosa_BI(test_data: test_data_t):
+    input_data, init_data = test_data
+    pipeline = TosaPipelineBI[input_t](
+        EyeAdd(*init_data),
+        input_data(),
+        EyeAdd.aten_op,
+    )
+    pipeline.pop_stage("check.quant_nodes")
+    pipeline.run()
+
+
+@common.parametrize("test_data", EyeAdd.test_data)
+def test_eye_u55_BI(test_data: test_data_t):
+    input_data, init_data = test_data
+    pipeline = EthosU55PipelineBI[input_t](
+        EyeAdd(*init_data),
+        input_data(),
+        EyeAdd.aten_op,
+        use_to_edge_transform_and_lower=True,
+    )
+    pipeline.pop_stage("check.quant_nodes")
+    pipeline.run()
+
+
+@common.parametrize("test_data", EyeAdd.test_data)
+def test_eye_u85_BI(test_data: test_data_t):
+    input_data, init_data = test_data
+    pipeline = EthosU85PipelineBI[input_t](
+        EyeAdd(*init_data),
+        input_data(),
+        EyeAdd.aten_op,
+        use_to_edge_transform_and_lower=True,
+    ).dump_artifact("to_edge_transform_and_lower")
+    pipeline.pop_stage("check.quant_nodes")
+    pipeline.run()
+
+
+@common.parametrize(
+    "test_data",
+    EyeAdd.test_data_not_delegated,
+    xfails={
+        "fp32_int32": "MLETORCG-716: Do not delegate empty networks to vela",
+        "fp32_int64": "MLETORCG-716: Do not delegate empty networks to vela",
+        "int32_int64": "MLETORCG-716: Do not delegate empty networks to vela",
+    },
+)
+def test_eye_tosa_BI_not_delegated(test_data: test_data_t):
+    input_data, init_data = test_data
+    pipeline = OpNotSupportedPipeline[input_t](
+        EyeAdd(*init_data), input_data(), non_delegated_ops={}, quantize=True
+    )
+    pipeline.run()

backends/arm/test/ops/test_ones.py

@@ -0,0 +1,114 @@
+# Copyright 2025 Arm Limited and/or its affiliates.
+#
+# 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.arm.test import common
+from executorch.backends.arm.test.tester.test_pipeline import (
+    EthosU55PipelineBI,
+    EthosU85PipelineBI,
+    OpNotSupportedPipeline,
+    TosaPipelineBI,
+    TosaPipelineMI,
+)
+
+input_t = tuple[torch.Tensor]
+test_data_t = tuple[int, torch.dtype]
+
+
+class OnesAdd(torch.nn.Module):
+    aten_op: str = "torch.ops.aten.ones.default"
+
+    def __init__(self, n: int, dtype: torch.dtype):
+        super().__init__()
+        self.args = (n,)
+        self.dtype = dtype
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        return torch.ones(*self.args, dtype=self.dtype) + x
+
+    test_data: dict[str, test_data_t] = {
+        "10x3x3": (lambda: (torch.randn(10, 3, 3),), (3, torch.float32)),
+        "10x1": (lambda: (torch.randn(10, 1),), (10, torch.float32)),
+        "int32_int32": (
+            lambda: (torch.randint(0, 10, [10], dtype=torch.int32),),
+            (10, torch.int32),
+        ),
+    }
+
+    test_data_not_delegated: dict[str, test_data_t] = {
+        "fp32_int64": (lambda: (torch.randn(10),), (10, torch.int64)),
+        "fp32_int32": (lambda: (torch.randn(10),), (10, torch.int32)),
+        "int32_int64": (
+            lambda: (torch.randint(0, 10, [10], dtype=torch.int32),),
+            (10, torch.int64),
+        ),
+    }
+
+
+@common.parametrize("test_data", OnesAdd.test_data)
+def test_ones_tosa_MI(test_data: test_data_t):
+    input_data, init_data = test_data
+    pipeline = TosaPipelineMI[input_t](
+        OnesAdd(*init_data),
+        input_data(),
+        OnesAdd.aten_op,
+    )
+    pipeline.run()
+
+
+@common.parametrize("test_data", OnesAdd.test_data)
+def test_ones_tosa_BI(test_data: test_data_t):
+    input_data, init_data = test_data
+    pipeline = TosaPipelineBI[input_t](
+        OnesAdd(*init_data),
+        input_data(),
+        OnesAdd.aten_op,
+    )
+    pipeline.pop_stage("check.quant_nodes")
+    pipeline.run()
+
+
+@common.parametrize("test_data", OnesAdd.test_data)
+def test_ones_u55_BI(test_data: test_data_t):
+    input_data, init_data = test_data
+    pipeline = EthosU55PipelineBI[input_t](
+        OnesAdd(*init_data),
+        input_data(),
+        OnesAdd.aten_op,
+        use_to_edge_transform_and_lower=True,
+    )
+    pipeline.pop_stage("check.quant_nodes")
+    pipeline.run()
+
+
+@common.parametrize("test_data", OnesAdd.test_data)
+def test_ones_u85_BI(test_data: test_data_t):
+    input_data, init_data = test_data
+    pipeline = EthosU85PipelineBI[input_t](
+        OnesAdd(*init_data),
+        input_data(),
+        OnesAdd.aten_op,
+        use_to_edge_transform_and_lower=True,
+    ).dump_artifact("to_edge_transform_and_lower")
+    pipeline.pop_stage("check.quant_nodes")
+    pipeline.run()
+
+
+@common.parametrize(
+    "test_data",
+    OnesAdd.test_data_not_delegated,
+    xfails={
+        "fp32_int32": "MLETORCG-716: Do not delegate empty networks to vela",
+        "fp32_int64": "MLETORCG-716: Do not delegate empty networks to vela",
+        "int32_int64": "MLETORCG-716: Do not delegate empty networks to vela",
+    },
+)
+def test_ones_tosa_BI_not_delegated(test_data: test_data_t):
+    input_data, init_data = test_data
+    pipeline = OpNotSupportedPipeline[input_t](
+        OnesAdd(*init_data), input_data(), non_delegated_ops={}, quantize=True
+    )
+    pipeline.run()

backends/arm/test/ops/test_pow.py

@@ -71,6 +71,10 @@ class Pow_TensorScalar(torch.nn.Module):
             torch.abs(torch.randn((1, 2, 3, 6))),
             6.789,
         ),
+        "neg_base_exp_pos_integer": lambda: (
+            -torch.abs(torch.randn((1, 2, 3, 6))) - 10,
+            3,
+        ),
     }
 
     def __init__(self, exp):