[Backend Tester] Add more pointwise op tests

ghstack-source-id: be6e7b1
ghstack-comment-id: 3116317028
Pull-Request: #12855

Author: GregoryComer

backends/test/suite/operators/test_abs.py

@@ -0,0 +1,57 @@
+# 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 torch
+from executorch.backends.test.suite.flow import TestFlow
+
+from executorch.backends.test.suite.operators import (
+    dtype_test,
+    operator_test,
+    OperatorTest,
+)
+
+
+class AbsModel(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, x):
+        return torch.abs(x)
+
+
+@operator_test
+class TestAbs(OperatorTest):
+    @dtype_test
+    def test_abs_dtype(self, flow: TestFlow, dtype) -> None:
+        # Test with different dtypes
+        model = AbsModel().to(dtype)
+        self._test_op(model, (torch.rand(10, 10).to(dtype) * 2 - 1,), flow)
+
+    def test_abs_shapes(self, flow: TestFlow) -> None:
+        # Test with different tensor shapes
+
+        # 1D tensor
+        self._test_op(AbsModel(), (torch.randn(20),), flow)
+
+        # 2D tensor
+        self._test_op(AbsModel(), (torch.randn(5, 10),), flow)
+
+        # 3D tensor
+        self._test_op(AbsModel(), (torch.randn(3, 4, 5),), flow)
+
+    def test_abs_edge_cases(self, flow: TestFlow) -> None:
+        # Test edge cases
+
+        # Tensor with infinity
+        x = torch.tensor([float("inf"), float("-inf"), 1.0, -1.0])
+        self._test_op(AbsModel(), (x,), flow, generate_random_test_inputs=False)
+
+        # Tensor with NaN
+        x = torch.tensor([float("nan"), 1.0, -1.0])
+        self._test_op(AbsModel(), (x,), flow, generate_random_test_inputs=False)

backends/test/suite/operators/test_ceil.py

@@ -0,0 +1,57 @@
+# 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 torch
+from executorch.backends.test.suite.flow import TestFlow
+
+from executorch.backends.test.suite.operators import (
+    dtype_test,
+    operator_test,
+    OperatorTest,
+)
+
+
+class CeilModel(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, x):
+        return torch.ceil(x)
+
+
+@operator_test
+class TestCeil(OperatorTest):
+    @dtype_test
+    def test_ceil_dtype(self, flow: TestFlow, dtype) -> None:
+        # Test with different dtypes
+        model = CeilModel().to(dtype)
+        self._test_op(model, (torch.rand(10, 10).to(dtype) * 2 - 1,), flow)
+
+    def test_ceil_shapes(self, flow: TestFlow) -> None:
+        # Test with different tensor shapes
+
+        # 1D tensor
+        self._test_op(CeilModel(), (torch.randn(20),), flow)
+
+        # 2D tensor
+        self._test_op(CeilModel(), (torch.randn(5, 10),), flow)
+
+        # 3D tensor
+        self._test_op(CeilModel(), (torch.randn(3, 4, 5),), flow)
+
+    def test_ceil_edge_cases(self, flow: TestFlow) -> None:
+        # Test edge cases
+
+        # Tensor with infinity
+        x = torch.tensor([float("inf"), float("-inf"), 1.0, -1.0])
+        self._test_op(CeilModel(), (x,), flow, generate_random_test_inputs=False)
+
+        # Tensor with NaN
+        x = torch.tensor([float("nan"), 1.0, -1.0])
+        self._test_op(CeilModel(), (x,), flow, generate_random_test_inputs=False)

backends/test/suite/operators/test_clamp.py

@@ -0,0 +1,83 @@
+# 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 torch
+from executorch.backends.test.suite.flow import TestFlow
+
+from executorch.backends.test.suite.operators import (
+    dtype_test,
+    operator_test,
+    OperatorTest,
+)
+
+
+class ClampModel(torch.nn.Module):
+    def __init__(self, min_val=None, max_val=None):
+        super().__init__()
+        self.min_val = min_val
+        self.max_val = max_val
+
+    def forward(self, x):
+        return torch.clamp(x, min=self.min_val, max=self.max_val)
+
+
+@operator_test
+class TestClamp(OperatorTest):
+    @dtype_test
+    def test_clamp_dtype(self, flow: TestFlow, dtype) -> None:
+        # Test with different dtypes
+        model = ClampModel(min_val=-0.5, max_val=0.5).to(dtype)
+        self._test_op(model, (torch.rand(10, 10).to(dtype) * 2 - 1,), flow)
+
+    def test_clamp_min_only(self, flow: TestFlow) -> None:
+        # Test with only min value specified
+        self._test_op(ClampModel(min_val=0.0), (torch.randn(10, 10),), flow)
+
+    def test_clamp_max_only(self, flow: TestFlow) -> None:
+        # Test with only max value specified
+        self._test_op(ClampModel(max_val=0.0), (torch.randn(10, 10),), flow)
+
+    def test_clamp_shapes(self, flow: TestFlow) -> None:
+        # Test with different tensor shapes
+        model = ClampModel(min_val=-1.0, max_val=1.0)
+
+        # 1D tensor
+        self._test_op(model, (torch.randn(20),), flow)
+
+        # 2D tensor
+        self._test_op(model, (torch.randn(5, 10),), flow)
+
+        # 3D tensor
+        self._test_op(model, (torch.randn(3, 4, 5),), flow)
+
+    def test_clamp_edge_cases(self, flow: TestFlow) -> None:
+        # Test edge cases
+
+        # Min equals max
+        self._test_op(
+            ClampModel(min_val=0.0, max_val=0.0), (torch.randn(10, 10),), flow
+        )
+
+        # Tensor with infinity
+        x = torch.tensor([float("inf"), float("-inf"), 1.0, -1.0])
+        self._test_op(
+            ClampModel(min_val=-2.0, max_val=2.0),
+            (x,),
+            flow,
+            generate_random_test_inputs=False,
+        )
+
+        # Tensor with NaN
+        x = torch.tensor([float("nan"), 1.0, -1.0])
+        self._test_op(
+            ClampModel(min_val=-2.0, max_val=2.0),
+            (x,),
+            flow,
+            generate_random_test_inputs=False,
+        )

backends/test/suite/operators/test_exp.py

@@ -0,0 +1,62 @@
+# 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 torch
+from executorch.backends.test.suite.flow import TestFlow
+
+from executorch.backends.test.suite.operators import (
+    dtype_test,
+    operator_test,
+    OperatorTest,
+)
+
+
+class ExpModel(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, x):
+        return torch.exp(x)
+
+
+@operator_test
+class TestExp(OperatorTest):
+    @dtype_test
+    def test_exp_dtype(self, flow: TestFlow, dtype) -> None:
+        # Test with different dtypes
+        model = ExpModel().to(dtype)
+        # Use smaller range to avoid overflow
+        self._test_op(model, (torch.rand(10, 10).to(dtype) * 4 - 2,), flow)
+
+    def test_exp_shapes(self, flow: TestFlow) -> None:
+        # Test with different tensor shapes
+
+        # 1D tensor
+        self._test_op(ExpModel(), (torch.randn(20),), flow)
+
+        # 2D tensor
+        self._test_op(ExpModel(), (torch.randn(5, 10),), flow)
+
+        # 3D tensor
+        self._test_op(ExpModel(), (torch.randn(3, 4, 5),), flow)
+
+    def test_exp_edge_cases(self, flow: TestFlow) -> None:
+        # Test edge cases
+
+        # Tensor with infinity
+        x = torch.tensor([float("inf"), float("-inf"), 1.0, -1.0])
+        self._test_op(ExpModel(), (x,), flow, generate_random_test_inputs=False)
+
+        # Tensor with NaN
+        x = torch.tensor([float("nan"), 1.0, -1.0])
+        self._test_op(ExpModel(), (x,), flow, generate_random_test_inputs=False)
+
+        # Overflow
+        x = torch.tensor([10e10])
+        self._test_op(ExpModel(), (x,), flow, generate_random_test_inputs=False)

backends/test/suite/operators/test_floor.py

@@ -0,0 +1,54 @@
+# 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 torch
+from executorch.backends.test.suite.flow import TestFlow
+
+from executorch.backends.test.suite.operators import (
+    dtype_test,
+    operator_test,
+    OperatorTest,
+)
+
+
+class FloorModel(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+
+
+@operator_test
+class TestFloor(OperatorTest):
+    @dtype_test
+    def test_floor_dtype(self, flow: TestFlow, dtype) -> None:
+        # Test with different dtypes
+        model = FloorModel().to(dtype)
+        self._test_op(model, (torch.rand(10, 10).to(dtype) * 2 - 1,), flow)
+
+    def test_floor_shapes(self, flow: TestFlow) -> None:
+        # Test with different tensor shapes
+
+        # 1D tensor
+        self._test_op(FloorModel(), (torch.randn(20),), flow)
+
+        # 2D tensor
+        self._test_op(FloorModel(), (torch.randn(5, 10),), flow)
+
+        # 3D tensor
+        self._test_op(FloorModel(), (torch.randn(3, 4, 5),), flow)
+
+    def test_floor_edge_cases(self, flow: TestFlow) -> None:
+        # Test edge cases
+
+        # Tensor with infinity
+        x = torch.tensor([float("inf"), float("-inf"), 1.0, -1.0])
+        self._test_op(FloorModel(), (x,), flow, generate_random_test_inputs=False)
+
+        # Tensor with NaN
+        x = torch.tensor([float("nan"), 1.0, -1.0])
+        self._test_op(FloorModel(), (x,), flow, generate_random_test_inputs=False)

backends/test/suite/operators/test_log.py

@@ -0,0 +1,57 @@
+# 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 torch
+from executorch.backends.test.suite.flow import TestFlow
+
+from executorch.backends.test.suite.operators import (
+    dtype_test,
+    operator_test,
+    OperatorTest,
+)
+
+
+class LogModel(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+
+    def forward(self, x):
+        return torch.log(x)
+
+
+@operator_test
+class TestLog(OperatorTest):
+    @dtype_test
+    def test_log_dtype(self, flow: TestFlow, dtype) -> None:
+        # Test with different dtypes
+        model = LogModel().to(dtype)
+        # Use positive values only for log
+        self._test_op(model, (torch.rand(10, 10).to(dtype) + 0.01,), flow)
+
+    def test_log_shapes(self, flow: TestFlow) -> None:
+        # Test with different tensor shapes
+
+        # 1D tensor
+        self._test_op(LogModel(), (torch.rand(20) + 0.01,), flow)
+
+        # 2D tensor
+        self._test_op(LogModel(), (torch.rand(5, 10) + 0.01,), flow)
+
+        # 3D tensor
+        self._test_op(LogModel(), (torch.rand(3, 4, 5) + 0.01,), flow)
+
+    def test_log_edge_cases(self, flow: TestFlow) -> None:
+        # Test edge cases
+        # Tensor with infinity
+        x = torch.tensor([float("inf"), 1.0, 2.0])
+        self._test_op(LogModel(), (x,), flow, generate_random_test_inputs=False)
+
+        # Tensor with NaN
+        x = torch.tensor([float("nan"), 1.0, 2.0])
+        self._test_op(LogModel(), (x,), flow, generate_random_test_inputs=False)