【PIR API adaptor No.115】 Migrate instance_norm into pir (#59371)

MarioLulab · web-flow · commit 87353eedc6e8 · 2023-11-29T15:51:31.000+08:00
diff --git a/python/paddle/nn/functional/norm.py b/python/paddle/nn/functional/norm.py
@@ -441,7 +441,7 @@ def instance_norm(
                [ 0.74275863, -0.11246002,  1.73788261]]]])
 
     """
-    if in_dygraph_mode():
+    if in_dynamic_or_pir_mode():
         out = _C_ops.instance_norm(x, weight, bias, eps)
         return out
     else:
diff --git a/test/legacy_test/test_instance_norm_op.py b/test/legacy_test/test_instance_norm_op.py
@@ -130,10 +130,12 @@ def setUp(self):
         }
 
     def test_check_output(self):
-        self.check_output(check_prim=True)
+        self.check_output(check_prim=True, check_pir=True)
 
     def test_check_grad(self):
-        self.check_grad(['X', 'Scale', 'Bias'], 'Y', check_prim=True)
+        self.check_grad(
+            ['X', 'Scale', 'Bias'], 'Y', check_prim=True, check_pir=True
+        )
 
     def init_test_case(self):
         x_shape = [2, 100, 4, 5]
diff --git a/test/legacy_test/test_instance_norm_op_v2.py b/test/legacy_test/test_instance_norm_op_v2.py
@@ -21,7 +21,8 @@
 
 import paddle
 from paddle import base
-from paddle.base import Program, core, program_guard
+from paddle.base import core
+from paddle.pir_utils import test_with_pir_api
 
 
 def instance_norm_wrapper(
@@ -140,6 +141,7 @@ def compute_v2(x):
             y2 = compute_v2(x)
             np.testing.assert_allclose(y1, y2, rtol=1e-05)
 
+    @test_with_pir_api
     def test_static(self):
         with static_guard():
             places = [base.CPUPlace()]
@@ -152,24 +154,28 @@ def test_static(self):
                 shape = [4, 10, 16, 16]
 
                 def compute_v1(x_np):
-                    with program_guard(Program(), Program()):
+                    with paddle.static.program_guard(
+                        paddle.static.Program(), paddle.static.Program()
+                    ):
                         ins = paddle.nn.InstanceNorm2D(shape[1])
                         x = paddle.static.data(
                             name='x', shape=x_np.shape, dtype=x_np.dtype
                         )
                         y = ins(x)
-                        exe.run(base.default_startup_program())
+                        exe.run(paddle.static.default_startup_program())
                         r = exe.run(feed={'x': x_np}, fetch_list=[y])[0]
                     return r
 
                 def compute_v2(x_np):
-                    with program_guard(Program(), Program()):
+                    with paddle.static.program_guard(
+                        paddle.static.Program(), paddle.static.Program()
+                    ):
                         ins = paddle.nn.InstanceNorm2D(shape[1])
                         x = paddle.static.data(
                             name='x', shape=x_np.shape, dtype=x_np.dtype
                         )
                         y = ins(x)
-                        exe.run(base.default_startup_program())
+                        exe.run(paddle.static.default_startup_program())
                         r = exe.run(feed={'x': x_np}, fetch_list=[y])[0]
                     return r
 
@@ -213,10 +219,17 @@ def setUp(self):
         )
 
     def test_check_output(self):
-        self.check_output(atol=self.atol, check_prim=self.check_prim)
+        self.check_output(
+            atol=self.atol, check_prim=self.check_prim, check_pir=True
+        )
 
     def test_check_grad(self):
-        self.check_grad(['X', 'Scale', 'Bias'], 'Y', check_prim=self.check_prim)
+        self.check_grad(
+            ['X', 'Scale', 'Bias'],
+            'Y',
+            check_prim=self.check_prim,
+            check_pir=True,
+        )
 
     def init_dtype(self):
         self.dtype = np.float32
@@ -259,7 +272,7 @@ def set_err_thre(self):
     def test_check_output(self):
         place = core.CUDAPlace(0)
         self.check_output_with_place(
-            place, atol=self.atol, check_prim=self.check_prim
+            place, atol=self.atol, check_prim=self.check_prim, check_pir=True
         )
 
     def test_check_grad(self):
@@ -270,6 +283,7 @@ def test_check_grad(self):
             'Y',
             max_relative_error=self.max_relative_error,
             check_prim=self.check_prim,
+            check_pir=True,
         )
 
 
@@ -329,7 +343,9 @@ def init_shape(self):
 
     def test_check_output(self):
         place = core.CUDAPlace(0)
-        self.check_output_with_place(place, check_prim=self.check_prim)
+        self.check_output_with_place(
+            place, check_prim=self.check_prim, check_pir=True
+        )
 
     def test_check_grad(self):
         place = core.CUDAPlace(0)
@@ -339,6 +355,7 @@ def test_check_grad(self):
             'Y',
             user_defined_grads=self.user_defined_grads,
             check_prim=self.check_prim,
+            check_pir=True,
         )
 
 
diff --git a/test/legacy_test/test_layers.py b/test/legacy_test/test_layers.py
@@ -914,52 +914,77 @@ def test_instance_norm(self):
 
         shape = (2, 4, 3, 3)
 
-        input = np.random.random(shape).astype('float32')
+        def _test_static_specific(input):
+            with self.static_graph():
+                X = paddle.static.data(name='X', shape=shape, dtype='float32')
+                ret = paddle.static.nn.instance_norm(input=X)
+                static_ret = self.get_static_graph_result(
+                    feed={'X': input}, fetch_list=[ret]
+                )[0]
+            return static_ret
 
-        with self.static_graph():
-            X = paddle.static.data(name='X', shape=shape, dtype='float32')
-            ret = paddle.static.nn.instance_norm(input=X)
-            static_ret = self.get_static_graph_result(
-                feed={'X': input}, fetch_list=[ret]
-            )[0]
+        def _test_static(input):
+            with self.static_graph():
+                X = paddle.static.data(name='X', shape=shape, dtype='float32')
+                instanceNorm = paddle.nn.InstanceNorm2D(num_features=shape[1])
+                ret = instanceNorm(X)
+                static_ret2 = self.get_static_graph_result(
+                    feed={'X': input}, fetch_list=[ret]
+                )[0]
+            return static_ret2
 
-        with self.static_graph():
-            X = paddle.static.data(name='X', shape=shape, dtype='float32')
-            instanceNorm = paddle.nn.InstanceNorm2D(num_features=shape[1])
-            ret = instanceNorm(X)
-            static_ret2 = self.get_static_graph_result(
-                feed={'X': input}, fetch_list=[ret]
-            )[0]
+        def _test_dygraph_1(input):
+            with self.dynamic_graph():
+                instanceNorm = paddle.nn.InstanceNorm2D(num_features=shape[1])
+                dy_ret = instanceNorm(to_variable(input))
+                dy_rlt_value = dy_ret.numpy()
 
-        with self.dynamic_graph():
-            instanceNorm = paddle.nn.InstanceNorm2D(num_features=shape[1])
-            dy_ret = instanceNorm(to_variable(input))
-            dy_rlt_value = dy_ret.numpy()
+            return dy_rlt_value
 
-        with self.dynamic_graph():
-            instanceNorm = paddle.nn.InstanceNorm2D(num_features=shape[1])
-            dy_ret = instanceNorm(to_variable(input))
-            dy_rlt_value2 = dy_ret.numpy()
+        def _test_dygraph_2(input):
+            with self.dynamic_graph():
+                instanceNorm = paddle.nn.InstanceNorm2D(num_features=shape[1])
+                dy_ret = instanceNorm(to_variable(input))
+                dy_rlt_value2 = dy_ret.numpy()
+            return dy_rlt_value2
+
+        input = np.random.random(shape).astype('float32')
+        static_ret = _test_static_specific(input)
+        static_ret2 = _test_static(input)
+        dy_rlt_value = _test_dygraph_1(input)
+        dy_rlt_value2 = _test_dygraph_2(input)
 
         np.testing.assert_allclose(static_ret, dy_rlt_value, rtol=1e-05)
         np.testing.assert_allclose(static_ret, dy_rlt_value2, rtol=1e-05)
         np.testing.assert_allclose(static_ret, static_ret2, rtol=1e-05)
 
-        with self.static_graph():
-            # the input of InstanceNorm must be Variable.
-            def test_Variable():
-                instanceNorm = paddle.nn.InstanceNorm2D(num_features=shape[1])
-                ret1 = instanceNorm(input)
+        with paddle.pir_utils.IrGuard():
+            static_ret_pir = _test_static(input)
 
-            self.assertRaises(TypeError, test_Variable)
+        np.testing.assert_allclose(static_ret2, static_ret_pir, rtol=1e-05)
 
-            # the input dtype of InstanceNorm must be float32 or float64
-            def test_type():
-                input = np.random.random(shape).astype('int32')
-                instanceNorm = paddle.nn.InstanceNorm2D(num_features=shape[1])
-                ret2 = instanceNorm(input)
+        def _test_errors():
+            with self.static_graph():
+                # the input of InstanceNorm must be Variable.
+                def test_Variable():
+                    instanceNorm = paddle.nn.InstanceNorm2D(
+                        num_features=shape[1]
+                    )
+                    ret1 = instanceNorm(input)
 
-            self.assertRaises(TypeError, test_type)
+                self.assertRaises(TypeError, test_Variable)
+
+                # the input dtype of InstanceNorm must be float32 or float64
+                def test_type():
+                    input = np.random.random(shape).astype('int32')
+                    instanceNorm = paddle.nn.InstanceNorm2D(
+                        num_features=shape[1]
+                    )
+                    ret2 = instanceNorm(input)
+
+                self.assertRaises(TypeError, test_type)
+
+        _test_errors()
 
     def test_spectral_norm(self):
         if core.is_compiled_with_cuda():
