[BugFix] fix bugs in DCU unit tests (#54874)

lishicheng1996 · web-flow · commit abc1c3d40c40 · 2023-06-27T17:28:59.000+08:00
* block bf16 tests on ROCM

* block more bf16 tests on ROCM

* some unittest cases doesn't have kernels on ROCm

* some unittest cases doesn't have kernels on ROCm

* fix code style
diff --git a/test/legacy_test/test_assign_op.py b/test/legacy_test/test_assign_op.py
@@ -72,7 +72,8 @@ def test_backward(self):
 
 
 @unittest.skipIf(
-    not paddle.is_compiled_with_cuda(), "BFP16 test runs only on GPU"
+    not paddle.is_compiled_with_cuda() or paddle.is_compiled_with_rocm(),
+    "BFP16 test runs only on CUDA",
 )
 class TestAssignBFP16Op(eager_op_test.OpTest):
     def setUp(self):
diff --git a/test/legacy_test/test_cast_op.py b/test/legacy_test/test_cast_op.py
@@ -95,6 +95,10 @@ def test_grad(self):
         self.check_grad(['X'], ['Out'], check_prim=True, only_check_prim=True)
 
 
+@unittest.skipIf(
+    not paddle.is_compiled_with_cuda() or paddle.is_compiled_with_rocm(),
+    "BFP16 test runs only on CUDA",
+)
 class TestCastOpBf16ToFp32(OpTest):
     def setUp(self):
         ipt = np.array(np.random.randint(10, size=[10, 10])).astype('uint16')
@@ -120,6 +124,10 @@ def test_grad(self):
         self.check_grad(['X'], ['Out'], check_prim=True, only_check_prim=True)
 
 
+@unittest.skipIf(
+    not paddle.is_compiled_with_cuda() or paddle.is_compiled_with_rocm(),
+    "BFP16 test runs only on CUDA",
+)
 class TestCastOpFp32ToBf16(OpTest):
     def setUp(self):
         ipt = np.random.random(size=[10, 10]).astype('float32')
diff --git a/test/legacy_test/test_elementwise_mul_op.py b/test/legacy_test/test_elementwise_mul_op.py
@@ -163,6 +163,10 @@ def init_input_output(self):
         self.out = np.multiply(self.x, self.y)
 
 
+@unittest.skipIf(
+    not paddle.is_compiled_with_cuda() or paddle.is_compiled_with_rocm(),
+    "BFP16 test runs only on CUDA",
+)
 class TestBF16ElementwiseMulOp(OpTest):
     def setUp(self):
         self.op_type = "elementwise_mul"
diff --git a/test/legacy_test/test_elementwise_pow_op.py b/test/legacy_test/test_elementwise_pow_op.py
@@ -268,6 +268,10 @@ def test_check_grad(self):
         )
 
 
+@unittest.skipIf(
+    not paddle.is_compiled_with_cuda() or paddle.is_compiled_with_rocm(),
+    "BFP16 test runs only on CUDA",
+)
 class TestElementwisePowBF16Op(OpTest):
     def setUp(self):
         self.op_type = "elementwise_pow"
diff --git a/test/legacy_test/test_fill_any_like_op.py b/test/legacy_test/test_fill_any_like_op.py
@@ -64,7 +64,8 @@ def if_enable_cinn(self):
 
 
 @unittest.skipIf(
-    not core.is_compiled_with_cuda(), "core is not compiled with CUDA"
+    not core.is_compiled_with_cuda() or paddle.is_compiled_with_rocm(),
+    "core is not compiled with CUDA",
 )
 class TestFillAnyLikeOpBfloat16(OpTest):
     def setUp(self):
diff --git a/test/legacy_test/test_layer_norm_op.py b/test/legacy_test/test_layer_norm_op.py
@@ -126,6 +126,10 @@ def layer_norm_wrapper(
     )
 
 
+@unittest.skipIf(
+    paddle.is_compiled_with_rocm(),
+    "ROCm doesn't support fp64 LayerNormOpByOp currently",
+)
 class TestLayerNormOpByOpTest(OpTest):
     def setUp(self):
         self.python_api = layer_norm_wrapper
@@ -164,7 +168,7 @@ def initConfig(self):
         self.cinn_rtol = 1e-5
 
         self.max_relative_error = 1e-5
-
+        # ROCm does not have float64 LayerNorm kernel
         self.dtype = "float64"
         self.x_shape = [2, 6, 6, 3]
         self.epsilon = 0.00001
@@ -218,6 +222,7 @@ def initTestCase(self):
 
 @unittest.skipIf(
     not core.is_compiled_with_cuda()
+    or paddle.is_compiled_with_rocm()
     or not core.is_bfloat16_supported(core.CUDAPlace(0)),
     "core is not compiled with CUDA or not support the bfloat16",
 )
@@ -306,6 +311,10 @@ def initTestCase(self):
         }
 
 
+@unittest.skipIf(
+    paddle.is_compiled_with_rocm(),
+    "ROCm doesn't support fp64 LayerNormOpByOp currently",
+)
 class TestLayerNormOpByOpTestFP64_case2(TestLayerNormOpByOpTest):
     def initConfig(self):
         self.rev_comp_atol = 1e-6
@@ -328,6 +337,10 @@ def initConfig(self):
         self.has_bias = False
 
 
+@unittest.skipIf(
+    paddle.is_compiled_with_rocm(),
+    "ROCm doesn't support bf16 LayerNormOpByOp currently",
+)
 class TestLayerNormBF16OpByOpTest_case2(TestLayerNormBF16OpByOpTest):
     def initConfig(self):
         self.ori_atol = 1e-2
@@ -343,6 +356,10 @@ def initConfig(self):
         self.has_bias = False
 
 
+@unittest.skipIf(
+    paddle.is_compiled_with_rocm(),
+    "ROCm doesn't support fp64 LayerNormOpByOp currently",
+)
 class TestLayerNormOpByOpTestFP64_case3(TestLayerNormOpByOpTest):
     def initConfig(self):
         self.rev_comp_atol = 1e-7
@@ -365,6 +382,10 @@ def initConfig(self):
         self.has_bias = False
 
 
+@unittest.skipIf(
+    paddle.is_compiled_with_rocm(),
+    "ROCm doesn't support bf16 LayerNormOpByOp currently",
+)
 class TestLayerNormBF16OpByOpTest_case3(TestLayerNormBF16OpByOpTest):
     def initConfig(self):
         self.ori_atol = 1e-2
@@ -380,6 +401,10 @@ def initConfig(self):
         self.has_bias = False
 
 
+@unittest.skipIf(
+    paddle.is_compiled_with_rocm(),
+    "ROCm doesn't support fp64 LayerNormOpByOp currently",
+)
 class TestLayerNormOpByOpTestFP64_case4(TestLayerNormOpByOpTest):
     def initConfig(self):
         self.rev_comp_atol = 1e-6
@@ -801,6 +826,10 @@ def assert_equal(x, y):
         assert_equal(b_g_np_1, b_g_np_2)
 
 
+@unittest.skipIf(
+    not core.is_compiled_with_cuda() or paddle.is_compiled_with_rocm(),
+    "BF16 is only supported on CUDA.",
+)
 class TestBF16ScaleBiasLayerNorm(unittest.TestCase):
     def check_main(self, x_np, weight_np, bias_np, dtype):
         paddle.disable_static()
@@ -934,7 +963,7 @@ def check_with_dtype(self, dtype):
         )
 
     def test_main(self):
-        if not paddle.is_compiled_with_cuda():
+        if not paddle.is_compiled_with_cuda() or paddle.is_compiled_with_rocm():
             return
         self.check_with_dtype(dtype="float32")
         self.check_with_dtype(dtype="bfloat16")
diff --git a/test/legacy_test/test_matmul_v2_op.py b/test/legacy_test/test_matmul_v2_op.py
@@ -405,6 +405,7 @@ def test_check_grad(self):
 def create_test_bf16_class(parent, atol=0.01):
     @unittest.skipIf(
         not core.is_compiled_with_cuda()
+        or paddle.is_compiled_with_rocm()
         or not core.is_bfloat16_supported(core.CUDAPlace(0)),
         "core is not compiled with CUDA and not support the bfloat16",
     )
diff --git a/test/legacy_test/test_reduce_op.py b/test/legacy_test/test_reduce_op.py
@@ -198,7 +198,8 @@ def test_check_grad(self):
 
 def create_test_bf16_class(parent):
     @unittest.skipIf(
-        not core.is_compiled_with_cuda(), "core is not compiled with CUDA"
+        not core.is_compiled_with_cuda() or paddle.is_compiled_with_rocm(),
+        "core is not compiled with CUDA",
     )
     class TestSumOpBf16(parent):
         def setUp(self):
@@ -349,6 +350,7 @@ def init_dtype(self):
 
 @unittest.skipIf(
     not core.is_compiled_with_cuda()
+    or paddle.is_compiled_with_rocm()
     or not core.is_bfloat16_supported(core.CUDAPlace(0)),
     "core is not compiled with CUDA or not support the bfloat16",
 )
@@ -449,6 +451,9 @@ def test_check_output(self):
     reason="reduce_min is discontinuous non-derivable function,"
     " its gradient check is not supported by unittest framework."
 )
+@unittest.skipIf(
+    paddle.is_compiled_with_rocm(), "ROCm doesn't have FP16 reduce_min kernel"
+)
 class TestMinFP16Op(OpTest):
     """Remove Min with subgradient from gradient check to confirm the success of CI."""
 
@@ -479,6 +484,7 @@ def test_check_output(self):
 
 @unittest.skipIf(
     not core.is_compiled_with_cuda()
+    or paddle.is_compiled_with_rocm()
     or not core.is_bfloat16_supported(core.CUDAPlace(0)),
     "core is not compiled with CUDA or not support the bfloat16",
 )
@@ -541,6 +547,7 @@ def test_check_grad(self):
 
 @unittest.skipIf(
     not core.is_compiled_with_cuda()
+    or paddle.is_compiled_with_rocm()
     or not core.is_bfloat16_supported(core.CUDAPlace(0)),
     "core is not compiled with CUDA or not support the bfloat16",
 )
@@ -648,6 +655,7 @@ def test_check_grad(self):
 
 @unittest.skipIf(
     not core.is_compiled_with_cuda()
+    or paddle.is_compiled_with_rocm()
     or not core.is_bfloat16_supported(core.CUDAPlace(0)),
     "core is not compiled with CUDA or not support the bfloat16",
 )
@@ -721,6 +729,7 @@ def test_check_grad(self):
 
 @unittest.skipIf(
     not core.is_compiled_with_cuda()
+    or paddle.is_compiled_with_rocm()
     or not core.is_bfloat16_supported(core.CUDAPlace(0)),
     "core is not compiled with CUDA or not support the bfloat16",
 )
diff --git a/test/legacy_test/test_reshape_op.py b/test/legacy_test/test_reshape_op.py
@@ -86,6 +86,10 @@ def init_data(self):
         self.infered_shape = ()
 
 
+@unittest.skipIf(
+    not paddle.is_compiled_with_cuda() or paddle.is_compiled_with_rocm(),
+    "BFP16 test runs only on CUDA",
+)
 class TestReshapeBF16Op(OpTest):
     def setUp(self):
         self.init_data()
diff --git a/test/legacy_test/test_scale_op.py b/test/legacy_test/test_scale_op.py
@@ -155,7 +155,8 @@ def test_check_grad(self):
 
 
 @unittest.skipIf(
-    not core.is_compiled_with_rocm(), "core is not compiled with CUDA"
+    not paddle.is_compiled_with_cuda() or paddle.is_compiled_with_rocm(),
+    "BFP16 test runs only on CUDA",
 )
 class TestScaleBF16Op(OpTest):
     def setUp(self):
diff --git a/test/legacy_test/test_static_model_parallel_fused_multi_transformer.py b/test/legacy_test/test_static_model_parallel_fused_multi_transformer.py
@@ -34,7 +34,10 @@ def _setup_config(self):
     def test_dist_static_model_parallel_fused_multi_transformer(self):
         from paddle import fluid
 
-        if fluid.core.is_compiled_with_cuda():
+        if (
+            fluid.core.is_compiled_with_cuda()
+            and not paddle.is_compiled_with_rocm()
+        ):
             self.check_with_place(
                 "static_model_parallel_fused_multi_transformer.py",
                 delta=1e-5,

Original file line number	Diff line number	Diff line change
`@@ -72,7 +72,8 @@ def test_backward(self):`
`72`	`72`
`73`	`73`
`74`	`74`	`@unittest.skipIf(`
`75`		`- not paddle.is_compiled_with_cuda(), "BFP16 test runs only on GPU"`
	`75`	`+ not paddle.is_compiled_with_cuda() or paddle.is_compiled_with_rocm(),`
	`76`	`+ "BFP16 test runs only on CUDA",`
`76`	`77`	`)`
`77`	`78`	`class TestAssignBFP16Op(eager_op_test.OpTest):`
`78`	`79`	`def setUp(self):`
Original file line number	Diff line number	Diff line change
`@@ -268,6 +268,10 @@ def test_check_grad(self):`
`268`	`268`	`)`
`269`	`269`
`270`	`270`
	`271`	`+@unittest.skipIf(`
	`272`	`+ not paddle.is_compiled_with_cuda() or paddle.is_compiled_with_rocm(),`
	`273`	`+ "BFP16 test runs only on CUDA",`
	`274`	`+)`
`271`	`275`	`class TestElementwisePowBF16Op(OpTest):`
`272`	`276`	`def setUp(self):`
`273`	`277`	`self.op_type = "elementwise_pow"`
Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,8 @@ def if_enable_cinn(self):`
`64`	`64`
`65`	`65`
`66`	`66`	`@unittest.skipIf(`
`67`		`- not core.is_compiled_with_cuda(), "core is not compiled with CUDA"`
	`67`	`+ not core.is_compiled_with_cuda() or paddle.is_compiled_with_rocm(),`
	`68`	`+ "core is not compiled with CUDA",`
`68`	`69`	`)`
`69`	`70`	`class TestFillAnyLikeOpBfloat16(OpTest):`
`70`	`71`	`def setUp(self):`
Original file line number	Diff line number	Diff line change
`@@ -405,6 +405,7 @@ def test_check_grad(self):`
`405`	`405`	`def create_test_bf16_class(parent, atol=0.01):`
`406`	`406`	`@unittest.skipIf(`
`407`	`407`	`not core.is_compiled_with_cuda()`
	`408`	`+ or paddle.is_compiled_with_rocm()`
`408`	`409`	`or not core.is_bfloat16_supported(core.CUDAPlace(0)),`
`409`	`410`	`"core is not compiled with CUDA and not support the bfloat16",`
`410`	`411`	`)`
Original file line number	Diff line number	Diff line change
`@@ -155,7 +155,8 @@ def test_check_grad(self):`
`155`	`155`
`156`	`156`
`157`	`157`	`@unittest.skipIf(`
`158`		`- not core.is_compiled_with_rocm(), "core is not compiled with CUDA"`
	`158`	`+ not paddle.is_compiled_with_cuda() or paddle.is_compiled_with_rocm(),`
	`159`	`+ "BFP16 test runs only on CUDA",`
`159`	`160`	`)`
`160`	`161`	`class TestScaleBF16Op(OpTest):`
`161`	`162`	`def setUp(self):`