Add Op UnitTest For Max/Mod/Multiply

python/tests/ops/test_max_op.py

@@ -14,12 +14,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import unittest
-import numpy as np
 from op_test import OpTest, OpTestTool
+from op_test_helper import TestCaseHelper
 import paddle
-import paddle.nn.functional as F
-import cinn
 from cinn.frontend import *
 from cinn.common import *
 
@@ -28,81 +25,254 @@
                     "x86 test will be skipped due to timeout.")
 class TestMaxOp(OpTest):
     def setUp(self):
-        self.init_case()
+        print(f"\nRunning {self.__class__.__name__}: {self.case}")
+        self.prepare_inputs()
 
-    def init_case(self):
-        self.inputs = {
-            "x": np.random.random((16, 64)).astype("float32"),
-            "y": np.random.random((16, 64)).astype("float32")
-        }
+    def prepare_inputs(self):
+        self.x_np = self.random(
+            shape=self.case["x_shape"],
+            dtype=self.case["x_dtype"],
+            low=self.case["x_low"],
+            high=self.case["x_high"])
+        self.y_np = self.random(
+            shape=self.case["y_shape"],
+            dtype=self.case["y_dtype"],
+            low=self.case["y_low"],
+            high=self.case["y_high"])
 
     def build_paddle_program(self, target):
-        x = paddle.to_tensor(self.inputs["x"], stop_gradient=False)
-        y = paddle.to_tensor(self.inputs["y"], stop_gradient=False)
-
+        x = paddle.to_tensor(self.x_np, stop_gradient=True)
+        y = paddle.to_tensor(self.y_np, stop_gradient=True)
         out = paddle.maximum(x, y)
-
         self.paddle_outputs = [out]
 
     def build_cinn_program(self, target):
         builder = NetBuilder("pow")
         x = builder.create_input(
-            self.nptype2cinntype(self.inputs["x"].dtype),
-            self.inputs["x"].shape, "x")
+            self.nptype2cinntype(self.case["x_dtype"]), self.case["x_shape"],
+            "x")
         y = builder.create_input(
-            self.nptype2cinntype(self.inputs["y"].dtype),
-            self.inputs["y"].shape, "y")
+            self.nptype2cinntype(self.case["y_dtype"]), self.case["y_shape"],
+            "y")
         out = builder.max(x, y)
-
         prog = builder.build()
         res = self.get_cinn_output(prog, target, [x, y],
-                                   [self.inputs["x"], self.inputs["y"]], [out])
+                                   [self.x_np, self.y_np], [out])
 
         self.cinn_outputs = [res[0]]
 
     def test_check_results(self):
-        self.check_outputs_and_grads()
+        max_relative_error = self.case[
+            "max_relative_error"] if "max_relative_error" in self.case else 1e-5
+        self.check_outputs_and_grads(max_relative_error=max_relative_error)
 
 
-@OpTestTool.skip_if(not is_compiled_with_cuda(),
-                    "x86 test will be skipped due to timeout.")
-class TestMinOp(OpTest):
-    def setUp(self):
-        self.init_case()
+class TestMaxOpBase(TestCaseHelper):
 
-    def init_case(self):
-        self.inputs = {
-            "x": np.random.random((16, 64)).astype("float32"),
-            "y": np.random.random((16, 64)).astype("float32")
-        }
+    inputs = [
+        {
+            "x_shape": [1],
+            "y_shape": [1],
+        },
+        {
+            "x_shape": [32, 64],
+            "y_shape": [32, 64],
+        },
+        {
+            "x_shape": [2, 3, 4],
+            "y_shape": [2, 3, 4],
+        },
+        {
+            "x_shape": [16, 8, 4, 2],
+            "y_shape": [16, 8, 4, 2],
+        },
+        {
+            "x_shape": [16, 8, 4, 2, 1],
+            "y_shape": [16, 8, 4, 2, 1],
+        },
+    ]
 
-    def build_paddle_program(self, target):
-        x = paddle.to_tensor(self.inputs["x"], stop_gradient=False)
-        y = paddle.to_tensor(self.inputs["y"], stop_gradient=False)
+    dtypes = [
+        {
+            "x_dtype": "float32",
+            "y_dtype": "float32",
+        },
+    ]
 
-        out = paddle.minimum(x, y)
+    attrs = [
+        {
+            "x_low": -100,
+            "x_high": 100,
+            "y_low": -100,
+            "y_high": 100
+        },
+    ]
 
-        self.paddle_outputs = [out]
+    def init_attrs(self):
+        self.class_name = "TestMaxOpBase"
+        self.cls = TestMaxOp
 
-    def build_cinn_program(self, target):
-        builder = NetBuilder("pow")
-        x = builder.create_input(
-            self.nptype2cinntype(self.inputs["x"].dtype),
-            self.inputs["x"].shape, "x")
-        y = builder.create_input(
-            self.nptype2cinntype(self.inputs["y"].dtype),
-            self.inputs["y"].shape, "y")
-        out = builder.min(x, y)
 
-        prog = builder.build()
-        res = self.get_cinn_output(prog, target, [x, y],
-                                   [self.inputs["x"], self.inputs["y"]], [out])
+class TestMaxOpShapeTest(TestMaxOpBase):
+    def init_attrs(self):
+        self.class_name = "TestMaxOpShapeTest"
+        self.cls = TestMaxOp
+        self.inputs = [{
+            "x_shape": [1],
+            "y_shape": [1],
+        }, {
+            "x_shape": [1024],
+            "y_shape": [1024],
+        }, {
+            "x_shape": [2048],
+            "y_shape": [2048],
+        }, {
+            "x_shape": [32, 64],
+            "y_shape": [32, 64],
+        }, {
+            "x_shape": [2, 3, 4],
+            "y_shape": [2, 3, 4],
+        }, {
+            "x_shape": [16, 8, 4, 2],
+            "y_shape": [16, 8, 4, 2],
+        }, {
+            "x_shape": [16, 8, 4, 1024],
+            "y_shape": [16, 8, 4, 1024],
+        }, {
+            "x_shape": [16, 8, 4, 2, 1],
+            "y_shape": [16, 8, 4, 2, 1],
+        }, {
+            "x_shape": [1, 1, 1, 1, 1],
+            "y_shape": [1, 1, 1, 1, 1],
+        }]
 
-        self.cinn_outputs = [res[0]]
 
-    def test_check_results(self):
-        self.check_outputs_and_grads()
+class TestMaxOpDtypeTest(TestMaxOpBase):
+    def init_attrs(self):
+        self.class_name = "TestMaxOpDtypeTest"
+        self.cls = TestMaxOp
+        self.dtypes = [
+            #{
+            #"x_dtype": "int8",
+            #"y_dtype": "int8",
+            #}, {
+            #"x_dtype": "int16",
+            #"y_dtype": "int16",
+            #}, {
+            #"x_dtype": "uint8",
+            #"y_dtype": "uint8",
+            #}, {
+            #"x_dtype": "uint16",
+            #"y_dtype": "uint16",
+            #},
+            {
+                "x_dtype": "int32",
+                "y_dtype": "int32",
+            },
+            {
+                "x_dtype": "int64",
+                "y_dtype": "int64",
+            },
+            #{
+            #    "x_dtype": "float16",
+            #    "y_dtype": "float16",
+            #    "max_relative_error": 1e-3,
+            #},
+            {
+                "x_dtype": "float32",
+                "y_dtype": "float32",
+            },
+            {
+                "x_dtype": "float64",
+                "y_dtype": "float64",
+            }
+        ]
+
+
+class TestMaxOpPolarityTest(TestMaxOpBase):
+    def init_attrs(self):
+        self.class_name = "TestMaxOpPolarityTest"
+        self.cls = TestMaxOp
+        self.attrs = [{
+            "x_low": -100,
+            "x_high": 100,
+            "y_low": -100,
+            "y_high": 100,
+        }]
+
+
+class TestMaxOpBroadcastTest(TestMaxOpBase):
+    def init_attrs(self):
+        self.class_name = "TestMaxOpBroadcastTest"
+        self.cls = TestMaxOp
+        self.inputs = [{
+            "x_shape": [32],
+            "y_shape": [1],
+        }, {
+            "x_shape": [1],
+            "y_shape": [32],
+        }, {
+            "x_shape": [1, 64],
+            "y_shape": [32, 1],
+        }, {
+            "x_shape": [1, 64],
+            "y_shape": [32, 64],
+        }, {
+            "x_shape": [32, 1],
+            "y_shape": [32, 64],
+        }, {
+            "x_shape": [1, 1],
+            "y_shape": [32, 64],
+        }, {
+            "x_shape": [1, 3, 4],
+            "y_shape": [2, 3, 4],
+        }, {
+            "x_shape": [1, 3, 1],
+            "y_shape": [2, 3, 4],
+        }, {
+            "x_shape": [1, 1, 1],
+            "y_shape": [2, 3, 4],
+        }, {
+            "x_shape": [2, 1, 1],
+            "y_shape": [1, 3, 4],
+        }, {
+            "x_shape": [1, 8, 4, 2],
+            "y_shape": [16, 8, 4, 2],
+        }, {
+            "x_shape": [16, 8, 1, 1],
+            "y_shape": [16, 8, 4, 2],
+        }, {
+            "x_shape": [1, 8, 1, 1],
+            "y_shape": [16, 8, 4, 2],
+        }, {
+            "x_shape": [1, 1, 1, 1],
+            "y_shape": [16, 8, 4, 2],
+        }, {
+            "x_shape": [1, 8, 1, 2],
+            "y_shape": [16, 1, 4, 1],
+        }, {
+            "x_shape": [1, 8, 4, 2, 32],
+            "y_shape": [16, 8, 4, 2, 32],
+        }, {
+            "x_shape": [16, 1, 1, 2, 32],
+            "y_shape": [16, 8, 4, 2, 32],
+        }, {
+            "x_shape": [16, 1, 4, 1, 1],
+            "y_shape": [16, 8, 4, 2, 32],
+        }, {
+            "x_shape": [1, 1, 1, 1, 32],
+            "y_shape": [16, 8, 4, 2, 32],
+        }, {
+            "x_shape": [1, 1, 1, 1, 1],
+            "y_shape": [16, 8, 4, 2, 32],
+        }, {
+            "x_shape": [16, 1, 4, 1, 32],
+            "y_shape": [1, 8, 1, 2, 1],
+        }]
 
 
 if __name__ == "__main__":
-    unittest.main()
+    TestMaxOpShapeTest().run()
+    TestMaxOpDtypeTest().run()
+    TestMaxOpPolarityTest().run()
+    TestMaxOpBroadcastTest().run()