fix (#72890)

fangfangssj · web-flow · commit 73173ccd0e2f · 2025-05-24T10:16:40.000+08:00
diff --git a/paddle/phi/kernels/xpu/full_kernel.cc b/paddle/phi/kernels/xpu/full_kernel.cc
@@ -23,6 +23,7 @@
 #include "paddle/phi/common/scalar.h"
 #include "paddle/phi/core/kernel_registry.h"
 #include "paddle/phi/core/visit_type.h"
+#include "paddle/phi/kernels/complex_kernel.h"
 #include "paddle/phi/kernels/impl/full_with_tensor_kernel_impl.h"
 
 namespace phi {
@@ -46,6 +47,43 @@ void FullKernel(const Context& dev_ctx,
   }
 }
 
+#ifdef PADDLE_WITH_XPU_FFT
+template <>
+void FullKernel<phi::dtype::complex<float>, XPUContext>(
+    const XPUContext& dev_ctx,
+    const IntArray& shape,
+    const Scalar& val,
+    DataType dtype,
+    DenseTensor* out) {
+  using T = phi::dtype::complex<float>;
+  out->Resize(common::make_ddim(shape.GetData()));
+  dev_ctx.template Alloc<T>(out);
+
+  T complex_val = val.to<T>();
+  float real_part = complex_val.real;
+  float imag_part = complex_val.imag;
+
+  // The current complex number implementation uses separate real/imaginary
+  // parts,resulting in redundant operations and performance
+  // penalties.Optimization should address this in future iterations.
+  DenseTensor real_out, imag_out;
+  real_out.Resize(out->dims());
+  imag_out.Resize(out->dims());
+  dev_ctx.template Alloc<float>(&real_out);
+  dev_ctx.template Alloc<float>(&imag_out);
+
+  if (out->numel() > 0) {
+    int r = xpu::constant(
+        dev_ctx.x_context(), real_out.data<float>(), out->numel(), real_part);
+    PADDLE_ENFORCE_XDNN_SUCCESS(r, "constant");
+    r = xpu::constant(
+        dev_ctx.x_context(), imag_out.data<float>(), out->numel(), imag_part);
+    PADDLE_ENFORCE_XDNN_SUCCESS(r, "constant");
+    phi::ComplexKernel<float>(dev_ctx, real_out, imag_out, out);
+  }
+}
+#endif
+
 template <typename T, typename Context>
 void FullLikeKernel(const Context& dev_ctx,
                     const DenseTensor& x,
diff --git a/paddle/phi/kernels/xpu/slice_grad_kernel.cc b/paddle/phi/kernels/xpu/slice_grad_kernel.cc
@@ -17,6 +17,7 @@
 #include "paddle/phi/backends/xpu/enforce_xpu.h"
 #include "paddle/phi/core/kernel_registry.h"
 #include "paddle/phi/kernels/complex_kernel.h"
+#include "paddle/phi/kernels/full_kernel.h"
 #include "paddle/phi/kernels/funcs/slice_utils.h"
 
 namespace phi {
@@ -33,7 +34,17 @@ void SliceGradKernel(const Context& ctx,
                      DenseTensor* input_grad) {
   using XPUType = typename XPUTypeTrait<T>::Type;
   ctx.template Alloc<T>(input_grad);
-
+  if (input_grad->numel() == 0) {
+    return;
+  }
+  if (out_grad.numel() == 0) {
+    phi::Full<T, XPUContext>(
+        ctx,
+        phi::IntArray(common::vectorize(input_grad->dims())),
+        T(0),
+        input_grad);
+    return;
+  }
   // Get the accurate attribute value of starts and ends
   std::vector<int64_t> starts = starts_t.GetData();
   std::vector<int64_t> ends = ends_t.GetData();
@@ -50,16 +61,14 @@ void SliceGradKernel(const Context& ctx,
     int64_t end = in_dims[i];
     int64_t axis = cnt < static_cast<int64_t>(axes.size()) ? axes[cnt] : -1;
     if (axis == i) {
-      start = starts[cnt];
-      if (start < 0) {
-        start = (start + in_dims[i]);
-      }
-      start = std::max(start, static_cast<int64_t>(0));
-      end = ends[cnt];
-      if (end < 0) {
-        end = (end + in_dims[i]);
-      }
-      end = std::min(end, in_dims[i]);
+      bool zero_dim = false;
+      funcs::normalize_interval(starts[cnt],
+                                ends[cnt],
+                                static_cast<int64_t>(1),
+                                in_dims[i],
+                                &start,
+                                &end,
+                                &zero_dim);
       cnt++;
     }
 
@@ -93,6 +102,17 @@ void SliceGradKernel<phi::dtype::complex<float>, XPUContext>(
     DenseTensor* input_grad) {
   using T = phi::dtype::complex<float>;
   ctx.template Alloc<T>(input_grad);
+  if (input_grad->numel() == 0) {
+    return;
+  }
+  if (out_grad.numel() == 0) {
+    phi::Full<T, XPUContext>(
+        ctx,
+        phi::IntArray(common::vectorize(input_grad->dims())),
+        T(0),
+        input_grad);
+    return;
+  }
 
   // Get the accurate attribute value of starts and ends
   std::vector<int64_t> starts = starts_t.GetData();
@@ -110,16 +130,14 @@ void SliceGradKernel<phi::dtype::complex<float>, XPUContext>(
     int64_t end = in_dims[i];
     int64_t axis = cnt < static_cast<int64_t>(axes.size()) ? axes[cnt] : -1;
     if (axis == i) {
-      start = starts[cnt];
-      if (start < 0) {
-        start = (start + in_dims[i]);
-      }
-      start = std::max(start, static_cast<int64_t>(0));
-      end = ends[cnt];
-      if (end < 0) {
-        end = (end + in_dims[i]);
-      }
-      end = std::min(end, in_dims[i]);
+      bool zero_dim = false;
+      funcs::normalize_interval(starts[cnt],
+                                ends[cnt],
+                                static_cast<int64_t>(1),
+                                in_dims[i],
+                                &start,
+                                &end,
+                                &zero_dim);
       cnt++;
     }
 
diff --git a/paddle/phi/kernels/xpu/slice_kernel.cc b/paddle/phi/kernels/xpu/slice_kernel.cc
@@ -31,7 +31,10 @@ void SliceKernel(const Context& ctx,
                  const std::vector<int64_t>& decrease_axis,
                  DenseTensor* out) {
   using XPUType = typename XPUTypeTrait<T>::Type;
-
+  if (out->numel() == 0) {
+    ctx.template Alloc<T>(out);
+    return;
+  }
   // Step 1: Get the accurate attribute value of starts and ends
   std::vector<int64_t> starts = starts_t.GetData();
   std::vector<int64_t> ends = ends_t.GetData();
@@ -140,6 +143,10 @@ void SliceKernel<phi::dtype::complex<float>, XPUContext>(
     const std::vector<int64_t>& decrease_axis,
     DenseTensor* out) {
   using T = phi::dtype::complex<float>;
+  if (out->numel() == 0) {
+    ctx.template Alloc<T>(out);
+    return;
+  }
   // Step 1: Get the accurate attribute value of starts and ends
   std::vector<int64_t> starts = starts_t.GetData();
   std::vector<int64_t> ends = ends_t.GetData();
diff --git a/test/xpu/CMakeLists.txt b/test/xpu/CMakeLists.txt
@@ -31,6 +31,7 @@ endforeach()
 
 set_tests_properties(test_conv2d_op_xpu PROPERTIES TIMEOUT 120)
 set_tests_properties(test_mul_op_xpu PROPERTIES TIMEOUT 120)
+set_tests_properties(test_slice_op_xpu PROPERTIES TIMEOUT 40)
 set_tests_properties(test_matmul_v2_op_xpu PROPERTIES TIMEOUT 900)
 set_tests_properties(test_collective_identity_xpu
                      PROPERTIES LABELS "RUN_TYPE=DIST_KUNLUN")
diff --git a/test/xpu/test_real_imag_op_xpu.py b/test/xpu/test_real_imag_op_xpu.py
@@ -159,7 +159,7 @@ def test_check_grad(self):
             )
 
 
-class TTestImagOpZeroSize1(TestImagOp):
+class TestImagOpZeroSize1(TestImagOp):
     def init_input_output(self):
         self.inputs = {
             'X': np.random.random(0).astype(self.dtype)
diff --git a/test/xpu/test_slice_op_xpu.py b/test/xpu/test_slice_op_xpu.py
@@ -59,6 +59,9 @@ def config(self):
             self.infer_flags = [1, 1, 1]
             self.out = self.input[1:3, 0:3, 2:4, :]
 
+        def test_check_output(self):
+            self.check_output_with_place(self.place)
+
         def test_check_grad_normal(self):
             if self.dtype == np.float16:
                 self.check_grad_with_place(self.place, ['Input'], 'Out')
@@ -225,28 +228,12 @@ def setUp(self):
             self.dtype = np.float32
             self.place = paddle.XPUPlace(0)
             self.op_type = "slice"
-            self.config()
-            self.inputs = {'Input': self.input}
-            self.outputs = {'Out': self.out}
-            self.attrs = {
-                'axes': self.axes,
-                'starts': self.starts,
-                'ends': self.ends,
-                'infer_flags': self.infer_flags,
-                "use_xpu": True,
-            }
+            self.python_api = paddle.slice
 
-        def config(self):
-            real_part = np.random.random([3, 4, 5, 6]).astype(self.dtype)
-            imag_part = np.random.random([3, 4, 5, 6]).astype(self.dtype)
-            self.input = real_part + 1j * imag_part
-            self.starts = [1, 0, 2]
-            self.ends = [3, 3, 4]
-            self.axes = [0, 1, 2]
-            self.infer_flags = [1, 1, 1]
-            self.out = self.input[1:3, 0:3, 2:4, :]
+        def _test_check_output(self):
+            self.check_output_with_place(self.place)
 
-        def test_check_grad_normal(self):
+        def _test_check_grad_normal(self):
             real_grad = np.random.random(self.out.shape).astype(self.dtype)
             imag_grad = np.random.random(self.out.shape).astype(self.dtype)
             user_defined_grad_outputs = real_grad + 1j * imag_grad
@@ -257,27 +244,101 @@ def test_check_grad_normal(self):
                 user_defined_grad_outputs=user_defined_grad_outputs,
             )
 
-    class TestCaseComplex1(TestSliceOpComplex):
-        def config(self):
+        def test_with_all_possible_start_end(self):
             real_part = np.random.random([3, 4, 5, 6]).astype(self.dtype)
             imag_part = np.random.random([3, 4, 5, 6]).astype(self.dtype)
-            self.input = real_part + 1j * imag_part
-            self.starts = [-3, 0, 2]
-            self.ends = [3, 100, -1]
-            self.axes = [0, 1, 2]
-            self.infer_flags = [1, 1, 1]
-            self.out = self.input[-3:3, 0:100, 2:-1, :]
-
-    class TestCaseComplex2(TestSliceOpComplex):
-        def config(self):
-            real_part = np.random.random([3, 4, 5, 6]).astype(self.dtype)
-            imag_part = np.random.random([3, 4, 5, 6]).astype(self.dtype)
-            self.input = real_part + 1j * imag_part
-            self.starts = [-3, 0, 2]
-            self.ends = [3, 100, -1]
-            self.axes = [0, 1, 3]
-            self.infer_flags = [1, 1, 1]
-            self.out = self.input[-3:3, 0:100, :, 2:-1]
+            np_data = real_part + 1j * imag_part
+            dim_size = np_data.shape[2]
+            for st in [*list(range(-dim_size - 1, dim_size + 2)), None]:
+                for ed in [*list(range(-dim_size - 1, dim_size + 2)), None]:
+                    try:
+                        np_res = np_data[:, :, st:ed, :]
+                    except Exception as e:
+                        # skip the invalid case use try-except strategy
+                        continue
+                    self.axes = [2]
+                    self.starts = [st if st is not None else 0]
+                    self.ends = [ed if ed is not None else dim_size]
+                    self.infer_flags = [1]
+
+                    self.input = np_data
+                    self.out = np_res
+                    self.inputs = {'Input': self.input}
+                    self.outputs = {'Out': self.out}
+                    self.attrs = {
+                        'axes': self.axes,
+                        'starts': self.starts,
+                        'ends': self.ends,
+                        'infer_flags': self.infer_flags,
+                        "use_xpu": True,
+                    }
+
+                    self._test_check_output()
+                    self._test_check_grad_normal()
+
+        def test_with_all_possible_start_end_zero_size(self):
+            real_part = np.random.random([0, 4, 5, 6]).astype(self.dtype)
+            imag_part = np.random.random([0, 4, 5, 6]).astype(self.dtype)
+            np_data = real_part + 1j * imag_part
+            dim_size = np_data.shape[2]
+            for st in [*list(range(-dim_size - 1, dim_size + 2)), None]:
+                for ed in [*list(range(-dim_size - 1, dim_size + 2)), None]:
+                    try:
+                        np_res = np_data[:, :, st:ed, :]
+                    except Exception as e:
+                        # skip the invalid case use try-except strategy
+                        continue
+                    self.axes = [2]
+                    self.starts = [st if st is not None else 0]
+                    self.ends = [ed if ed is not None else dim_size]
+                    self.infer_flags = [1]
+
+                    self.input = np_data
+                    self.out = np_res
+                    self.inputs = {'Input': self.input}
+                    self.outputs = {'Out': self.out}
+                    self.attrs = {
+                        'axes': self.axes,
+                        'starts': self.starts,
+                        'ends': self.ends,
+                        'infer_flags': self.infer_flags,
+                        "use_xpu": True,
+                    }
+
+                    self._test_check_output()
+                    self._test_check_grad_normal()
+
+        def test_with_all_possible_start_end_zero_size_self(self):
+            real_part = np.random.random([3, 4, 0, 6]).astype(self.dtype)
+            imag_part = np.random.random([3, 4, 0, 6]).astype(self.dtype)
+            np_data = real_part + 1j * imag_part
+            dim_size = np_data.shape[2]
+            for st in [*list(range(-dim_size - 1, dim_size + 2)), None]:
+                for ed in [*list(range(-dim_size - 1, dim_size + 2)), None]:
+                    try:
+                        np_res = np_data[:, :, st:ed, :]
+                    except Exception as e:
+                        # skip the invalid case use try-except strategy
+                        continue
+                    self.axes = [2]
+                    self.starts = [st if st is not None else 0]
+                    self.ends = [ed if ed is not None else dim_size]
+                    self.infer_flags = [1]
+
+                    self.input = np_data
+                    self.out = np_res
+                    self.inputs = {'Input': self.input}
+                    self.outputs = {'Out': self.out}
+                    self.attrs = {
+                        'axes': self.axes,
+                        'starts': self.starts,
+                        'ends': self.ends,
+                        'infer_flags': self.infer_flags,
+                        "use_xpu": True,
+                    }
+
+                    self._test_check_output()
+                    self._test_check_grad_normal()
 
 
 if __name__ == '__main__':

Original file line number	Diff line number	Diff line change
`@@ -159,7 +159,7 @@ def test_check_grad(self):`
`159`	`159`	`)`
`160`	`160`
`161`	`161`
`162`		`-class TTestImagOpZeroSize1(TestImagOp):`
	`162`	`+class TestImagOpZeroSize1(TestImagOp):`
`163`	`163`	`def init_input_output(self):`
`164`	`164`	`self.inputs = {`
`165`	`165`	`'X': np.random.random(0).astype(self.dtype)`