[Accuracy diff No.38-39] Fix accuracy diff for nextafter API (#72965)

Author: ooooo-create

paddle/phi/kernels/cpu/elementwise_kernel.cc

@@ -106,6 +106,23 @@ void CopySignKernel(const Context& dev_ctx,
  }
 }
 
+template <typename T, typename Context>
+void NextafterKernel(const Context& dev_ctx,
+ const DenseTensor& x,
+ const DenseTensor& y,
+ DenseTensor* out) {
+ dev_ctx.template Alloc<T>(out);
+ auto x_dims = x.dims();
+ auto y_dims = y.dims();
+ if (x_dims.size() >= y_dims.size()) {
+ funcs::ElementwiseCompute<funcs::NextafterFunctor<T>, T>(
+ dev_ctx, x, y, funcs ::NextafterFunctor<T>(), out);
+ } else {
+ funcs::ElementwiseCompute<funcs::InverseNextafterFunctor<T>, T>(
+ dev_ctx, x, y, funcs::InverseNextafterFunctor<T>(), out);
+ }
+}
+
 } // namespace phi
 
 using complex64 = ::phi::dtype::complex<float>;
@@ -193,3 +210,5 @@ PD_REGISTER_KERNEL(copysign,
  double,
  phi::dtype::float16,
  phi::dtype::bfloat16) {}
+PD_REGISTER_KERNEL(
+ nextafter, CPU, ALL_LAYOUT, phi::NextafterKernel, float, double) {}

paddle/phi/kernels/cpu/nextafter_kernel.cc

@@ -73,6 +73,12 @@ void CopySignKernel(const Context& dev_ctx,
  const DenseTensor& y,
  DenseTensor* out);
 
+template <typename T, typename Context>
+void NextafterKernel(const Context& dev_ctx,
+ const DenseTensor& x,
+ const DenseTensor& y,
+ DenseTensor* out);
+
 template <typename T, typename Context>
 DenseTensor Maximum(const Context& dev_ctx,
  const DenseTensor& x,

paddle/phi/kernels/elementwise_kernel.h

@@ -1174,5 +1174,56 @@ struct InverseCopySignFunctor {
  }
 };
 
+template <typename T, typename Enable = void>
+struct NextafterFunctor {
+ inline HOSTDEVICE T operator()(const T x, const T y) const {
+ return static_cast<T>(
+ std::nextafter(static_cast<float>(x), static_cast<float>(y)));
+ }
+};
+
+template <typename T>
+struct NextafterFunctor<
+ T,
+ typename std::enable_if_t<std::is_same<T, double>::value>> {
+ inline HOSTDEVICE T operator()(const T x, const T y) const {
+ return std::nextafter(x, y);
+ }
+};
+
+template <typename T>
+struct NextafterFunctor<T,
+ typename std::enable_if_t<std::is_integral<T>::value>> {
+ inline HOSTDEVICE double operator()(const T x, const T y) const {
+ return std::nextafter(static_cast<double>(x), static_cast<double>(y));
+ }
+};
+
+template <typename T, typename Enable = void>
+struct InverseNextafterFunctor {
+ inline HOSTDEVICE T operator()(const T x, const T y) const {
+ return static_cast<T>(
+ std::nextafter(static_cast<float>(y), static_cast<float>(x)));
+ }
+};
+
+template <typename T>
+struct InverseNextafterFunctor<
+ T,
+ typename std::enable_if_t<std::is_same<T, double>::value>> {
+ inline HOSTDEVICE T operator()(const T x, const T y) const {
+ return std::nextafter(y, x);
+ }
+};
+
+template <typename T>
+struct InverseNextafterFunctor<
+ T,
+ typename std::enable_if_t<std::is_integral<T>::value>> {
+ inline HOSTDEVICE double operator()(const T x, const T y) const {
+ return std::nextafter(static_cast<double>(y), static_cast<double>(x));
+ }
+};
+
 } // namespace funcs
 } // namespace phi

paddle/phi/kernels/funcs/elementwise_functor.h

@@ -196,6 +196,18 @@ void CopySignKernel(const Context& dev_ctx,
  dev_ctx, inputs, &outputs, funcs::CopySignFunctor<T>());
 }
 
+template <typename T, typename Context>
+void NextafterKernel(const Context& dev_ctx,
+ const DenseTensor& x,
+ const DenseTensor& y,
+ DenseTensor* out) {
+ std::vector<const DenseTensor*> inputs = {&x, &y};
+ std::vector<DenseTensor*> outputs = {out};
+ dev_ctx.template Alloc<T>(out);
+ funcs::BroadcastKernel<T>(
+ dev_ctx, inputs, &outputs, funcs::NextafterFunctor<T>());
+}
+
 } // namespace phi
 
 #if defined(PADDLE_WITH_CUDA) || defined(PADDLE_WITH_HIP)
@@ -269,6 +281,8 @@ PD_REGISTER_KERNEL(copysign,
  double,
  phi::dtype::float16,
  phi::dtype::bfloat16) {}
+PD_REGISTER_KERNEL(
+ nextafter, GPU, ALL_LAYOUT, phi::NextafterKernel, float, double) {}
 
 #endif
 

paddle/phi/kernels/gpu/nextafter_kernel.cu

@@ -95,9 +95,10 @@ def setUp(self):
  self.op_type = "nextafter"
  self.python_api = paddle.nextafter
  self.init_dtype()
+ self.init_shape()
 
- x = np.array([1, 2]).astype(self.dtype)
- y = np.array([2, 1]).astype(self.dtype)
+ x = np.random.rand(*self.x_shape).astype(self.dtype)
+ y = np.random.rand(*self.y_shape).astype(self.dtype)
  out = np.nextafter(x, y)
  self.inputs = {'x': x, 'y': y}
  self.outputs = {'out': out}
@@ -108,11 +109,45 @@ def test_check_output(self):
  def init_dtype(self):
  self.dtype = np.float64
 
+ def init_shape(self):
+ self.x_shape = (2,)
+ self.y_shape = (2,)
+
 
 class TestNextafterOPFP32(TestNextafterOP):
  def init_dtype(self):
  self.dtype = np.float32
 
 
+class TestNextafterOPFP32Case1(TestNextafterOP):
+ def init_dtype(self):
+ self.dtype = np.float32
+
+ def init_shape(self):
+ self.x_shape = (5,)
+ self.y_shape = (2, 3, 4, 5)
+
+
+class TestNextafterOPFP32Case2(TestNextafterOP):
+ def init_dtype(self):
+ self.dtype = np.float32
+
+ def init_shape(self):
+ self.x_shape = (2, 3, 4, 5)
+ self.y_shape = (1,)
+
+
+class TestNextafterOPCase1(TestNextafterOP):
+ def init_shape(self):
+ self.x_shape = (5,)
+ self.y_shape = (2, 3, 4, 5)
+
+
+class TestNextafterOPCase2(TestNextafterOP):
+ def init_shape(self):
+ self.x_shape = (2, 3, 4, 5)
+ self.y_shape = (1,)
+
+
 if __name__ == "__main__":
  unittest.main()