[AMP OP&Test] add bf16 fp16 test case for interpolate (#51160)

paddle/phi/kernels/cpu/interpolate_grad_kernel.cc

@@ -110,7 +110,6 @@ static void BilinearInterpolationGrad(const DenseTensor& output_grad,
         for (int j = 0; j < c; j++) {  // loop for channels
           // bilinear interpolation grad
           if (data_layout == DataLayout::kNCHW) {
-            // const T grad = output_grad_t(i, j, k, l);
             const MT grad = static_cast<MT>(output_grad_t(i, j, k, l));
             input_grad_t(i, j, y_n, x_w) += static_cast<T>(grad * d_s * d_e);
             input_grad_t(i, j, y_s, x_w) += static_cast<T>(grad * d_n * d_e);

python/paddle/fluid/tests/unittests/test_bicubic_interp_v2_op.py

@@ -15,14 +15,81 @@
 import unittest
 
 import numpy as np
-from eager_op_test import OpTest
+from eager_op_test import OpTest, convert_float_to_uint16
 
 import paddle
 from paddle import fluid
-from paddle.fluid import Program, program_guard
+from paddle.fluid import Program, core, program_guard
 from paddle.nn.functional import interpolate
 
 
+def create_test_case0(self):
+    self.interp_method = 'bicubic'
+    self.input_shape = [2, 3, 5, 5]
+    self.out_h = 2
+    self.out_w = 2
+    self.scale = []
+    self.out_size = np.array([3, 3]).astype("int32")
+    self.align_corners = True
+
+
+def create_test_case1(self):
+    self.interp_method = 'bicubic'
+    self.input_shape = [4, 1, 7, 8]
+    self.out_h = 1
+    self.out_w = 1
+    self.scale = []
+    self.align_corners = True
+
+
+def create_test_case2(self):
+    self.interp_method = 'bicubic'
+    self.input_shape = [3, 3, 9, 6]
+    self.out_h = 10
+    self.out_w = 8
+    self.scale = []
+    self.align_corners = True
+
+
+def create_test_case3(self):
+    self.interp_method = 'bicubic'
+    self.input_shape = [1, 1, 32, 64]
+    self.out_h = 64
+    self.out_w = 32
+    self.scale = []
+    self.align_corners = False
+
+
+def create_test_case4(self):
+    self.interp_method = 'bicubic'
+    self.input_shape = [4, 1, 7, 8]
+    self.out_h = 1
+    self.out_w = 1
+    self.scale = []
+    self.out_size = np.array([2, 2]).astype("int32")
+    self.align_corners = True
+
+
+def create_test_case5(self):
+    self.interp_method = 'bicubic'
+    self.input_shape = [3, 3, 9, 6]
+    self.out_h = 11
+    self.out_w = 11
+    self.scale = []
+    self.out_size = np.array([6, 4]).astype("int32")
+    self.align_corners = False
+
+
+def create_test_case6(self):
+    self.interp_method = 'bicubic'
+    self.input_shape = [1, 1, 32, 64]
+    self.out_h = 64
+    self.out_w = 32
+    self.scale = 0
+    self.out_size = np.array([64, 32]).astype("int32")
+    self.align_corners = False
+
+
 def bicubic_interp_test(
     x,
     OutSize=None,
@@ -181,10 +248,12 @@ class TestBicubicInterpOp(OpTest):
         self.out_size = None
         self.actual_shape = None
         self.data_layout = 'NCHW'
+        self.dtype = np.float64
         self.init_test_case()
         self.op_type = "bicubic_interp_v2"
         # NOTE(dev): some AsDispensible input is not used under imperative mode.
-        input_np = np.random.random(self.input_shape).astype("float64")
+        # Skip check_dygraph while found them in Inputs.
+        input_np = np.random.random(self.input_shape).astype(self.dtype)
         scale_h = 0
         scale_w = 0
         if self.data_layout == "NCHW":
@@ -249,76 +318,248 @@ class TestBicubicInterpOp(OpTest):
         self.check_grad(['X'], 'Out', in_place=True)
 
     def init_test_case(self):
-        self.interp_method = 'bicubic'
-        self.input_shape = [2, 3, 5, 5]
-        self.out_h = 2
-        self.out_w = 2
-        self.scale = []
-        self.out_size = np.array([3, 3]).astype("int32")
-        self.align_corners = True
+        create_test_case0(self)
 
 
 class TestBicubicInterpCase1(TestBicubicInterpOp):
     def init_test_case(self):
-        self.interp_method = 'bicubic'
-        self.input_shape = [4, 1, 7, 8]
-        self.out_h = 1
-        self.out_w = 1
-        self.scale = []
-        self.align_corners = True
+        create_test_case1(self)
 
 
 class TestBicubicInterpCase2(TestBicubicInterpOp):
     def init_test_case(self):
-        self.interp_method = 'bicubic'
-        self.input_shape = [3, 3, 9, 6]
-        self.out_h = 10
-        self.out_w = 8
-        self.scale = []
-        self.align_corners = True
+        create_test_case2(self)
 
 
 class TestBicubicInterpCase3(TestBicubicInterpOp):
     def init_test_case(self):
-        self.interp_method = 'bicubic'
-        self.input_shape = [1, 1, 32, 64]
-        self.out_h = 64
-        self.out_w = 32
-        self.scale = []
-        self.align_corners = False
+        create_test_case3(self)
 
 
 class TestBicubicInterpCase4(TestBicubicInterpOp):
     def init_test_case(self):
-        self.interp_method = 'bicubic'
-        self.input_shape = [4, 1, 7, 8]
-        self.out_h = 1
-        self.out_w = 1
-        self.scale = []
-        self.out_size = np.array([2, 2]).astype("int32")
-        self.align_corners = True
+        create_test_case4(self)
 
 
 class TestBicubicInterpCase5(TestBicubicInterpOp):
     def init_test_case(self):
-        self.interp_method = 'bicubic'
-        self.input_shape = [3, 3, 9, 6]
-        self.out_h = 11
-        self.out_w = 11
-        self.scale = []
-        self.out_size = np.array([6, 4]).astype("int32")
-        self.align_corners = False
+        create_test_case5(self)
 
 
 class TestBicubicInterpCase6(TestBicubicInterpOp):
     def init_test_case(self):
-        self.interp_method = 'bicubic'
-        self.input_shape = [1, 1, 32, 64]
-        self.out_h = 64
-        self.out_w = 32
-        self.scale = 0
-        self.out_size = np.array([64, 32]).astype("int32")
-        self.align_corners = False
+        create_test_case6(self)
+
+
+class TestBicubicInterpOpFP16(TestBicubicInterpOp):
+    def test_check_output(self):
+        self.check_output(atol=1e-3)
+
+    def test_check_grad(self):
+        self.check_grad(
+            ['X'],
+            'Out',
+            in_place=True,
+            max_relative_error=1e-2,
+        )
+
+    def init_test_case(self):
+        create_test_case0(self)
+        self.dtype = np.float16
+
+
+class TestBicubicInterpCase1FP16(TestBicubicInterpOpFP16):
+    def init_test_case(self):
+        create_test_case1(self)
+        self.dtype = np.float16
+
+
+# this case will cause accuracy loss （backward:0.008773442)
+# class TestBicubicInterpCase2FP16(TestBicubicInterpOpFP16):
+#     def init_test_case(self):
+#         self.interp_method = 'bicubic'
+#         self.input_shape = [3, 3, 9, 6]
+#         self.out_h = 10
+#         self.out_w = 8
+#         self.scale = []
+#         self.align_corners = True
+
+
+class TestBicubicInterpCase3FP16(TestBicubicInterpOpFP16):
+    def init_test_case(self):
+        create_test_case3(self)
+        self.dtype = np.float16
+
+
+class TestBicubicInterpCase4FP16(TestBicubicInterpOpFP16):
+    def init_test_case(self):
+        create_test_case4(self)
+        self.dtype = np.float16
+
+
+class TestBicubicInterpCase5FP16(TestBicubicInterpOpFP16):
+    def init_test_case(self):
+        create_test_case5(self)
+        self.dtype = np.float16
+
+
+class TestBicubicInterpCase6FP16(TestBicubicInterpOpFP16):
+    def init_test_case(self):
+        create_test_case6(self)
+        self.dtype = np.float16
+
+
+@unittest.skipIf(
+    not core.is_compiled_with_cuda()
+    or not core.is_bfloat16_supported(core.CUDAPlace(0)),
+    "core is not compiled with CUDA or not support the bfloat16",
+)
+class TestBicubicInterpOpBF16(OpTest):
+    def setUp(self):
+        self.python_api = bicubic_interp_test
+        self.out_size = None
+        self.actual_shape = None
+        self.data_layout = 'NCHW'
+        self.init_test_case()
+        self.op_type = "bicubic_interp_v2"
+        # NOTE(dev): some AsDispensible input is not used under imperative mode.
+        # Skip check_dygraph while found them in Inputs.
+        self.check_dygraph = True
+        self.dtype = np.uint16
+        input_np = np.random.random(self.input_shape).astype("float32")
+        scale_h = 0
+        scale_w = 0
+        if self.data_layout == "NCHW":
+            in_h = self.input_shape[2]
+            in_w = self.input_shape[3]
+        else:
+            in_h = self.input_shape[1]
+            in_w = self.input_shape[2]
+
+        if self.scale:
+            if isinstance(self.scale, float) or isinstance(self.scale, int):
+                if self.scale > 0.0:
+                    scale_h = scale_w = float(self.scale)
+            if isinstance(self.scale, list) and len(self.scale) == 1:
+                scale_w = scale_h = self.scale[0]
+            elif isinstance(self.scale, list) and len(self.scale) > 1:
+                scale_w = self.scale[1]
+                scale_h = self.scale[0]
+            out_h = int(in_h * scale_h)
+            out_w = int(in_w * scale_w)
+        else:
+            out_h = self.out_h
+            out_w = self.out_w
+
+        output_np = bicubic_interp_np(
+            input_np,
+            out_h,
+            out_w,
+            scale_h,
+            scale_w,
+            self.out_size,
+            self.actual_shape,
+            self.align_corners,
+            self.data_layout,
+        )
+        self.inputs = {'X': convert_float_to_uint16(input_np)}
+        if self.out_size is not None:
+            self.inputs['OutSize'] = self.out_size
+            self.check_dygraph = False
+        if self.actual_shape is not None:
+            self.inputs['OutSize'] = self.actual_shape
+            self.check_dygraph = False
+
+        self.attrs = {
+            'out_h': self.out_h,
+            'out_w': self.out_w,
+            'interp_method': self.interp_method,
+            'align_corners': self.align_corners,
+            'data_layout': self.data_layout,
+        }
+        if self.scale:
+            if isinstance(self.scale, float) or isinstance(self.scale, int):
+                if self.scale > 0.0:
+                    self.scale = [self.scale]
+            if isinstance(self.scale, list) and len(self.scale) == 1:
+                self.scale = [self.scale[0], self.scale[0]]
+            self.attrs['scale'] = self.scale
+        self.outputs = {'Out': convert_float_to_uint16(output_np)}
+
+    def test_check_output(self):
+        self.check_output(check_dygraph=self.check_dygraph, atol=1e-2)
+
+    def test_check_grad(self):
+        self.check_grad(
+            ['X'],
+            'Out',
+            in_place=True,
+            check_dygraph=self.check_dygraph,
+            max_relative_error=1e-2,
+        )
+
+    def init_test_case(self):
+        create_test_case0(self)
+
+
+@unittest.skipIf(
+    not core.is_compiled_with_cuda()
+    or not core.is_bfloat16_supported(core.CUDAPlace(0)),
+    "core is not compiled with CUDA or not support the bfloat16",
+)
+class TestBicubicInterpCase1BF16(TestBicubicInterpOpBF16):
+    def init_test_case(self):
+        create_test_case1(self)
+
+
+@unittest.skipIf(
+    not core.is_compiled_with_cuda()
+    or not core.is_bfloat16_supported(core.CUDAPlace(0)),
+    "core is not compiled with CUDA or not support the bfloat16",
+)
+class TestBicubicInterpCase2BF16(TestBicubicInterpOpBF16):
+    def init_test_case(self):
+        create_test_case2(self)
+
+
+@unittest.skipIf(
+    not core.is_compiled_with_cuda()
+    or not core.is_bfloat16_supported(core.CUDAPlace(0)),
+    "core is not compiled with CUDA or not support the bfloat16",
+)
+class TestBicubicInterpCase3BF16(TestBicubicInterpOpBF16):
+    def init_test_case(self):
+        create_test_case3(self)
+
+
+@unittest.skipIf(
+    not core.is_compiled_with_cuda()
+    or not core.is_bfloat16_supported(core.CUDAPlace(0)),
+    "core is not compiled with CUDA or not support the bfloat16",
+)
+class TestBicubicInterpCase4BF16(TestBicubicInterpOpBF16):
+    def init_test_case(self):
+        create_test_case4(self)
+
+
+@unittest.skipIf(
+    not core.is_compiled_with_cuda()
+    or not core.is_bfloat16_supported(core.CUDAPlace(0)),
+    "core is not compiled with CUDA or not support the bfloat16",
+)
+class TestBicubicInterpCase5BF16(TestBicubicInterpOpBF16):
+    def init_test_case(self):
+        create_test_case5(self)
+
+
+@unittest.skipIf(
+    not core.is_compiled_with_cuda()
+    or not core.is_bfloat16_supported(core.CUDAPlace(0)),
+    "core is not compiled with CUDA or not support the bfloat16",
+)
+class TestBicubicInterpCase6BF16(TestBicubicInterpOpBF16):
+    def init_test_case(self):
+        create_test_case6(self)
 
 
 class TestBicubicInterpSame(TestBicubicInterpOp):

python/paddle/fluid/tests/unittests/test_bilinear_interp_v2_op.py

@@ -15,7 +15,7 @@
 import unittest
 
 import numpy as np
-from eager_op_test import OpTest
+from eager_op_test import OpTest, convert_float_to_uint16
 
 import paddle
 from paddle import fluid
@@ -23,6 +23,90 @@ from paddle.fluid import core
 from paddle.nn.functional import interpolate
 
 
+def create_test_case0(self):
+    self.interp_method = 'bilinear'
+    self.input_shape = [2, 3, 5, 5]
+    self.out_h = 2
+    self.out_w = 2
+    self.scale = []
+    self.out_size = np.array([3, 3]).astype("int32")
+    self.align_corners = True
+    self.align_mode = 1
+
+
+def create_test_case1(self):
+    self.interp_method = 'bilinear'
+    self.input_shape = [4, 1, 7, 8]
+    self.out_h = 1
+    self.out_w = 1
+    self.scale = []
+    self.align_corners = True
+    self.align_mode = 1
+
+
+def create_test_case2(self):
+    self.interp_method = 'bilinear'
+    self.input_shape = [3, 3, 9, 6]
+    self.out_h = 12
+    self.out_w = 12
+    self.scale = []
+    self.align_corners = True
+    self.align_mode = 1
+
+
+def create_test_case3(self):
+    self.interp_method = 'bilinear'
+    self.input_shape = [1, 1, 32, 64]
+    self.out_h = 64
+    self.out_w = 32
+    self.scale = []
+    self.align_corners = True
+    self.align_mode = 1
+
+
+def create_test_case4(self):
+    self.interp_method = 'bilinear'
+    self.input_shape = [4, 1, 7, 8]
+    self.out_h = 1
+    self.out_w = 1
+    self.scale = []
+    self.out_size = np.array([2, 2]).astype("int32")
+    self.align_corners = True
+    self.align_mode = 1
+
+
+def create_test_case5(self):
+    self.interp_method = 'bilinear'
+    self.input_shape = [3, 3, 9, 6]
+    self.out_h = 12
+    self.out_w = 12
+    self.scale = []
+    self.out_size = np.array([11, 11]).astype("int32")
+    self.align_corners = True
+    self.align_mode = 1
+
+
+def create_test_case6(self):
+    self.interp_method = 'bilinear'
+    self.input_shape = [1, 1, 32, 64]
+    self.out_h = 64
+    self.out_w = 32
+    self.scale = []
+    self.out_size = np.array([65, 33]).astype("int32")
+    self.align_corners = True
+    self.align_mode = 1
+
+
+def create_test_case7(self):
+    self.interp_method = 'bilinear'
+    self.input_shape = [1, 1, 32, 64]
+    self.out_h = 64
+    self.out_w = 32
+    self.scale = [2.0, 0.5]
+    self.align_corners = False
+    self.align_mode = 1
+
+
 def bilinear_interp_test(
     x,
     OutSize=None,
@@ -156,9 +240,10 @@ class TestBilinearInterpOp(OpTest):
         self.out_size = None
         self.actual_shape = None
         self.data_layout = 'NCHW'
+        self.dtype = np.float64
         self.init_test_case()
         self.op_type = "bilinear_interp_v2"
-        input_np = np.random.random(self.input_shape).astype("float64")
+        input_np = np.random.random(self.input_shape).astype(self.dtype)
 
         if self.data_layout == "NCHW":
             in_h = self.input_shape[2]
@@ -225,94 +310,42 @@ class TestBilinearInterpOp(OpTest):
         self.check_grad(['X'], 'Out', in_place=True)
 
     def init_test_case(self):
-        self.interp_method = 'bilinear'
-        self.input_shape = [2, 3, 5, 5]
-        self.out_h = 2
-        self.out_w = 2
-        self.scale = []
-        self.out_size = np.array([3, 3]).astype("int32")
-        self.align_corners = True
-        self.align_mode = 1
+        create_test_case0(self)
 
 
 class TestBilinearInterpCase1(TestBilinearInterpOp):
     def init_test_case(self):
-        self.interp_method = 'bilinear'
-        self.input_shape = [4, 1, 7, 8]
-        self.out_h = 1
-        self.out_w = 1
-        self.scale = []
-        self.align_corners = True
-        self.align_mode = 1
+        create_test_case1(self)
 
 
 class TestBilinearInterpCase2(TestBilinearInterpOp):
     def init_test_case(self):
-        self.interp_method = 'bilinear'
-        self.input_shape = [3, 3, 9, 6]
-        self.out_h = 12
-        self.out_w = 12
-        self.scale = []
-        self.align_corners = True
-        self.align_mode = 1
+        create_test_case2(self)
 
 
 class TestBilinearInterpCase3(TestBilinearInterpOp):
     def init_test_case(self):
-        self.interp_method = 'bilinear'
-        self.input_shape = [1, 1, 32, 64]
-        self.out_h = 64
-        self.out_w = 32
-        self.scale = []
-        self.align_corners = True
-        self.align_mode = 1
+        create_test_case3(self)
 
 
 class TestBilinearInterpCase4(TestBilinearInterpOp):
     def init_test_case(self):
-        self.interp_method = 'bilinear'
-        self.input_shape = [4, 1, 7, 8]
-        self.out_h = 1
-        self.out_w = 1
-        self.scale = []
-        self.out_size = np.array([2, 2]).astype("int32")
-        self.align_corners = True
-        self.align_mode = 1
+        create_test_case4(self)
 
 
 class TestBilinearInterpCase5(TestBilinearInterpOp):
     def init_test_case(self):
-        self.interp_method = 'bilinear'
-        self.input_shape = [3, 3, 9, 6]
-        self.out_h = 12
-        self.out_w = 12
-        self.scale = []
-        self.out_size = np.array([11, 11]).astype("int32")
-        self.align_corners = True
-        self.align_mode = 1
+        create_test_case5(self)
 
 
 class TestBilinearInterpCase6(TestBilinearInterpOp):
     def init_test_case(self):
-        self.interp_method = 'bilinear'
-        self.input_shape = [1, 1, 32, 64]
-        self.out_h = 64
-        self.out_w = 32
-        self.scale = []
-        self.out_size = np.array([65, 33]).astype("int32")
-        self.align_corners = True
-        self.align_mode = 1
+        create_test_case6(self)
 
 
 class TestBilinearInterpCase7(TestBilinearInterpOp):
     def init_test_case(self):
-        self.interp_method = 'bilinear'
-        self.input_shape = [1, 1, 32, 64]
-        self.out_h = 64
-        self.out_w = 32
-        self.scale = [2.0, 0.5]
-        self.align_corners = False
-        self.align_mode = 1
+        create_test_case7(self)
 
 
 class TestBilinearInterpSame(TestBilinearInterpOp):
@@ -351,6 +384,214 @@ class TestBilinearInterpDataLayout(TestBilinearInterpOp):
         self.data_layout = "NHWC"
 
 
+class TestBilinearInterpOpFP16(TestBilinearInterpOp):
+    def test_check_output(self):
+        self.check_output(atol=1e-3)
+
+    def test_check_grad(self):
+        self.check_grad(['X'], 'Out', in_place=True, max_relative_error=1e-2)
+
+    def init_test_case(self):
+        create_test_case0(self)
+        self.dtype = np.float16
+
+
+class TestBilinearInterpCase1FP16(TestBilinearInterpOpFP16):
+    def init_test_case(self):
+        create_test_case1(self)
+        self.dtype = np.float16
+
+
+class TestBilinearInterpCase2FP16(TestBilinearInterpOpFP16):
+    def init_test_case(self):
+        create_test_case2(self)
+        self.dtype = np.float16
+
+
+class TestBilinearInterpCase3FP16(TestBilinearInterpOpFP16):
+    def init_test_case(self):
+        create_test_case3(self)
+        self.dtype = np.float16
+
+
+class TestBilinearInterpCase4FP16(TestBilinearInterpOpFP16):
+    def init_test_case(self):
+        create_test_case4(self)
+        self.dtype = np.float16
+
+
+class TestBilinearInterpCase5FP16(TestBilinearInterpOpFP16):
+    def init_test_case(self):
+        create_test_case5(self)
+        self.dtype = np.float16
+
+
+class TestBilinearInterpCase6FP16(TestBilinearInterpOpFP16):
+    def init_test_case(self):
+        create_test_case6(self)
+        self.dtype = np.float16
+
+
+class TestBilinearInterpCase7FP16(TestBilinearInterpOpFP16):
+    def init_test_case(self):
+        create_test_case7(self)
+        self.dtype = np.float16
+
+
+@unittest.skipIf(
+    not core.is_compiled_with_cuda()
+    or not core.is_bfloat16_supported(core.CUDAPlace(0)),
+    "core is not compiled with CUDA or not support the bfloat16",
+)
+class TestBilinearInterpOpBF16(OpTest):
+    def setUp(self):
+        self.python_api = bilinear_interp_test
+        self.out_size = None
+        self.actual_shape = None
+        self.data_layout = 'NCHW'
+        self.init_test_case()
+        self.op_type = "bilinear_interp_v2"
+        self.dtype = np.uint16
+        input_np = np.random.random(self.input_shape).astype("float32")
+
+        if self.data_layout == "NCHW":
+            in_h = self.input_shape[2]
+            in_w = self.input_shape[3]
+        else:
+            in_h = self.input_shape[1]
+            in_w = self.input_shape[2]
+        scale_h = 0
+        scale_w = 0
+        if self.scale:
+            if isinstance(self.scale, float) or isinstance(self.scale, int):
+                if self.scale > 0.0:
+                    scale_h = scale_w = float(self.scale)
+            if isinstance(self.scale, list) and len(self.scale) == 1:
+                scale_w = scale_h = self.scale[0]
+            elif isinstance(self.scale, list) and len(self.scale) > 1:
+                scale_w = self.scale[1]
+                scale_h = self.scale[0]
+            out_h = int(in_h * scale_h)
+            out_w = int(in_w * scale_w)
+        else:
+            out_h = self.out_h
+            out_w = self.out_w
+
+        output_np = bilinear_interp_np(
+            input_np,
+            out_h,
+            out_w,
+            0,
+            0,
+            self.out_size,
+            self.actual_shape,
+            self.align_corners,
+            self.align_mode,
+            self.data_layout,
+        )
+        self.inputs = {'X': convert_float_to_uint16(input_np)}
+        if self.out_size is not None:
+            self.inputs['OutSize'] = self.out_size
+        if self.actual_shape is not None:
+            self.inputs['OutSize'] = self.actual_shape
+
+        self.attrs = {
+            'out_h': self.out_h,
+            'out_w': self.out_w,
+            'interp_method': self.interp_method,
+            'align_corners': self.align_corners,
+            'align_mode': self.align_mode,
+            'data_layout': self.data_layout,
+        }
+        if self.scale:
+            if isinstance(self.scale, float) or isinstance(self.scale, int):
+                if self.scale > 0.0:
+                    self.scale = [self.scale]
+            if isinstance(self.scale, list) and len(self.scale) == 1:
+                self.scale = [self.scale[0], self.scale[0]]
+            self.attrs['scale'] = self.scale
+        self.outputs = {'Out': convert_float_to_uint16(output_np)}
+
+    def test_check_output(self):
+        self.check_output(atol=1e-2)
+
+    def test_check_grad(self):
+        self.check_grad(['X'], 'Out', in_place=True, max_relative_error=1e-2)
+
+    def init_test_case(self):
+        create_test_case0(self)
+
+
+@unittest.skipIf(
+    not core.is_compiled_with_cuda()
+    or not core.is_bfloat16_supported(core.CUDAPlace(0)),
+    "core is not compiled with CUDA or not support the bfloat16",
+)
+class TestBilinearInterpCase1BF16(TestBilinearInterpOpBF16):
+    def init_test_case(self):
+        create_test_case1(self)
+
+
+@unittest.skipIf(
+    not core.is_compiled_with_cuda()
+    or not core.is_bfloat16_supported(core.CUDAPlace(0)),
+    "core is not compiled with CUDA or not support the bfloat16",
+)
+class TestBilinearInterpCase2BF16(TestBilinearInterpOpBF16):
+    def init_test_case(self):
+        create_test_case2(self)
+
+
+@unittest.skipIf(
+    not core.is_compiled_with_cuda()
+    or not core.is_bfloat16_supported(core.CUDAPlace(0)),
+    "core is not compiled with CUDA or not support the bfloat16",
+)
+class TestBilinearInterpCase3BF16(TestBilinearInterpOpBF16):
+    def init_test_case(self):
+        create_test_case3(self)
+
+
+@unittest.skipIf(
+    not core.is_compiled_with_cuda()
+    or not core.is_bfloat16_supported(core.CUDAPlace(0)),
+    "core is not compiled with CUDA or not support the bfloat16",
+)
+class TestBilinearInterpCase4BF16(TestBilinearInterpOpBF16):
+    def init_test_case(self):
+        create_test_case4(self)
+
+
+@unittest.skipIf(
+    not core.is_compiled_with_cuda()
+    or not core.is_bfloat16_supported(core.CUDAPlace(0)),
+    "core is not compiled with CUDA or not support the bfloat16",
+)
+class TestBilinearInterpCase5BF16(TestBilinearInterpOpBF16):
+    def init_test_case(self):
+        create_test_case5(self)
+
+
+@unittest.skipIf(
+    not core.is_compiled_with_cuda()
+    or not core.is_bfloat16_supported(core.CUDAPlace(0)),
+    "core is not compiled with CUDA or not support the bfloat16",
+)
+class TestBilinearInterpCase6BF16(TestBilinearInterpOpBF16):
+    def init_test_case(self):
+        create_test_case6(self)
+
+
+@unittest.skipIf(
+    not core.is_compiled_with_cuda()
+    or not core.is_bfloat16_supported(core.CUDAPlace(0)),
+    "core is not compiled with CUDA or not support the bfloat16",
+)
+class TestBilinearInterpCase7BF16(TestBilinearInterpOpBF16):
+    def init_test_case(self):
+        create_test_case7(self)
+
+
 class TestBilinearInterpOpUint8(OpTest):
     def setUp(self):
         self.python_api = bilinear_interp_test

python/paddle/fluid/tests/unittests/test_linear_interp_v2_op.py

@@ -16,7 +16,7 @@ import platform
 import unittest
 
 import numpy as np
-from eager_op_test import OpTest, paddle_static_guard
+from eager_op_test import OpTest, convert_float_to_uint16, paddle_static_guard
 
 import paddle
 from paddle import fluid
@@ -24,6 +24,20 @@ from paddle.fluid import Program, core, program_guard
 from paddle.nn.functional import interpolate
 
 
+def create_test_case0(self):
+    self.interp_method = 'linear'
+    self.input_shape = [1, 3, 100]
+    self.out_w = 50
+    self.scale = 0.5
+    self.out_size = np.array(
+        [
+            50,
+        ]
+    ).astype("int32")
+    self.align_corners = False
+    self.align_mode = 1
+
+
 def linear_interp_test(
     x,
     OutSize=None,
@@ -127,9 +141,10 @@ class TestLinearInterpOp(OpTest):
         self.out_size = None
         self.actual_shape = None
         self.data_layout = 'NCHW'
+        self.dtype = np.float64
         self.init_test_case()
         self.op_type = "linear_interp_v2"
-        input_np = np.random.random(self.input_shape).astype("float64")
+        input_np = np.random.random(self.input_shape).astype(self.dtype)
 
         scale_w = 0
         if self.data_layout == "NCHW":
@@ -185,17 +200,7 @@ class TestLinearInterpOp(OpTest):
         self.check_grad(['X'], 'Out', in_place=True)
 
     def init_test_case(self):
-        self.interp_method = 'linear'
-        self.input_shape = [1, 3, 100]
-        self.out_w = 50
-        self.scale = 0.5
-        self.out_size = np.array(
-            [
-                50,
-            ]
-        ).astype("int32")
-        self.align_corners = False
-        self.align_mode = 1
+        create_test_case0(self)
 
 
 class TestLinearInterpOpDataLayout(TestLinearInterpOp):
@@ -333,6 +338,97 @@ class TestLinearInterpOpAPI2_0(unittest.TestCase):
             np.testing.assert_allclose(interp.numpy(), expect, rtol=1e-05)
 
 
+class TestLinearInterpOpFP16(TestLinearInterpOp):
+    def test_check_output(self):
+        self.check_output(atol=1e-3)
+
+    def test_check_grad(self):
+        self.check_grad(
+            ['X'],
+            'Out',
+            in_place=True,
+            max_relative_error=1e-2,
+        )
+
+    def init_test_case(self):
+        create_test_case0(self)
+        self.dtype = np.float16
+
+
+@unittest.skipIf(
+    not core.is_compiled_with_cuda()
+    or not core.is_bfloat16_supported(core.CUDAPlace(0)),
+    "core is not compiled with CUDA or not support the bfloat16",
+)
+class TestLinearInterpOpBF16(OpTest):
+    def setUp(self):
+        self.python_api = linear_interp_test
+        self.out_size = None
+        self.actual_shape = None
+        self.data_layout = 'NCHW'
+        self.init_test_case()
+        self.op_type = "linear_interp_v2"
+        self.dtype = np.uint16
+        input_np = np.random.random(self.input_shape).astype("float32")
+
+        scale_w = 0
+        if self.data_layout == "NCHW":
+            in_w = self.input_shape[2]
+        else:
+            in_w = self.input_shape[1]
+
+        if self.scale > 0:
+            if isinstance(self.scale, float) or isinstance(self.scale, int):
+                self.scale = float(self.scale)
+            if isinstance(self.scale, list):
+                self.scale = float(self.scale[0])
+            out_w = int(in_w * self.scale)
+        else:
+            out_w = self.out_w
+
+        output_np = linear_interp_np(
+            input_np,
+            out_w,
+            self.scale,
+            self.out_size,
+            self.actual_shape,
+            self.align_corners,
+            self.align_mode,
+            self.data_layout,
+        )
+        self.inputs = {'X': convert_float_to_uint16(input_np)}
+        if self.out_size is not None:
+            self.inputs['OutSize'] = self.out_size
+        if self.actual_shape is not None:
+            self.inputs['OutSize'] = self.actual_shape
+
+        self.attrs = {
+            'out_w': self.out_w,
+            'interp_method': self.interp_method,
+            'align_corners': self.align_corners,
+            'align_mode': self.align_mode,
+            'data_layout': self.data_layout,
+        }
+        if self.scale > 0:
+            if isinstance(self.scale, float) or isinstance(self.scale, int):
+                self.scale = [float(self.scale)]
+            self.attrs['scale'] = self.scale
+        self.outputs = {'Out': convert_float_to_uint16(output_np)}
+
+    def test_check_output(self):
+        place = core.CUDAPlace(0)
+        self.check_output_with_place(place, atol=1e-2)
+
+    def test_check_grad(self):
+        place = core.CUDAPlace(0)
+        self.check_grad_with_place(
+            place, ['X'], 'Out', in_place=True, max_relative_error=1e-2
+        )
+
+    def init_test_case(self):
+        create_test_case0(self)
+
+
 class TestResizeLinearOpUint8(OpTest):
     def setUp(self):
         self.out_size = None

python/paddle/fluid/tests/unittests/test_nearest_interp_v2_op.py

@@ -15,7 +15,7 @@
 import unittest
 
 import numpy as np
-from eager_op_test import OpTest
+from eager_op_test import OpTest, convert_float_to_uint16
 
 import paddle
 from paddle import fluid
@@ -25,6 +25,74 @@ from paddle.nn.functional import interpolate
 paddle.enable_static()
 
 
+def create_test_case0(self):
+    self.interp_method = 'nearest'
+    self.input_shape = [2, 3, 4, 5]
+    self.out_h = 2
+    self.out_w = 2
+    self.scale = []
+    self.out_size = np.array([3, 3]).astype("int32")
+    self.align_corners = True
+
+
+def create_test_case1(self):
+    self.interp_method = 'nearest'
+    self.input_shape = [4, 1, 1, 7, 8]
+    self.out_d = 1
+    self.out_h = 1
+    self.out_w = 1
+    self.scale = []
+    self.align_corners = True
+
+
+def create_test_case2(self):
+    self.interp_method = 'nearest'
+    self.input_shape = [3, 3, 9, 6]
+    self.out_h = 12
+    self.out_w = 12
+    self.scale = []
+    self.align_corners = True
+
+
+def create_test_case3(self):
+    self.interp_method = 'nearest'
+    self.input_shape = [1, 1, 32, 64]
+    self.out_h = 64
+    self.out_w = 32
+    self.scale = []
+    self.align_corners = True
+
+
+def create_test_case4(self):
+    self.interp_method = 'nearest'
+    self.input_shape = [4, 1, 7, 8]
+    self.out_h = 1
+    self.out_w = 1
+    self.scale = []
+    self.out_size = np.array([2, 2]).astype("int32")
+    self.align_corners = True
+
+
+def create_test_case5(self):
+    self.interp_method = 'nearest'
+    self.input_shape = [3, 3, 9, 6]
+    self.out_h = 12
+    self.out_w = 12
+    self.scale = []
+    self.out_size = np.array([11, 11]).astype("int32")
+    self.align_corners = True
+
+
+def create_test_case6(self):
+    self.interp_method = 'nearest'
+    self.input_shape = [1, 1, 32, 64]
+    self.out_h = 64
+    self.out_w = 32
+    self.scale = []
+    self.out_size = np.array([65, 129]).astype("int32")
+    self.align_corners = True
+
+
 def nearest_interp_test(
     x,
     OutSize=None,
@@ -208,9 +276,10 @@ class TestNearestInterpOp(OpTest):
         self.out_size = None
         self.actual_shape = None
         self.data_layout = 'NCHW'
+        self.dtype = np.float64
         self.init_test_case()
         self.op_type = "nearest_interp_v2"
-        input_np = np.random.random(self.input_shape).astype("float64")
+        input_np = np.random.random(self.input_shape).astype(self.dtype)
 
         if self.data_layout == "NCHW" and len(self.input_shape) == 4:
             in_d = 1
@@ -320,77 +389,37 @@ class TestNearestInterpOp(OpTest):
         self.check_grad(['X'], 'Out', in_place=True)
 
     def init_test_case(self):
-        self.interp_method = 'nearest'
-        self.input_shape = [2, 3, 4, 5]
-        self.out_h = 2
-        self.out_w = 2
-        self.scale = []
-        self.out_size = np.array([3, 3]).astype("int32")
-        self.align_corners = True
+        create_test_case0(self)
 
 
 class TestNearestNeighborInterpCase1(TestNearestInterpOp):
     def init_test_case(self):
-        self.interp_method = 'nearest'
-        self.input_shape = [4, 1, 1, 7, 8]
-        self.out_d = 1
-        self.out_h = 1
-        self.out_w = 1
-        self.scale = []
-        self.align_corners = True
+        create_test_case1(self)
 
 
 class TestNearestNeighborInterpCase2(TestNearestInterpOp):
     def init_test_case(self):
-        self.interp_method = 'nearest'
-        self.input_shape = [3, 3, 9, 6]
-        self.out_h = 12
-        self.out_w = 12
-        self.scale = []
-        self.align_corners = True
+        create_test_case2(self)
 
 
 class TestNearestNeighborInterpCase3(TestNearestInterpOp):
     def init_test_case(self):
-        self.interp_method = 'nearest'
-        self.input_shape = [1, 1, 32, 64]
-        self.out_h = 64
-        self.out_w = 32
-        self.scale = []
-        self.align_corners = True
+        create_test_case3(self)
 
 
 class TestNearestNeighborInterpCase4(TestNearestInterpOp):
     def init_test_case(self):
-        self.interp_method = 'nearest'
-        self.input_shape = [4, 1, 7, 8]
-        self.out_h = 1
-        self.out_w = 1
-        self.scale = []
-        self.out_size = np.array([2, 2]).astype("int32")
-        self.align_corners = True
+        create_test_case4(self)
 
 
 class TestNearestNeighborInterpCase5(TestNearestInterpOp):
     def init_test_case(self):
-        self.interp_method = 'nearest'
-        self.input_shape = [3, 3, 9, 6]
-        self.out_h = 12
-        self.out_w = 12
-        self.scale = []
-        self.out_size = np.array([11, 11]).astype("int32")
-        self.align_corners = True
+        create_test_case5(self)
 
 
 class TestNearestNeighborInterpCase6(TestNearestInterpOp):
     def init_test_case(self):
-        self.interp_method = 'nearest'
-        self.input_shape = [1, 1, 32, 64]
-        self.out_h = 64
-        self.out_w = 32
-        self.scale = []
-        self.out_size = np.array([65, 129]).astype("int32")
-        self.align_corners = True
+        create_test_case6(self)
 
 
 class TestNearestNeighborInterpSame(TestNearestInterpOp):
@@ -414,6 +443,248 @@ class TestNearestNeighborInterpActualShape(TestNearestInterpOp):
         self.align_corners = True
 
 
+class TestNearestInterpOpFP16(TestNearestInterpOp):
+    def test_check_output(self):
+        self.check_output(check_dygraph=True, atol=1e-3)
+
+    def test_check_grad(self):
+        self.check_grad(
+            ['X'],
+            'Out',
+            in_place=True,
+            check_dygraph=True,
+            max_relative_error=1e-2,
+        )
+
+    def init_test_case(self):
+        create_test_case0(self)
+        self.dtype = np.float16
+
+
+class TestNearestNeighborInterpCase1FP16(TestNearestInterpOpFP16):
+    def init_test_case(self):
+        create_test_case1(self)
+        self.dtype = np.float16
+
+
+class TestNearestNeighborInterpCase2FP16(TestNearestInterpOpFP16):
+    def init_test_case(self):
+        create_test_case2(self)
+        self.dtype = np.float16
+
+
+class TestNearestNeighborInterpCase3FP16(TestNearestInterpOpFP16):
+    def init_test_case(self):
+        create_test_case3(self)
+        self.dtype = np.float16
+
+
+class TestNearestNeighborInterpCase4FP16(TestNearestInterpOpFP16):
+    def init_test_case(self):
+        create_test_case4(self)
+        self.dtype = np.float16
+
+
+class TestNearestNeighborInterpCase5FP16(TestNearestInterpOpFP16):
+    def init_test_case(self):
+        create_test_case5(self)
+        self.dtype = np.float16
+
+
+class TestNearestNeighborInterpCase6FP16(TestNearestInterpOpFP16):
+    def init_test_case(self):
+        create_test_case6(self)
+        self.dtype = np.float16
+
+
+@unittest.skipIf(
+    not core.is_compiled_with_cuda()
+    or not core.is_bfloat16_supported(core.CUDAPlace(0)),
+    "core is not compiled with CUDA or not support the bfloat16",
+)
+class TestNearestInterpOpBF16(OpTest):
+    def setUp(self):
+        self.python_api = nearest_interp_test
+        self.out_size = None
+        self.actual_shape = None
+        self.data_layout = 'NCHW'
+        self.init_test_case()
+        self.op_type = "nearest_interp_v2"
+        self.dtype = np.uint16
+        input_np = np.random.random(self.input_shape).astype("float32")
+
+        if self.data_layout == "NCHW" and len(self.input_shape) == 4:
+            in_d = 1
+            in_h = self.input_shape[2]
+            in_w = self.input_shape[3]
+        else:
+            in_d = 1
+            in_h = self.input_shape[1]
+            in_w = self.input_shape[2]
+
+        if self.data_layout == "NCDHW" and len(self.input_shape) == 5:
+            in_d = self.input_shape[2]
+            in_h = self.input_shape[3]
+            in_w = self.input_shape[4]
+        else:
+            in_d = self.input_shape[1]
+            in_h = self.input_shape[2]
+            in_w = self.input_shape[3]
+        scale_d = 0
+        scale_h = 0
+        scale_w = 0
+        if self.scale:
+            if isinstance(self.scale, float) or isinstance(self.scale, int):
+                if self.scale > 0:
+                    scale_d = scale_h = scale_w = float(self.scale)
+            if isinstance(self.scale, list) and len(self.scale) == 1:
+                scale_d = scale_w = scale_h = self.scale[0]
+            elif isinstance(self.scale, list) and len(self.scale) > 1:
+                if len(self.scale) == 5:
+                    scale_w = self.scale[2]
+                    scale_h = self.scale[1]
+                    scale_d = self.scale[0]
+                else:
+                    scale_w = self.scale[1]
+                    scale_h = self.scale[0]
+
+            out_h = int(in_h * scale_h)
+            out_w = int(in_w * scale_w)
+            out_d = int(in_d * scale_d)
+        else:
+            if len(self.input_shape) == 5:
+                out_d = self.out_d
+            out_h = self.out_h
+            out_w = self.out_w
+
+        if len(self.input_shape) == 4:
+            output_np = nearest_neighbor_interp_np(
+                input_np,
+                out_h,
+                out_w,
+                scale_h,
+                scale_w,
+                self.out_size,
+                self.actual_shape,
+                self.align_corners,
+                self.data_layout,
+            )
+        elif len(self.input_shape) == 5:
+            output_np = nearest_neighbor_interp3d_np(
+                input_np,
+                out_d,
+                out_h,
+                out_w,
+                scale_d,
+                scale_h,
+                scale_w,
+                self.out_size,
+                self.actual_shape,
+                self.align_corners,
+                self.data_layout,
+            )
+        self.inputs = {'X': convert_float_to_uint16(input_np)}
+        if self.out_size is not None:
+            self.inputs['OutSize'] = self.out_size
+        if self.actual_shape is not None:
+            self.inputs['OutSize'] = self.actual_shape
+        if len(self.input_shape) == 5:
+            self.attrs = {
+                'out_d': self.out_d,
+                'out_h': self.out_h,
+                'out_w': self.out_w,
+                'interp_method': self.interp_method,
+                'align_corners': self.align_corners,
+                'data_layout': self.data_layout,
+            }
+        else:
+            self.attrs = {
+                'out_h': self.out_h,
+                'out_w': self.out_w,
+                'interp_method': self.interp_method,
+                'align_corners': self.align_corners,
+                'data_layout': self.data_layout,
+            }
+        if self.scale:
+            if isinstance(self.scale, float) or isinstance(self.scale, int):
+                if self.scale > 0:
+                    self.scale = [self.scale]
+            if isinstance(self.scale, list) and len(self.scale) == 1:
+                self.scale = [self.scale[0], self.scale[0]]
+            self.attrs['scale'] = self.scale
+        self.outputs = {'Out': convert_float_to_uint16(output_np)}
+
+    def test_check_output(self):
+        self.check_output(check_dygraph=True, atol=1e-2)
+
+    def test_check_grad(self):
+        self.check_grad(
+            ['X'],
+            'Out',
+            in_place=True,
+            check_dygraph=True,
+            max_relative_error=1e-2,
+        )
+
+    def init_test_case(self):
+        create_test_case0(self)
+
+
+class TestNearestNeighborInterpCase1BF16(TestNearestInterpOpBF16):
+    def init_test_case(self):
+        create_test_case1(self)
+
+
+@unittest.skipIf(
+    not core.is_compiled_with_cuda()
+    or not core.is_bfloat16_supported(core.CUDAPlace(0)),
+    "core is not compiled with CUDA or not support the bfloat16",
+)
+class TestNearestNeighborInterpCase2BF16(TestNearestInterpOpBF16):
+    def init_test_case(self):
+        create_test_case2(self)
+
+
+@unittest.skipIf(
+    not core.is_compiled_with_cuda()
+    or not core.is_bfloat16_supported(core.CUDAPlace(0)),
+    "core is not compiled with CUDA or not support the bfloat16",
+)
+class TestNearestNeighborInterpCase3BF16(TestNearestInterpOpBF16):
+    def init_test_case(self):
+        create_test_case3(self)
+
+
+@unittest.skipIf(
+    not core.is_compiled_with_cuda()
+    or not core.is_bfloat16_supported(core.CUDAPlace(0)),
+    "core is not compiled with CUDA or not support the bfloat16",
+)
+class TestNearestNeighborInterpCase4BF16(TestNearestInterpOpBF16):
+    def init_test_case(self):
+        create_test_case4(self)
+
+
+@unittest.skipIf(
+    not core.is_compiled_with_cuda()
+    or not core.is_bfloat16_supported(core.CUDAPlace(0)),
+    "core is not compiled with CUDA or not support the bfloat16",
+)
+class TestNearestNeighborInterpCase5BF16(TestNearestInterpOpBF16):
+    def init_test_case(self):
+        create_test_case5(self)
+
+
+@unittest.skipIf(
+    not core.is_compiled_with_cuda()
+    or not core.is_bfloat16_supported(core.CUDAPlace(0)),
+    "core is not compiled with CUDA or not support the bfloat16",
+)
+class TestNearestNeighborInterpCase6BF16(TestNearestInterpOpBF16):
+    def init_test_case(self):
+        create_test_case6(self)
+
+
 class TestNearestNeighborInterpDataLayout(TestNearestInterpOp):
     def init_test_case(self):
         self.interp_method = 'nearest'

python/paddle/fluid/tests/unittests/test_trilinear_interp_v2_op.py

@@ -15,7 +15,7 @@
 import unittest
 
 import numpy as np
-from eager_op_test import OpTest
+from eager_op_test import OpTest, convert_float_to_uint16
 
 import paddle
 from paddle import fluid
@@ -25,6 +25,87 @@ from paddle.nn.functional import interpolate
 np.random.seed(123)
 
 
+def create_test_case0(self):
+    self.interp_method = 'trilinear'
+    self.input_shape = [2, 3, 4, 4, 4]
+    self.out_d = 2
+    self.out_h = 2
+    self.out_w = 2
+    self.scale = []
+    self.out_size = np.array([3, 3, 3]).astype("int32")
+    self.align_corners = True
+    self.align_mode = 1
+
+
+def create_test_case1(self):
+    self.interp_method = 'trilinear'
+    self.input_shape = [2, 1, 7, 8, 9]
+    self.out_d = 1
+    self.out_h = 1
+    self.out_w = 1
+    self.scale = []
+    self.align_corners = True
+    self.align_mode = 1
+
+
+def create_test_case2(self):
+    self.interp_method = 'trilinear'
+    self.input_shape = [2, 3, 9, 6, 8]
+    self.out_d = 12
+    self.out_h = 12
+    self.out_w = 12
+    self.scale = []
+    self.align_corners = True
+    self.align_mode = 1
+
+
+def create_test_case3(self):
+    self.interp_method = 'trilinear'
+    self.input_shape = [3, 2, 16, 8, 4]
+    self.out_d = 32
+    self.out_h = 16
+    self.out_w = 8
+    self.scale = []
+    self.align_corners = True
+    self.align_mode = 1
+
+
+def create_test_case4(self):
+    self.interp_method = 'trilinear'
+    self.input_shape = [4, 1, 7, 8, 9]
+    self.out_d = 1
+    self.out_h = 1
+    self.out_w = 1
+    self.scale = []
+    self.out_size = np.array([2, 2, 2]).astype("int32")
+    self.align_corners = True
+    self.align_mode = 1
+
+
+def create_test_case5(self):
+    self.interp_method = 'trilinear'
+    self.input_shape = [3, 3, 9, 6, 8]
+    self.out_d = 12
+    self.out_h = 12
+    self.out_w = 12
+    self.scale = []
+    self.out_size = np.array([11, 11, 11]).astype("int32")
+    self.align_corners = True
+    self.align_mode = 1
+
+
+def create_test_case6(self):
+    self.interp_method = 'trilinear'
+    self.input_shape = [1, 1, 16, 8, 4]
+    self.out_d = 8
+    self.out_h = 32
+    self.out_w = 16
+    self.scale = []
+    self.out_size = np.array([17, 9, 5]).astype("int32")
+    self.align_corners = True
+    self.align_mode = 1
+
+
 def trilinear_interp_test(
     x,
     OutSize=None,
@@ -201,10 +282,13 @@ class TestTrilinearInterpOp(OpTest):
         self.out_size = None
         self.actual_shape = None
         self.data_layout = 'NCDHW'
+        self.dtype = np.float32
         self.init_test_case()
         self.op_type = "trilinear_interp_v2"
         # NOTE(dev): some AsDispensible input is not used under imperative mode.
-        input_np = np.random.random(self.input_shape).astype("float32")
+        # Skip check_dygraph while found them in Inputs.
+        self.check_dygraph = True
+        input_np = np.random.random(self.input_shape).astype(self.dtype)
 
         scale_w = 0
         scale_h = 0
@@ -285,90 +369,37 @@ class TestTrilinearInterpOp(OpTest):
         self.check_grad(['X'], 'Out', in_place=True)
 
     def init_test_case(self):
-        self.interp_method = 'trilinear'
-        self.input_shape = [2, 3, 4, 4, 4]
-        self.out_d = 2
-        self.out_h = 2
-        self.out_w = 2
-        self.scale = []
-        self.out_size = np.array([3, 3, 3]).astype("int32")
-        self.align_corners = True
-        self.align_mode = 1
+        create_test_case0(self)
 
 
 class TestTrilinearInterpCase1(TestTrilinearInterpOp):
     def init_test_case(self):
-        self.interp_method = 'trilinear'
-        self.input_shape = [2, 1, 7, 8, 9]
-        self.out_d = 1
-        self.out_h = 1
-        self.out_w = 1
-        self.scale = []
-        self.align_corners = True
-        self.align_mode = 1
+        create_test_case1(self)
 
 
 class TestTrilinearInterpCase2(TestTrilinearInterpOp):
     def init_test_case(self):
-        self.interp_method = 'trilinear'
-        self.input_shape = [2, 3, 9, 6, 8]
-        self.out_d = 12
-        self.out_h = 12
-        self.out_w = 12
-        self.scale = []
-        self.align_corners = True
-        self.align_mode = 1
+        create_test_case2(self)
 
 
 class TestTrilinearInterpCase3(TestTrilinearInterpOp):
     def init_test_case(self):
-        self.interp_method = 'trilinear'
-        self.input_shape = [3, 2, 16, 8, 4]
-        self.out_d = 32
-        self.out_h = 16
-        self.out_w = 8
-        self.scale = []
-        self.align_corners = True
-        self.align_mode = 1
+        create_test_case3(self)
 
 
 class TestTrilinearInterpCase4(TestTrilinearInterpOp):
     def init_test_case(self):
-        self.interp_method = 'trilinear'
-        self.input_shape = [4, 1, 7, 8, 9]
-        self.out_d = 1
-        self.out_h = 1
-        self.out_w = 1
-        self.scale = []
-        self.out_size = np.array([2, 2, 2]).astype("int32")
-        self.align_corners = True
-        self.align_mode = 1
+        create_test_case4(self)
 
 
 class TestTrilinearInterpCase5(TestTrilinearInterpOp):
     def init_test_case(self):
-        self.interp_method = 'trilinear'
-        self.input_shape = [3, 3, 9, 6, 8]
-        self.out_d = 12
-        self.out_h = 12
-        self.out_w = 12
-        self.scale = []
-        self.out_size = np.array([11, 11, 11]).astype("int32")
-        self.align_corners = True
-        self.align_mode = 1
+        create_test_case5(self)
 
 
 class TestTrilinearInterpCase6(TestTrilinearInterpOp):
     def init_test_case(self):
-        self.interp_method = 'trilinear'
-        self.input_shape = [1, 1, 16, 8, 4]
-        self.out_d = 8
-        self.out_h = 32
-        self.out_w = 16
-        self.scale = []
-        self.out_size = np.array([17, 9, 5]).astype("int32")
-        self.align_corners = True
-        self.align_mode = 1
+        create_test_case6(self)
 
 
 class TestTrilinearInterpSame(TestTrilinearInterpOp):
@@ -422,6 +453,229 @@ class TestTrilinearInterpDatalayout(TestTrilinearInterpOp):
         self.data_layout = "NDHWC"
 
 
+class TestTrilinearInterpOpFP16(TestTrilinearInterpOp):
+    def test_check_output(self):
+        self.check_output(check_dygraph=self.check_dygraph, atol=1e-3)
+
+    def test_check_grad(self):
+        self.check_grad(
+            ['X'],
+            'Out',
+            in_place=True,
+            check_dygraph=self.check_dygraph,
+            max_relative_error=1e-2,
+        )
+
+    def init_test_case(self):
+        create_test_case0(self)
+        self.dtype = np.float16
+
+
+class TestTrilinearInterpCase1FP16(TestTrilinearInterpOpFP16):
+    def init_test_case(self):
+        create_test_case1(self)
+        self.dtype = np.float16
+
+
+class TestTrilinearInterpCase2FP16(TestTrilinearInterpOpFP16):
+    def init_test_case(self):
+        create_test_case2(self)
+        self.dtype = np.float16
+
+
+class TestTrilinearInterpCase3FP16(TestTrilinearInterpOpFP16):
+    def init_test_case(self):
+        create_test_case3(self)
+        self.dtype = np.float16
+
+
+class TestTrilinearInterpCase4FP16(TestTrilinearInterpOpFP16):
+    def init_test_case(self):
+        create_test_case4(self)
+        self.dtype = np.float16
+
+
+class TestTrilinearInterpCase5FP16(TestTrilinearInterpOpFP16):
+    def init_test_case(self):
+        create_test_case5(self)
+        self.dtype = np.float16
+
+
+class TestTrilinearInterpCase6FP16(TestTrilinearInterpOpFP16):
+    def init_test_case(self):
+        create_test_case6(self)
+        self.dtype = np.float16
+
+
+@unittest.skipIf(
+    not core.is_compiled_with_cuda()
+    or not core.is_bfloat16_supported(core.CUDAPlace(0)),
+    "core is not compiled with CUDA or not support the bfloat16",
+)
+class TestNearestInterpOpBF16(OpTest):
+    def setUp(self):
+        self.python_api = trilinear_interp_test
+        self.out_size = None
+        self.actual_shape = None
+        self.data_layout = 'NCDHW'
+        self.init_test_case()
+        self.op_type = "trilinear_interp_v2"
+        # NOTE(dev): some AsDispensible input is not used under imperative mode.
+        # Skip check_dygraph while found them in Inputs.
+        self.check_dygraph = True
+        self.dtype = np.uint16
+        input_np = np.random.random(self.input_shape).astype("float32")
+
+        scale_w = 0
+        scale_h = 0
+        scale_d = 0
+        if self.data_layout == "NCDHW":
+            in_d = self.input_shape[2]
+            in_h = self.input_shape[3]
+            in_w = self.input_shape[4]
+        else:
+            in_d = self.input_shape[1]
+            in_h = self.input_shape[2]
+            in_w = self.input_shape[3]
+
+        if self.scale:
+            if isinstance(self.scale, float) or isinstance(self.scale, int):
+                if self.scale > 0:
+                    scale_d = scale_h = scale_w = float(self.scale)
+            if isinstance(self.scale, list) and len(self.scale) == 1:
+                scale_d = scale_w = scale_h = self.scale[0]
+            elif isinstance(self.scale, list) and len(self.scale) > 1:
+                scale_w = self.scale[2]
+                scale_h = self.scale[1]
+                scale_d = self.scale[0]
+            out_d = int(in_d * scale_d)
+            out_h = int(in_h * scale_h)
+            out_w = int(in_w * scale_w)
+        else:
+            out_d = self.out_d
+            out_h = self.out_h
+            out_w = self.out_w
+
+        output_np = trilinear_interp_np(
+            input_np,
+            out_d,
+            out_h,
+            out_w,
+            scale_d,
+            scale_h,
+            scale_w,
+            self.out_size,
+            self.actual_shape,
+            self.align_corners,
+            self.align_mode,
+            self.data_layout,
+        )
+        self.inputs = {'X': convert_float_to_uint16(input_np)}
+        if self.out_size is not None:
+            self.inputs['OutSize'] = self.out_size
+            self.check_dygraph = False
+        if self.actual_shape is not None:
+            self.inputs['OutSize'] = self.actual_shape
+            self.check_dygraph = False
+        # c++ end treat NCDHW the same way as NCHW
+        if self.data_layout == 'NCDHW':
+            data_layout = 'NCHW'
+        else:
+            data_layout = 'NHWC'
+        self.attrs = {
+            'out_d': self.out_d,
+            'out_h': self.out_h,
+            'out_w': self.out_w,
+            'interp_method': self.interp_method,
+            'align_corners': self.align_corners,
+            'align_mode': self.align_mode,
+            'data_layout': data_layout,
+        }
+        if self.scale:
+            if isinstance(self.scale, float) or isinstance(self.scale, int):
+                if self.scale > 0:
+                    self.scale = [self.scale]
+            if isinstance(self.scale, list) and len(self.scale) == 1:
+                self.scale = [self.scale[0], self.scale[0], self.scale[0]]
+            self.attrs['scale'] = self.scale
+        self.outputs = {'Out': convert_float_to_uint16(output_np)}
+
+    def test_check_output(self):
+        self.check_output(check_dygraph=self.check_dygraph, atol=1e-2)
+
+    def test_check_grad(self):
+        self.check_grad(
+            ['X'],
+            'Out',
+            in_place=True,
+            check_dygraph=self.check_dygraph,
+            max_relative_error=1e-2,
+        )
+
+    def init_test_case(self):
+        create_test_case0(self)
+
+
+@unittest.skipIf(
+    not core.is_compiled_with_cuda()
+    or not core.is_bfloat16_supported(core.CUDAPlace(0)),
+    "core is not compiled with CUDA or not support the bfloat16",
+)
+class TestTrilinearInterpCase1BF16(TestNearestInterpOpBF16):
+    def init_test_case(self):
+        create_test_case1(self)
+
+
+@unittest.skipIf(
+    not core.is_compiled_with_cuda()
+    or not core.is_bfloat16_supported(core.CUDAPlace(0)),
+    "core is not compiled with CUDA or not support the bfloat16",
+)
+class TestTrilinearInterpCase2BF16(TestNearestInterpOpBF16):
+    def init_test_case(self):
+        create_test_case2(self)
+
+
+@unittest.skipIf(
+    not core.is_compiled_with_cuda()
+    or not core.is_bfloat16_supported(core.CUDAPlace(0)),
+    "core is not compiled with CUDA or not support the bfloat16",
+)
+class TestTrilinearInterpCase3BF16(TestNearestInterpOpBF16):
+    def init_test_case(self):
+        create_test_case3(self)
+
+
+@unittest.skipIf(
+    not core.is_compiled_with_cuda()
+    or not core.is_bfloat16_supported(core.CUDAPlace(0)),
+    "core is not compiled with CUDA or not support the bfloat16",
+)
+class TestTrilinearInterpCase4BF16(TestNearestInterpOpBF16):
+    def init_test_case(self):
+        create_test_case4(self)
+
+
+@unittest.skipIf(
+    not core.is_compiled_with_cuda()
+    or not core.is_bfloat16_supported(core.CUDAPlace(0)),
+    "core is not compiled with CUDA or not support the bfloat16",
+)
+class TestTrilinearInterpCase5BF16(TestNearestInterpOpBF16):
+    def init_test_case(self):
+        create_test_case5(self)
+
+
+@unittest.skipIf(
+    not core.is_compiled_with_cuda()
+    or not core.is_bfloat16_supported(core.CUDAPlace(0)),
+    "core is not compiled with CUDA or not support the bfloat16",
+)
+class TestTrilinearInterpCase6BF16(TestNearestInterpOpBF16):
+    def init_test_case(self):
+        create_test_case6(self)
+
+
 class TestTrilinearInterpOpUint8(OpTest):
     def setUp(self):
         self.python_api = trilinear_interp_test