[Phi] Move allclose op kernel into phi (#40469)

* move allclose kernel * remove allclose op kernel * fix coverage failed

Author: chenwhql

paddle/fluid/operators/allclose_op.cc

@@ -12,9 +12,9 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "paddle/fluid/operators/allclose_op.h"
 #include <cmath>
 #include <string>
+
 #include "paddle/fluid/framework/op_registry.h"
 #include "paddle/fluid/framework/op_version_registry.h"
 #include "paddle/fluid/framework/operator.h"
@@ -23,41 +23,6 @@
 namespace paddle {
 namespace operators {
 
-template <typename T>
-struct GetTensorValue<platform::CPUDeviceContext, T> {
- T operator()(const platform::CPUDeviceContext& dev_ctx,
- const framework::Tensor& tensor) const {
- return *(tensor.data<T>());
- }
-};
-
-template <typename T>
-struct AllcloseFunctor<platform::CPUDeviceContext, T> {
- void operator()(const platform::CPUDeviceContext& ctx,
- const framework::Tensor& in, const framework::Tensor& other,
- const double rtol, const double atol, bool equal_nan,
- framework::Tensor* output) {
- auto* in_a = in.data<T>();
- auto* in_b = other.data<T>();
- auto* out_data = output->mutable_data<bool>(ctx.GetPlace());
- auto num = in.numel();
- *out_data = true;
- for (int i = 0; i < num; i++) {
- const T a = in_a[i], b = in_b[i];
- bool val;
- if (std::isnan(a) || std::isnan(b)) {
- val = equal_nan && std::isnan(a) == std::isnan(b);
- } else {
- T left = (a > b ? a - b : b - a);
- T right = atol + (b > 0 ? rtol * b : (-rtol) * b);
- T diff = (left > right ? left - right : right - left);
- val = a == b || left <= right || diff <= 1e-15;
- }
- *out_data &= val;
- }
- }
-};
-
 class AllcloseOpMaker : public framework::OpProtoAndCheckerMaker {
  public:
  void Make() override {
@@ -157,8 +122,6 @@ REGISTER_OPERATOR(
  paddle::framework::EmptyGradOpMaker<paddle::framework::OpDesc>,
  paddle::framework::EmptyGradOpMaker<paddle::imperative::OpBase>,
  ops::AllcloseOpVarTypeInference);
-REGISTER_OP_CPU_KERNEL(allclose, ops::AllcloseKernel<CPU, float>,
- ops::AllcloseKernel<CPU, double>);
 
 /* ========================== register checkpoint ===========================*/
 REGISTER_OP_VERSION(allclose)

paddle/fluid/operators/allclose_op.cu

@@ -40,6 +40,13 @@ phi::Scalar MakePhiScalarFromVar(const framework::Variable& variable) {
  auto expected_place = phi::TransToPhiPlace(phi::Backend::CPU);
  if (variable.IsType<framework::LoDTensor>()) {
  const auto& tensor = variable.Get<framework::LoDTensor>();
+ PADDLE_ENFORCE_EQ(
+ tensor.numel(),
+ 1UL,
+ platform::errors::InvalidArgument("The DenseTensor used to construct "
+ "the Scalar contains more than 1 "
+ "value, it contains `%d` values.",
+ tensor.numel()));
  if (!platform::is_same_place(tensor.place(), expected_place)) {
  framework::LoDTensor tmp_tensor;
  framework::TensorCopySync(tensor, expected_place, &tmp_tensor);

paddle/fluid/operators/allclose_op.h

@@ -0,0 +1,31 @@
+// Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#include "paddle/phi/common/scalar.h"
+#include "paddle/phi/core/dense_tensor.h"
+
+namespace phi {
+
+template <typename T, typename Context>
+void AllCloseKernel(const Context& dev_ctx,
+ const DenseTensor& x,
+ const DenseTensor& y,
+ const Scalar& rtol,
+ const Scalar& atol,
+ bool equal_nan,
+ DenseTensor* out);
+
+} // namespace phi

paddle/phi/api/lib/utils/tensor_utils.cc

@@ -0,0 +1,71 @@
+// Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "paddle/phi/kernels/allclose_kernel.h"
+
+#include <cmath>
+
+#include "paddle/phi/core/enforce.h"
+#include "paddle/phi/core/kernel_registry.h"
+
+namespace phi {
+
+template <typename T, typename Context>
+void AllCloseKernel(const Context& dev_ctx,
+ const DenseTensor& x,
+ const DenseTensor& y,
+ const Scalar& rtol,
+ const Scalar& atol,
+ bool equal_nan,
+ DenseTensor* out) {
+ PADDLE_ENFORCE_EQ(
+ rtol.dtype(),
+ DataType::FLOAT64,
+ phi::errors::InvalidArgument(
+ "Input (Rtol) type must be double, but get %s.", rtol.dtype()));
+ PADDLE_ENFORCE_EQ(
+ atol.dtype(),
+ DataType::FLOAT64,
+ phi::errors::InvalidArgument(
+ "Input (Atol) type must be double, but get %s.", atol.dtype()));
+
+ auto* in_a = x.data<T>();
+ auto* in_b = y.data<T>();
+ auto rtol_v = rtol.to<double>();
+ auto atol_v = atol.to<double>();
+ auto* out_data = dev_ctx.template Alloc<bool>(out);
+ *out_data = true;
+
+ auto num = x.numel();
+ for (int64_t i = 0; i < num; ++i) {
+ const T a = in_a[i], b = in_b[i];
+ bool val;
+ if (std::isnan(a) || std::isnan(b)) {
+ val = equal_nan && std::isnan(a) == std::isnan(b);
+ } else {
+ T left = (a > b ? a - b : b - a);
+ T right = atol_v + (b > 0 ? rtol_v * b : (-rtol_v) * b);
+ T diff = (left > right ? left - right : right - left);
+ val = a == b || left <= right || diff <= 1e-15;
+ }
+ *out_data &= val;
+ }
+}
+
+} // namespace phi
+
+PD_REGISTER_KERNEL(
+ allclose, CPU, ALL_LAYOUT, phi::AllCloseKernel, float, double) {
+ kernel->OutputAt(0).SetDataType(phi::DataType::BOOL);
+}