Update

[ghstack-poisoned]

Author: GregoryComer

backends/apple/coreml/test/tester.py

@@ -1,10 +1,10 @@
-git # Copyright (c) Meta Platforms, Inc. and affiliates.
+# 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.
 
-from typing import Any, Callable, List, Optional, Sequence, Tuple, Type
+from typing import Any, List, Optional, Tuple
 
 import executorch
 import executorch.backends.test.harness.stages as BaseStages
@@ -59,4 +59,3 @@ def __init__(
             example_inputs=example_inputs,
             dynamic_shapes=dynamic_shapes,
         )
-

backends/test/compliance_suite/__init__.py

@@ -1,10 +1,19 @@
+# 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-unsafe
+
+
+import logging
 import os
 import unittest
 
 from enum import Enum
 from typing import Any, Callable, Tuple
 
-import logging
 import torch
 from executorch.backends.test.harness import Tester
 
@@ -15,20 +24,23 @@
 # Read enabled backends from the environment variable. Enable all if
 # not specified (signalled by None).
 def get_enabled_backends():
-    et_test_backends = os.environ.get("ET_TEST_BACKENDS")
+    et_test_backends = os.environ.get("ET_TEST_ENABLED_BACKENDS")
     if et_test_backends is not None:
         return et_test_backends.split(",")
     else:
         return None
 
+
 _ENABLED_BACKENDS = get_enabled_backends()
 
+
 def is_backend_enabled(backend):
     if _ENABLED_BACKENDS is None:
         return True
     else:
         return backend in _ENABLED_BACKENDS
 
+
 ALL_TEST_FLOWS = []
 
 if is_backend_enabled("xnnpack"):
@@ -58,49 +70,71 @@ def is_backend_enabled(backend):
     torch.float64,
 ]
 
+FLOAT_DTYPES = [
+    torch.float16,
+    torch.float32,
+    torch.float64,
+]
+
+
 class TestType(Enum):
     STANDARD = 1
     DTYPE = 2
 
+
 def dtype_test(func):
-    setattr(func, "test_type", TestType.DTYPE)
+    func.test_type = TestType.DTYPE
     return func
 
+
 def operator_test(cls):
     _create_tests(cls)
     return cls
 
+
 def _create_tests(cls):
     for key in dir(cls):
         if key.startswith("test_"):
             _expand_test(cls, key)
-        
+
+
 def _expand_test(cls, test_name: str):
     test_func = getattr(cls, test_name)
-    for (flow_name, tester_factory) in ALL_TEST_FLOWS:
-        _create_test_for_backend(cls, test_func, flow_name, tester_factory)                        
+    for flow_name, tester_factory in ALL_TEST_FLOWS:
+        _create_test_for_backend(cls, test_func, flow_name, tester_factory)
     delattr(cls, test_name)
 
+
+def _make_wrapped_test(test_func, tester_factory):
+    def wrapped_test(self):
+        test_func(self, tester_factory)
+
+    return tester_factory
+
+
+def _make_wrapped_dtype_test(test_func, dtype, tester_factory):
+    def wrapped_test(self):
+        test_func(self, dtype, tester_factory)
+
+    return wrapped_test
+
+
 def _create_test_for_backend(
     cls,
     test_func: Callable,
     flow_name: str,
-    tester_factory: Callable[[torch.nn.Module, Tuple[Any]], Tester]
+    tester_factory: Callable[[torch.nn.Module, Tuple[Any]], Tester],
 ):
     test_type = getattr(test_func, "test_type", TestType.STANDARD)
 
     if test_type == TestType.STANDARD:
-        def wrapped_test(self):
-            test_func(self, tester_factory)
-            
+        wrapped_test = _make_wrapped_test(test_func, tester_factory)
         test_name = f"{test_func.__name__}_{flow_name}"
         setattr(cls, test_name, wrapped_test)
     elif test_type == TestType.DTYPE:
         for dtype in DTYPES:
-            def wrapped_test(self):
-                test_func(self, dtype, tester_factory)
-            
-            dtype_name = str(dtype)[6:] # strip "torch."
+            wrapped_test = _make_wrapped_dtype_test(test_func, dtype, tester_factory)
+            dtype_name = str(dtype)[6:]  # strip "torch."
             test_name = f"{test_func.__name__}_{dtype_name}_{flow_name}"
             setattr(cls, test_name, wrapped_test)
     else:
@@ -126,10 +160,4 @@ def _test_op(self, model, inputs, tester_factory):
 
         # Only run the runtime test if the op was delegated.
         if is_delegated:
-            (
-                tester
-                .to_executorch()
-                .serialize()
-                .run_method_and_compare_outputs()
-            )
-    
+            (tester.to_executorch().serialize().run_method_and_compare_outputs())

backends/test/compliance_suite/operators/__init__.py

@@ -0,0 +1,7 @@
+# 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-unsafe

backends/test/compliance_suite/operators/test_add.py

@@ -1,6 +1,11 @@
-# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+# 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-unsafe
 
-# pyre-strict
 
 from typing import Callable
 
@@ -12,10 +17,12 @@
     OperatorTest,
 )
 
+
 class Model(torch.nn.Module):
     def forward(self, x, y):
         return x + y
 
+
 class ModelAlpha(torch.nn.Module):
     def __init__(self, alpha):
         super().__init__()
@@ -24,6 +31,7 @@ def __init__(self, alpha):
     def forward(self, x, y):
         return torch.add(x, y, alpha=self.alpha)
 
+
 @operator_test
 class Add(OperatorTest):
     @dtype_test
@@ -34,41 +42,45 @@ def test_add_dtype(self, dtype, tester_factory: Callable) -> None:
                 (torch.rand(2, 10) * 100).to(dtype),
                 (torch.rand(2, 10) * 100).to(dtype),
             ),
-            tester_factory)
-        
+            tester_factory,
+        )
+
     def test_add_f32_bcast_first(self, tester_factory: Callable) -> None:
         self._test_op(
-            Model(), 
+            Model(),
             (
                 torch.randn(5),
                 torch.randn(1, 5, 1, 5),
             ),
-            tester_factory)
-        
+            tester_factory,
+        )
+
     def test_add_f32_bcast_second(self, tester_factory: Callable) -> None:
         self._test_op(
-            Model(), 
+            Model(),
             (
                 torch.randn(4, 4, 2, 7),
                 torch.randn(2, 7),
             ),
-            tester_factory)
+            tester_factory,
+        )
 
     def test_add_f32_bcast_unary(self, tester_factory: Callable) -> None:
         self._test_op(
-            Model(), 
+            Model(),
             (
                 torch.randn(5),
                 torch.randn(1, 1, 5),
             ),
-            tester_factory)
-        
+            tester_factory,
+        )
+
     def test_add_f32_alpha(self, tester_factory: Callable) -> None:
         self._test_op(
-            ModelAlpha(alpha=2), 
+            ModelAlpha(alpha=2),
             (
                 torch.randn(1, 25),
                 torch.randn(1, 25),
             ),
-            tester_factory)
-    
+            tester_factory,
+        )

backends/test/compliance_suite/operators/test_div.py

@@ -1,6 +1,11 @@
-# (c) Meta Platforms, Inc. and affiliates. Confidential and proprietary.
+# 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-unsafe
 
-# pyre-strict
 
 from typing import Callable, Optional
 
@@ -12,10 +17,12 @@
     OperatorTest,
 )
 
+
 class Model(torch.nn.Module):
     def forward(self, x, y):
         return x / y
 
+
 class ModelWithRounding(torch.nn.Module):
     def __init__(self, rounding_mode: Optional[str]):
         super().__init__()
@@ -24,6 +31,7 @@ def __init__(self, rounding_mode: Optional[str]):
     def forward(self, x, y):
         return torch.div(x, y, rounding_mode=self.rounding_mode)
 
+
 @operator_test
 class Divide(OperatorTest):
     @dtype_test
@@ -32,51 +40,64 @@ def test_divide_dtype(self, dtype, tester_factory: Callable) -> None:
             Model(),
             (
                 (torch.rand(2, 10) * 100).to(dtype),
-                (torch.rand(2, 10) * 100 + 0.1).to(dtype),  # Adding 0.1 to avoid division by zero
+                (torch.rand(2, 10) * 100 + 0.1).to(
+                    dtype
+                ),  # Adding 0.1 to avoid division by zero
             ),
-            tester_factory)
-        
+            tester_factory,
+        )
+
     def test_divide_f32_bcast_first(self, tester_factory: Callable) -> None:
         self._test_op(
-            Model(), 
+            Model(),
             (
                 torch.randn(5),
-                torch.randn(1, 5, 1, 5).abs() + 0.1,  # Using abs and adding 0.1 to avoid division by zero
+                torch.randn(1, 5, 1, 5).abs()
+                + 0.1,  # Using abs and adding 0.1 to avoid division by zero
             ),
-            tester_factory)
-        
+            tester_factory,
+        )
+
     def test_divide_f32_bcast_second(self, tester_factory: Callable) -> None:
         self._test_op(
-            Model(), 
+            Model(),
             (
                 torch.randn(4, 4, 2, 7),
-                torch.randn(2, 7).abs() + 0.1,  # Using abs and adding 0.1 to avoid division by zero
+                torch.randn(2, 7).abs()
+                + 0.1,  # Using abs and adding 0.1 to avoid division by zero
             ),
-            tester_factory)
+            tester_factory,
+        )
 
     def test_divide_f32_bcast_unary(self, tester_factory: Callable) -> None:
         self._test_op(
-            Model(), 
+            Model(),
             (
                 torch.randn(5),
-                torch.randn(1, 1, 5).abs() + 0.1,  # Using abs and adding 0.1 to avoid division by zero
+                torch.randn(1, 1, 5).abs()
+                + 0.1,  # Using abs and adding 0.1 to avoid division by zero
             ),
-            tester_factory)
-    
+            tester_factory,
+        )
+
     def test_divide_f32_trunc(self, tester_factory: Callable) -> None:
         self._test_op(
-            ModelWithRounding(rounding_mode="trunc"), 
+            ModelWithRounding(rounding_mode="trunc"),
             (
                 torch.randn(3, 4) * 10,
-                torch.randn(3, 4).abs() + 0.1,  # Using abs and adding 0.1 to avoid division by zero
+                torch.randn(3, 4).abs()
+                + 0.1,  # Using abs and adding 0.1 to avoid division by zero
             ),
-            tester_factory)
-    
+            tester_factory,
+        )
+
     def test_divide_f32_floor(self, tester_factory: Callable) -> None:
         self._test_op(
-            ModelWithRounding(rounding_mode="floor"), 
+            ModelWithRounding(rounding_mode="floor"),
             (
                 torch.randn(3, 4) * 10,
-                torch.randn(3, 4).abs() + 0.1,  # Using abs and adding 0.1 to avoid division by zero
+                torch.randn(3, 4).abs()
+                + 0.1,  # Using abs and adding 0.1 to avoid division by zero
             ),
-            tester_factory)
+            tester_factory,
+        )