【Hackathon 6th No.28】为 paddle.round 进行功能增强 -part (#64436)

zbt78 · web-flow · commit 218e62d8acf1 · 2024-07-04T14:30:27.000+08:00
* add decimals for round

* set defalut value

* fix

* fix round inplace

* add round inplace func

* empty

* fix round  on onednn

* fix

* remove redundant comments

* re-run

* change calculation process

* fix bug

* fix bug

* fix bug

* fix bug

* fix bug

* fix bug

* fix bug

* fix coverage

* add attr in yaml file
diff --git a/paddle/phi/kernels/activation_kernel.h b/paddle/phi/kernels/activation_kernel.h
@@ -68,7 +68,6 @@ DECLARE_ACTIVATION_KERNEL(Log)
 DECLARE_ACTIVATION_KERNEL(Log2)
 DECLARE_ACTIVATION_KERNEL(Log10)
 DECLARE_ACTIVATION_KERNEL(Log1p)
-DECLARE_ACTIVATION_KERNEL(Round)
 DECLARE_ACTIVATION_KERNEL(Floor)
 DECLARE_ACTIVATION_KERNEL(Ceil)
 DECLARE_ACTIVATION_KERNEL(Negative)
@@ -98,6 +97,12 @@ void Relu6Kernel(const Context& dev_ctx,
                  const DenseTensor& x,
                  DenseTensor* out);
 
+template <typename T, typename Context>
+void RoundKernel(const Context& dev_ctx,
+                 const DenseTensor& x,
+                 const int decimals,
+                 DenseTensor* out);
+
 template <typename T, typename Context>
 void SwishKernel(const Context& dev_ctx,
                  const DenseTensor& x,
diff --git a/paddle/phi/kernels/cpu/activation_kernel.cc b/paddle/phi/kernels/cpu/activation_kernel.cc
@@ -93,7 +93,6 @@ DEFINE_CPU_ACTIVATION_KERNEL(Rsqrt, RsqrtFunctor)
 DEFINE_CPU_ACTIVATION_KERNEL(Softsign, SoftsignFunctor)
 DEFINE_CPU_ACTIVATION_KERNEL(Sigmoid, SigmoidFunctor)
 DEFINE_CPU_ACTIVATION_KERNEL(LogSigmoid, LogSigmoidFunctor)
-DEFINE_CPU_ACTIVATION_KERNEL(Round, RoundFunctor)
 DEFINE_CPU_ACTIVATION_KERNEL(Floor, FloorFunctor)
 DEFINE_CPU_ACTIVATION_KERNEL(Ceil, CeilFunctor)
 DEFINE_CPU_ACTIVATION_KERNEL(Negative, NegativeFunctor)
@@ -161,6 +160,19 @@ void Relu6Kernel(const Context& dev_ctx,
   ActivationImpl<T, T, Context, funcs::Relu6Functor<T>>(
       dev_ctx, x, out, functor);
 }
+
+template <typename T, typename Context>
+void RoundKernel(const Context& dev_ctx,
+                 const DenseTensor& x,
+                 const int decimals,
+                 DenseTensor* out) {
+  funcs::RoundFunctor<T> functor;
+  auto attrs = functor.GetAttrs();
+  *(attrs[0].second) = decimals;
+  ActivationImpl<T, T, Context, funcs::RoundFunctor<T>>(
+      dev_ctx, x, out, functor);
+}
+
 }  // namespace phi
 PD_REGISTER_KERNEL(relu, CPU, ALL_LAYOUT, phi::ReluKernel, float, double) {}
 
diff --git a/paddle/phi/kernels/funcs/activation_functor.h b/paddle/phi/kernels/funcs/activation_functor.h
@@ -2949,9 +2949,23 @@ struct FloorFunctor : public BaseActivationFunctor<T> {
 // round(x) = [x]
 template <typename T>
 struct RoundFunctor : public BaseActivationFunctor<T> {
+  int decimals;
+
+  std::vector<std::pair<const char*, int*>> GetAttrs() {
+    return {{"deciamls", &decimals}};
+  }
+
   template <typename Device, typename X, typename Out>
   void operator()(Device d, X x, Out out) const {
-    out.device(d) = x.round();
+    if (decimals == 0) {
+      out.device(d) = x.round();
+    } else if (decimals > 0) {
+      auto ten_pow_deciamls = static_cast<T>(std::pow(10, decimals));
+      out.device(d) = (x * ten_pow_deciamls).round() / ten_pow_deciamls;
+    } else {
+      auto ten_pow_deciamls = static_cast<T>(std::pow(10, -decimals));
+      out.device(d) = (x / ten_pow_deciamls).round() * ten_pow_deciamls;
+    }
   }
 };
 
@@ -5161,11 +5175,26 @@ struct CudaFloorFunctor : public BaseActivationFunctor<T> {
 template <typename T>
 struct CudaRoundFunctor : public BaseActivationFunctor<T> {
   using MPType = typename phi::dtype::MPTypeTrait<T>::Type;
+  int decimals;
 
+  std::vector<std::pair<const char*, int*>> GetAttrs() {
+    return {{"deciamls", &decimals}};
+  }
   // round(x) = round(x)
   __device__ __forceinline__ T operator()(const T arg_x) const {
     MPType x = static_cast<MPType>(arg_x);
-    return static_cast<T>(round(x));
+
+    if (decimals == 0) {
+      return static_cast<T>(round(x));
+    } else if (decimals > 0) {
+      float ten_pow_deciamls = powf(10., decimals);
+      return static_cast<T>(round(x * static_cast<MPType>(ten_pow_deciamls)) /
+                            ten_pow_deciamls);
+    } else {
+      float ten_pow_deciamls = powf(10., -decimals);
+      return static_cast<T>(round(x / static_cast<MPType>(ten_pow_deciamls)) *
+                            ten_pow_deciamls);
+    }
   }
 };
 
diff --git a/paddle/phi/kernels/gpu/activation_kernel.cu b/paddle/phi/kernels/gpu/activation_kernel.cu
@@ -110,7 +110,6 @@ DEFINE_GPU_ACTIVATION_KERNEL(Rsqrt, CudaRsqrtFunctor)
 DEFINE_GPU_ACTIVATION_KERNEL(Softsign, CudaSoftsignFunctor)
 DEFINE_GPU_ACTIVATION_KERNEL(Sigmoid, CudaSigmoidFunctor)
 DEFINE_GPU_ACTIVATION_KERNEL(LogSigmoid, CudaLogSigmoidFunctor)
-DEFINE_GPU_ACTIVATION_KERNEL(Round, CudaRoundFunctor)
 DEFINE_GPU_ACTIVATION_KERNEL(Floor, CudaFloorFunctor)
 DEFINE_GPU_ACTIVATION_KERNEL(Ceil, CudaCeilFunctor)
 
@@ -187,6 +186,19 @@ void Relu6Kernel(const Context& dev_ctx,
   ActivationGPUImpl<T, Context, funcs::CudaRelu6Functor<T>>(
       dev_ctx, x, out, functor);
 }
+
+template <typename T, typename Context>
+void RoundKernel(const Context& dev_ctx,
+                 const DenseTensor& x,
+                 const int decimals,
+                 DenseTensor* out) {
+  funcs::CudaRoundFunctor<T> functor;
+  auto attrs = functor.GetAttrs();
+  *(attrs[0].second) = decimals;
+  ActivationGPUImpl<T, Context, funcs::CudaRoundFunctor<T>>(
+      dev_ctx, x, out, functor);
+}
+
 }  // namespace phi
 
 #ifdef PADDLE_WITH_HIP
diff --git a/paddle/phi/kernels/onednn/activation_kernel.cc b/paddle/phi/kernels/onednn/activation_kernel.cc
@@ -21,7 +21,6 @@
 #include "paddle/phi/common/place.h"
 #include "paddle/phi/core/kernel_registry.h"
 #include "paddle/phi/kernels/funcs/activation_functor.h"
-
 namespace phi {
 
 #define DEFINE_ONEDNN_ACTIVATION_KERNEL(name, functor_class)            \
@@ -149,7 +148,30 @@ DEFINE_ONEDNN_ACTIVATION_KERNEL(Sqrt, SqrtOneDNNFunctor)
 DEFINE_ONEDNN_ACTIVATION_KERNEL(Tanh, TanhOneDNNFunctor)
 
 // round eltwise primitive doesn't support BF16, nor does it support grad
-DEFINE_ONEDNN_ACTIVATION_KERNEL(Round, RoundOneDNNFunctor)
+template <typename T, typename Context>
+void RoundKernel(const Context& dev_ctx,
+                 const DenseTensor& x,
+                 const int decimals,
+                 DenseTensor* out) {
+  float ten_pow_deciamls = std::pow(10, decimals);
+
+  DenseTensor out1;
+  DenseTensorMeta meta_out(x.dtype(), x.dims());
+  out1.set_meta(meta_out);
+  out1.set_lod(x.lod());
+  out1.set_mem_desc(x.mem_desc());
+  dev_ctx.template Alloc<T>(&out1);
+
+  for (int i = 0; i < x.numel(); i++) {
+    out1.data<T>()[i] = x.data<T>()[i] * ten_pow_deciamls;
+  }
+  RoundOneDNNFunctor<T> functor;
+  functor(dev_ctx, out1, 0, 0, out);
+
+  for (int i = 0; i < x.numel(); i++) {
+    out->data<T>()[i] = out->data<T>()[i] * (1 / ten_pow_deciamls);
+  }
+}
 
 DEFINE_ONEDNN_ACT_KERNEL_WITH_ONE_ATTRS(Elu, EluOneDNNFunctor, alpha)
 DEFINE_ONEDNN_ACT_KERNEL_WITH_ONE_ATTRS(LeakyRelu, ReluOneDNNFunctor, alpha)
diff --git a/paddle/phi/ops/yaml/backward.yaml b/paddle/phi/ops/yaml/backward.yaml
@@ -2609,7 +2609,7 @@
   no_need_buffer : x
 
 - backward_op : round_grad
-  forward : round(Tensor x) -> Tensor(out)
+  forward : round(Tensor x, int decimals = 0 ) -> Tensor(out)
   args : (Tensor out_grad)
   output : Tensor(x_grad)
   infer_meta :
diff --git a/paddle/phi/ops/yaml/op_version.yaml b/paddle/phi/ops/yaml/op_version.yaml
@@ -494,6 +494,14 @@
         - add_input : ShiftsTensor
           comment : The number of places by which the elements of the tensor are shifted.
 
+- op : round
+  version :
+    - checkpoint : Add a new attribute [deciamls] to round
+      action :
+        - add_attr : decimals
+          comment : The number of decimal places rounded
+          default : 0.0
+
 - op : softmax_with_cross_entropy
   version :
     - checkpoint : Add a new attribute [use_softmax]
diff --git a/paddle/phi/ops/yaml/ops.yaml b/paddle/phi/ops/yaml/ops.yaml
@@ -3788,10 +3788,11 @@
   interfaces : paddle::dialect::InferSymbolicShapeInterface
 
 - op : round
-  args : (Tensor x)
+  args : (Tensor x, int decimals = 0 )
   output : Tensor(out)
   infer_meta :
     func : UnchangedInferMeta
+    param : [x]
   kernel :
     func : round
   inplace : (x -> out)
diff --git a/python/paddle/tensor/ops.py b/python/paddle/tensor/ops.py
@@ -35,7 +35,6 @@
     'rsqrt_',
     'ceil_',
     'floor_',
-    'round_',
     'reciprocal_',
     'sigmoid_',
     'abs_',
@@ -687,7 +686,7 @@ def reciprocal(x: Tensor, name: str | None = None) -> Tensor:
         return out
 
 
-def round(x: Tensor, name: str | None = None) -> Tensor:
+def round(x: Tensor, decimals: int = 0, name: str | None = None) -> Tensor:
     """
 
     Round the values in the input to the nearest integer value.
@@ -704,6 +703,7 @@ def round(x: Tensor, name: str | None = None) -> Tensor:
 
     Args:
         x (Tensor): Input of Round operator, an N-D Tensor, with data type float32, float64 or float16.
+        decimals(int): Rounded decimal place (default: 0).
         name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`.
 
     Returns:
@@ -721,17 +721,31 @@ def round(x: Tensor, name: str | None = None) -> Tensor:
             [-1., -0.,  1.,  2.])
     """
     if in_dynamic_or_pir_mode():
-        return _C_ops.round(x)
+        return _C_ops.round(x, decimals)
     else:
         check_variable_and_dtype(
             x, 'x', ['float16', 'uint16', 'float32', 'float64'], 'round'
         )
         helper = LayerHelper('round', **locals())
+        attrs = {
+            'decimals': int(decimals),
+        }
         out = helper.create_variable_for_type_inference(dtype=x.dtype)
-        helper.append_op(type='round', inputs={"X": x}, outputs={"Out": out})
+        helper.append_op(
+            type='round', inputs={"X": x}, outputs={"Out": out}, attrs=attrs
+        )
         return out
 
 
+@inplace_apis_in_dygraph_only
+def round_(x, decimals=0, name=None):
+    r"""
+    Inplace version of ``round`` API, the output Tensor will be inplaced with input ``x``.
+    Please refer to :ref:`api_paddle_round`.
+    """
+    return _C_ops.round_(x, decimals)
+
+
 def rsqrt(x: Tensor, name: str | None = None) -> Tensor:
     """
     Rsqrt Activation Operator.
diff --git a/test/legacy_test/test_activation_op.py b/test/legacy_test/test_activation_op.py
@@ -2593,18 +2593,23 @@ def setUp(self):
         self.python_api = paddle.round
         self.init_dtype()
         self.init_shape()
+        self.init_decimals()
 
         np.random.seed(1024)
-        x = np.random.uniform(-1, 1, self.shape).astype(self.dtype)
-        out = np.round(x)
+        x = np.random.uniform(-1, 1, self.shape).astype(self.dtype) * 100
+        out = np.round(x, decimals=self.decimals)
 
         self.inputs = {'X': OpTest.np_dtype_to_base_dtype(x)}
         self.outputs = {'Out': out}
+        self.attrs = {'decimals': self.decimals}
         self.convert_input_output()
 
     def init_shape(self):
         self.shape = [10, 12]
 
+    def init_decimals(self):
+        self.decimals = 0
+
     def test_check_output(self):
         self.check_output(
             check_pir=True, check_pir_onednn=self.check_pir_onednn
@@ -2619,6 +2624,33 @@ def init_shape(self):
         self.shape = []
 
 
+class TestRound_decimals1(TestRound):
+    def init_decimals(self):
+        self.decimals = 2
+
+    def test_round_api(self):
+        with dynamic_guard():
+            for device in devices:
+                if device == 'cpu' or (
+                    device == 'gpu' and paddle.is_compiled_with_cuda()
+                ):
+                    x_np = (
+                        np.random.uniform(-1, 1, self.shape).astype(self.dtype)
+                        * 100
+                    )
+                    out_expect = np.round(x_np, decimals=self.decimals)
+                    x_paddle = paddle.to_tensor(
+                        x_np, dtype=self.dtype, place=device
+                    )
+                    y = paddle.round(x_paddle, decimals=self.decimals)
+                    np.testing.assert_allclose(y.numpy(), out_expect, rtol=1e-3)
+
+
+class TestRound_decimals2(TestRound_decimals1):
+    def init_decimals(self):
+        self.decimals = -1
+
+
 class TestRelu(TestActivation):
     def setUp(self):
         self.op_type = "relu"
