【PIR API adaptor No.22】Migrate paddle.nn.functional.bilinear into pir (#58690)

GreatV · web-flow · commit 9528c7eb1109 · 2023-11-14T10:40:22.000+08:00
diff --git a/python/paddle/nn/functional/common.py b/python/paddle/nn/functional/common.py
@@ -941,7 +941,7 @@ def bilinear(x1, x2, weight, bias=None, name=None):
             [5, 1000]
     """
 
-    if in_dynamic_mode():
+    if in_dynamic_or_pir_mode():
         return _C_ops.bilinear(x1, x2, weight, bias)
     else:
         check_variable_and_dtype(x1, 'x1', ['float32', 'float64'], 'bilinear')
diff --git a/test/legacy_test/test_bilinear_api.py b/test/legacy_test/test_bilinear_api.py
@@ -19,13 +19,15 @@
 import paddle
 from paddle import base
 from paddle.base import core
+from paddle.pir_utils import test_with_pir_api
 
 
 class TestBilinearAPI(unittest.TestCase):
+    @test_with_pir_api
     def test_api(self):
-        with base.program_guard(
-            base.default_startup_program(), base.default_main_program()
-        ):
+        main = paddle.static.Program()
+        startup = paddle.static.Program()
+        with paddle.static.program_guard(startup, main):
             if core.is_compiled_with_cuda():
                 place = core.CUDAPlace(0)
             else:
@@ -43,9 +45,9 @@ def test_api(self):
             )
             ret = bilinear(data1, data2)
 
-            exe.run(base.default_startup_program())
+            exe.run(main)
             ret_fetch = exe.run(
-                feed={'X1': layer1, 'X2': layer2}, fetch_list=[ret.name]
+                feed={'X1': layer1, 'X2': layer2}, fetch_list=[ret]
             )
             self.assertEqual(ret_fetch[0].shape, (5, 1000))
 
diff --git a/test/legacy_test/test_layers.py b/test/legacy_test/test_layers.py
@@ -498,116 +498,148 @@ def test_type():
             self.assertRaises(TypeError, test_type)
 
     def test_bilinear_tensor_product(self):
-        inp_np_x = np.array([[1, 2, 3]]).astype('float32')
-        inp_np_y = np.array([[4, 5, 6]]).astype('float32')
+        def _test_static_specific(inp_np_x, inp_np_y):
+            with self.static_graph():
+                data_x = paddle.static.data(
+                    name='x', shape=[1, 3], dtype="float32"
+                )
+                data_y = paddle.static.data(
+                    name='y', shape=[1, 3], dtype="float32"
+                )
+                out = paddle.static.nn.common.bilinear_tensor_product(
+                    data_x,
+                    data_y,
+                    6,
+                    bias_attr=paddle.nn.initializer.Constant(value=1),
+                    act='sigmoid',
+                )
 
-        with self.static_graph():
-            data_x = paddle.static.data(name='x', shape=[1, 3], dtype="float32")
-            data_y = paddle.static.data(name='y', shape=[1, 3], dtype="float32")
-            out = paddle.static.nn.common.bilinear_tensor_product(
-                data_x,
-                data_y,
-                6,
-                bias_attr=paddle.nn.initializer.Constant(value=1),
-                act='sigmoid',
-            )
+                static_rlt = self.get_static_graph_result(
+                    feed={'x': inp_np_x, 'y': inp_np_y}, fetch_list=[out]
+                )[0]
 
-            static_rlt = self.get_static_graph_result(
-                feed={'x': inp_np_x, 'y': inp_np_y}, fetch_list=[out]
-            )[0]
+            return static_rlt
 
-        with self.static_graph():
-            data_x = paddle.static.data(name='x', shape=[1, 3], dtype="float32")
-            data_y = paddle.static.data(name='y', shape=[1, 3], dtype="float32")
-            btp = paddle.nn.Bilinear(
-                3,
-                3,
-                6,
-                bias_attr=paddle.nn.initializer.Constant(value=1),
-            )
-            out = btp(data_x, data_y)
-            out = paddle.nn.functional.sigmoid(out)
-            static_rlt2 = self.get_static_graph_result(
-                feed={'x': inp_np_x, 'y': inp_np_y}, fetch_list=[out]
-            )[0]
-        with self.dynamic_graph():
-            btp = paddle.nn.Bilinear(
-                3,
-                3,
-                6,
-                bias_attr=paddle.nn.initializer.Constant(value=1),
-            )
-            dy_rlt = btp(
-                to_variable(inp_np_x),
-                to_variable(inp_np_y),
-            )
-            dy_rlt = paddle.nn.functional.sigmoid(dy_rlt)
-            dy_rlt_value = dy_rlt.numpy()
+        def _test_static(inp_np_x, inp_np_y):
+            with self.static_graph():
+                data_x = paddle.static.data(
+                    name='x', shape=[1, 3], dtype="float32"
+                )
+                data_y = paddle.static.data(
+                    name='y', shape=[1, 3], dtype="float32"
+                )
+                btp = paddle.nn.Bilinear(
+                    3,
+                    3,
+                    6,
+                    bias_attr=paddle.nn.initializer.Constant(value=1),
+                )
+                out = btp(data_x, data_y)
+                out = paddle.nn.functional.sigmoid(out)
+                static_rlt2 = self.get_static_graph_result(
+                    feed={'x': inp_np_x, 'y': inp_np_y}, fetch_list=[out]
+                )[0]
 
-        with self.dynamic_graph():
-            btp2 = paddle.nn.Bilinear(3, 3, 6)
-            dy_rlt2 = btp2(
-                to_variable(inp_np_x),
-                to_variable(inp_np_y),
-            )
-            dy_rlt2 = paddle.nn.functional.sigmoid(dy_rlt2)
-            dy_rlt2_value = dy_rlt2.numpy()
+            return static_rlt2
 
-        with self.static_graph():
-            data_x2 = paddle.static.data(
-                name='x', shape=[1, 3], dtype="float32"
-            )
-            data_y2 = paddle.static.data(
-                name='y', shape=[1, 3], dtype="float32"
-            )
-            out2 = paddle.static.nn.common.bilinear_tensor_product(
-                data_x2, data_y2, 6, act='sigmoid'
-            )
+        def _test_dygraph_1(inp_np_x, inp_np_y):
+            with self.dynamic_graph():
+                btp = paddle.nn.Bilinear(
+                    3,
+                    3,
+                    6,
+                    bias_attr=paddle.nn.initializer.Constant(value=1),
+                )
+                dy_rlt = btp(
+                    to_variable(inp_np_x),
+                    to_variable(inp_np_y),
+                )
+                dy_rlt = paddle.nn.functional.sigmoid(dy_rlt)
+                dy_rlt_value = dy_rlt.numpy()
 
-            static_rlt3 = self.get_static_graph_result(
-                feed={'x': inp_np_x, 'y': inp_np_y}, fetch_list=[out2]
-            )[0]
+            with self.dynamic_graph():
+                btp2 = paddle.nn.Bilinear(3, 3, 6)
+                dy_rlt2 = btp2(
+                    to_variable(inp_np_x),
+                    to_variable(inp_np_y),
+                )
+                dy_rlt2 = paddle.nn.functional.sigmoid(dy_rlt2)
+                dy_rlt2_value = dy_rlt2.numpy()
 
+            with self.static_graph():
+                data_x2 = paddle.static.data(
+                    name='x', shape=[1, 3], dtype="float32"
+                )
+                data_y2 = paddle.static.data(
+                    name='y', shape=[1, 3], dtype="float32"
+                )
+                out2 = paddle.static.nn.common.bilinear_tensor_product(
+                    data_x2, data_y2, 6, act='sigmoid'
+                )
+
+                static_rlt3 = self.get_static_graph_result(
+                    feed={'x': inp_np_x, 'y': inp_np_y}, fetch_list=[out2]
+                )[0]
+
+            return dy_rlt_value, dy_rlt2_value, static_rlt3
+
+        def _test_dygraph_2(inp_np_x, inp_np_y):
+            with self.dynamic_graph():
+                custom_weight = np.random.randn(6, 3, 3).astype("float32")
+                weight_attr = base.ParamAttr(
+                    initializer=paddle.nn.initializer.Assign(custom_weight)
+                )
+                btp1 = paddle.nn.Bilinear(3, 3, 6)
+                btp2 = paddle.nn.Bilinear(3, 3, 6, weight_attr=weight_attr)
+                dy_rlt1 = btp1(
+                    to_variable(inp_np_x),
+                    to_variable(inp_np_y),
+                )
+                dy_rlt1 = paddle.nn.functional.sigmoid(dy_rlt1)
+                dy_rlt2 = btp2(
+                    to_variable(inp_np_x),
+                    to_variable(inp_np_y),
+                )
+                dy_rlt2 = paddle.nn.functional.sigmoid(dy_rlt2)
+                self.assertFalse(
+                    np.array_equal(dy_rlt1.numpy(), dy_rlt2.numpy())
+                )
+                btp2.weight.set_value(btp1.weight.numpy())
+                btp2.bias.set_value(btp1.bias)
+                dy_rlt1 = btp1(
+                    to_variable(inp_np_x),
+                    to_variable(inp_np_y),
+                )
+                dy_rlt2 = btp2(
+                    to_variable(inp_np_x),
+                    to_variable(inp_np_y),
+                )
+                np.testing.assert_array_equal(dy_rlt1.numpy(), dy_rlt2.numpy())
+
+                btp2.weight = btp1.weight
+                btp2.bias = btp1.bias
+                np.testing.assert_array_equal(
+                    btp1.weight.numpy(), btp2.weight.numpy()
+                )
+                np.testing.assert_array_equal(
+                    btp1.bias.numpy(), btp2.bias.numpy()
+                )
+
+        inp_np_x = np.array([[1, 2, 3]]).astype('float32')
+        inp_np_y = np.array([[4, 5, 6]]).astype('float32')
+
+        static_rlt = _test_static_specific(inp_np_x, inp_np_y)
+        static_rlt2 = _test_static(inp_np_x, inp_np_y)
+        dy_rlt_value, dy_rlt2_value, static_rlt3 = _test_dygraph_1(
+            inp_np_x, inp_np_y
+        )
         np.testing.assert_array_equal(dy_rlt2_value, static_rlt3)
         np.testing.assert_array_equal(static_rlt2, static_rlt)
         np.testing.assert_array_equal(dy_rlt_value, static_rlt)
 
-        with self.dynamic_graph():
-            custom_weight = np.random.randn(6, 3, 3).astype("float32")
-            weight_attr = base.ParamAttr(
-                initializer=paddle.nn.initializer.Assign(custom_weight)
-            )
-            btp1 = paddle.nn.Bilinear(3, 3, 6)
-            btp2 = paddle.nn.Bilinear(3, 3, 6, weight_attr=weight_attr)
-            dy_rlt1 = btp1(
-                to_variable(inp_np_x),
-                to_variable(inp_np_y),
-            )
-            dy_rlt1 = paddle.nn.functional.sigmoid(dy_rlt1)
-            dy_rlt2 = btp2(
-                to_variable(inp_np_x),
-                to_variable(inp_np_y),
-            )
-            dy_rlt2 = paddle.nn.functional.sigmoid(dy_rlt2)
-            self.assertFalse(np.array_equal(dy_rlt1.numpy(), dy_rlt2.numpy()))
-            btp2.weight.set_value(btp1.weight.numpy())
-            btp2.bias.set_value(btp1.bias)
-            dy_rlt1 = btp1(
-                to_variable(inp_np_x),
-                to_variable(inp_np_y),
-            )
-            dy_rlt2 = btp2(
-                to_variable(inp_np_x),
-                to_variable(inp_np_y),
-            )
-            np.testing.assert_array_equal(dy_rlt1.numpy(), dy_rlt2.numpy())
-
-            btp2.weight = btp1.weight
-            btp2.bias = btp1.bias
-            np.testing.assert_array_equal(
-                btp1.weight.numpy(), btp2.weight.numpy()
-            )
-            np.testing.assert_array_equal(btp1.bias.numpy(), btp2.bias.numpy())
+        with paddle.pir_utils.IrGuard():
+            static_pir_result = _test_static(inp_np_x, inp_np_y)
+        np.testing.assert_array_equal(static_pir_result, static_rlt)
 
     def test_embeding(self):
         inp_word = np.array([[[1]]]).astype('int64')
