[0-size Tensor No.181] Add 0-size Tensor support for paddle.nn.functional.interpolate [fluid_ops]

Author: co63oc

paddle/phi/infermeta/multiary.cc

@@ -3245,7 +3245,7 @@ static void Interpolate1DInferShapeCheck(
                         "Input(X) dimension is 3, but got method = %s .",
                         interp_method));
   const DataLayout data_layout = common::StringToDataLayout(data_layout_str);
-  for (int i = 0; i < dim_x.size(); ++i) {
+  for (int i = 2; i < dim_x.size(); ++i) {
     PADDLE_ENFORCE_NE(dim_x[i],
                       0,
                       common::errors::InvalidArgument(
@@ -3377,7 +3377,7 @@ static void Interpolate2DInferShapeCheck(
           interp_method));
   const DataLayout data_layout = common::StringToDataLayout(data_layout_str);
 
-  for (int i = 0; i < dim_x.size(); ++i) {
+  for (int i = 2; i < dim_x.size(); ++i) {
     PADDLE_ENFORCE_NE(dim_x[i],
                       0,
                       common::errors::InvalidArgument(
@@ -3530,7 +3530,7 @@ static void Interpolate3DInferShapeCheck(
           interp_method));
   const DataLayout data_layout = common::StringToDataLayout(data_layout_str);
 
-  for (int i = 0; i < dim_x.size(); ++i) {
+  for (int i = 2; i < dim_x.size(); ++i) {
     PADDLE_ENFORCE_NE(dim_x[i],
                       0,
                       common::errors::InvalidArgument(

paddle/phi/kernels/cpu/interpolate_grad_kernel.cc

@@ -861,6 +861,10 @@ void InterpolateGradKernel(
     bool align_corners,
     int align_mode,
     DenseTensor* x_grad) {
+  if (x_grad && x_grad->numel() == 0) {
+    dev_ctx.template Alloc<T>(x_grad);
+    return;
+  }
   auto output_grad_dims = output_grad.dims();
   if (output_grad_dims.size() == 3) {  // 1D interpolation grad
     Interpolate1DCPUBwd<T, Context>(dev_ctx,

paddle/phi/kernels/cpu/interpolate_kernel.cc

@@ -1033,6 +1033,11 @@ void InterpolateKernel(
     bool align_corners,
     int align_mode,
     DenseTensor* output) {
+  if (x.numel() == 0) {
+    dev_ctx.template Alloc<T>(output);
+    return;
+  }
+
   auto input_dims = x.dims();
   if (input_dims.size() == 3) {  // 1D interpolation
     Interpolate1DCPUFwd<T, Context>(dev_ctx,

paddle/phi/kernels/gpu/interpolate_grad_kernel.cu

@@ -1438,6 +1438,10 @@ void InterpolateGradKernel(
     bool align_corners,
     int align_mode,
     DenseTensor* x_grad) {
+  if (x_grad && x_grad->numel() == 0) {
+    dev_ctx.template Alloc<T>(x_grad);
+    return;
+  }
   auto output_grad_dims = output_grad.dims();
   if (output_grad_dims.size() == 3) {  // 1D interpolation grad
     Interpolate1DCUDABwd<T, Context>(dev_ctx,

paddle/phi/kernels/gpu/interpolate_kernel.cu

@@ -1230,6 +1230,10 @@ void InterpolateKernel(
     bool align_corners,
     int align_mode,
     DenseTensor* output) {
+  if (x.numel() == 0) {
+    dev_ctx.template Alloc<T>(output);
+    return;
+  }
   auto input_dims = x.dims();
   if (input_dims.size() == 3) {  // 1D interpolation
     Interpolate1DCUDAFwd<T, Context>(dev_ctx,

paddle/phi/kernels/xpu/interpolate_grad_kernel.cc

@@ -39,6 +39,10 @@ void InterpolateGradKernel(
     bool align_corners,
     int align_mode,
     DenseTensor* x_grad) {
+  if (x_grad && x_grad->numel() == 0) {
+    dev_ctx.template Alloc<T>(x_grad);
+    return;
+  }
   const DataLayout data_layout = common::StringToDataLayout(data_layout_str);
   int n, c, in_d, in_h, in_w;
   funcs::ExtractNCDWH(x.dims(), data_layout, &n, &c, &in_d, &in_h, &in_w);

paddle/phi/kernels/xpu/interpolate_kernel.cc

@@ -38,6 +38,10 @@ void InterpolateKernel(
     bool align_corners,
     int align_mode,
     DenseTensor* output) {
+  if (x.numel() == 0) {
+    dev_ctx.template Alloc<T>(output);
+    return;
+  }
   using XPUType = typename XPUTypeTrait<T>::Type;
   const DataLayout data_layout = common::StringToDataLayout(data_layout_str);
   int n, c, in_d, in_h, in_w;

python/paddle/nn/functional/common.py

@@ -642,7 +642,7 @@ def _is_list_or_tuple_(data):
             if len(x.shape) == 4:
                 if len(out_shape) != 2:
                     raise ValueError(
-                        "size length should be 2 for " "input 4-D tensor."
+                        "size length should be 2 for input 4-D tensor."
                     )
                 if contain_var:
                     attrs['out_h'] = size_list[0]
@@ -667,6 +667,30 @@ def _is_list_or_tuple_(data):
                     attrs['out_w'] = out_shape[2]
 
     elif scale is not None:
+        # scale in python is float64, but in kernel is float32, so we need to recalculate the scale in float32
+        # Currently it is only used when x.size is 0.
+        x_shape = x.shape
+        if data_format == 'NCW':
+            max_dim = x_shape[2]
+        elif data_format == 'NWC':
+            max_dim = x_shape[1]
+        elif data_format == 'NCHW':
+            max_dim = max(x.shape[2], x.shape[3])
+        elif data_format == 'NHWC':
+            max_dim = max(x.shape[1], x.shape[2])
+        elif data_format == 'NCDHW':
+            max_dim = max(x.shape[2], x.shape[3], x.shape[4])
+        elif data_format == 'NDHWC':
+            max_dim = max(x.shape[1], x.shape[2], x.shape[3])
+        else:
+            max_dim = 1
+
+        def _scale_to_float32(value):
+            if len(str(value)) <= 10:
+                return value
+            # round down
+            return numpy.float32(int(value * max_dim) / max_dim)
+
         if recompute_scale_factor:
             if in_dynamic_mode() and isinstance(scale, Variable):
                 if scale.shape == []:
@@ -710,11 +734,15 @@ def _is_list_or_tuple_(data):
 
             scale = None
         else:
-            if in_dynamic_mode() and isinstance(scale, Variable):
+            dynamic_mode = False
+            if in_dynamic_mode():
+                dynamic_mode = True
+            if dynamic_mode and isinstance(scale, Variable):
                 if scale.shape == []:
                     scale = float(scale)
                 else:
                     scale = list(scale.numpy())
+
             if isinstance(scale, (Variable, paddle.pir.Value)):
                 scale.stop_gradient = True
                 inputs["Scale"] = scale
@@ -724,7 +752,10 @@ def _is_list_or_tuple_(data):
                 scale_list = []
                 for i in range(len(x.shape) - 2):
                     scale_list.append(scale)
-                attrs['scale'] = list(map(float, scale_list))
+                if dynamic_mode and x.size == 0:
+                    attrs['scale'] = list(map(_scale_to_float32, scale_list))
+                else:
+                    attrs['scale'] = list(map(float, scale_list))
             elif isinstance(scale, (list, tuple)):
                 if len(scale) != len(x.shape) - 2:
                     raise ValueError(
@@ -736,7 +767,10 @@ def _is_list_or_tuple_(data):
                         raise ValueError(
                             "Attr(scale) should be greater than zero."
                         )
-                attrs['scale'] = list(map(float, scale))
+                if dynamic_mode and x.size == 0:
+                    attrs['scale'] = list(map(_scale_to_float32, scale))
+                else:
+                    attrs['scale'] = list(map(float, scale))
             else:
                 raise TypeError(
                     "Attr(scale)'s type should be float, int, list, tuple, or Tensor."

test/legacy_test/test_adaptive_avg_pool2d.py

@@ -515,5 +515,33 @@ def test_grad(self):
             np.testing.assert_allclose(x.grad.shape, x.shape)
 
 
+class TestInterpolateAPI_ZeroSize(unittest.TestCase):
+    def setUp(self):
+        self.x_np = np.random.random([0, 3, 7, 7]).astype("float32")
+
+    def test_functional_interpolate(self):
+        for use_cuda in (
+            [False, True] if core.is_compiled_with_cuda() else [False]
+        ):
+            place = paddle.CUDAPlace(0) if use_cuda else paddle.CPUPlace()
+            paddle.disable_static(place=place)
+            x = paddle.to_tensor(self.x_np)
+            x.stop_gradient = False
+
+            out = paddle.nn.functional.interpolate(
+                x=x, mode="area", size=[2, 5]
+            )
+            res_np = adaptive_pool2d_forward(
+                x=self.x_np, output_size=[2, 5], pool_type="avg"
+            )
+            np.testing.assert_allclose(
+                out.numpy(), res_np, rtol=1e-5, atol=1e-8
+            )
+
+            loss = paddle.sum(out)
+            loss.backward()
+            np.testing.assert_allclose(x.grad.shape, x.shape)
+
+
 if __name__ == '__main__':
     unittest.main()

test/legacy_test/test_bicubic_interp_v2_op.py

@@ -912,7 +912,7 @@ def test_input_shape_1():
         self.assertRaises(ValueError, test_size_length)
         self.assertRaises(ValueError, test_size_tensor_ndim)
         self.assertRaises(ValueError, test_size_tensor_length)
-        self.assertRaises(ValueError, test_input_shape_1)
+        # self.assertRaises(ValueError, test_input_shape_1)
 
     def test_errors(self):
         with program_guard(Program(), Program()):