From f69d2c32ae823e3f9479c2abc1fa2684c13c8e05 Mon Sep 17 00:00:00 2001 From: pangyoki Date: Tue, 30 Aug 2022 18:27:37 +0800 Subject: [PATCH] [PHI] move huber_loss/huber_loss_grad xpu kernel to phi (#45521) * move huber_loss xpu kernel to phi, test=kunlun * fix, test=kunlun * fix paddle_enforce, test=kunlun --- paddle/fluid/operators/huber_loss_op_xpu.cc | 107 ------------------ .../phi/kernels/xpu/huber_loss_grad_kernel.cc | 52 +++++++++ paddle/phi/kernels/xpu/huber_loss_kernel.cc | 46 ++++++++ 3 files changed, 98 insertions(+), 107 deletions(-) delete mode 100644 paddle/fluid/operators/huber_loss_op_xpu.cc create mode 100644 paddle/phi/kernels/xpu/huber_loss_grad_kernel.cc create mode 100644 paddle/phi/kernels/xpu/huber_loss_kernel.cc diff --git a/paddle/fluid/operators/huber_loss_op_xpu.cc b/paddle/fluid/operators/huber_loss_op_xpu.cc deleted file mode 100644 index 3c53c9299a6..00000000000 --- a/paddle/fluid/operators/huber_loss_op_xpu.cc +++ /dev/null @@ -1,107 +0,0 @@ -/* Copyright (c) 2021 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. */ - -#ifdef PADDLE_WITH_XPU -#include "paddle/fluid/framework/op_registry.h" - -namespace paddle { -namespace operators { - -using Tensor = framework::Tensor; - -template -class HuberLossXPUKernel : public framework::OpKernel { - public: - void Compute(const framework::ExecutionContext& ctx) const override { - auto* in0 = ctx.Input("X"); - auto* in1 = ctx.Input("Y"); - auto* residual = ctx.Output("Residual"); - auto* out = ctx.Output("Out"); - auto delta = ctx.Attr("delta"); - - auto residual_data = residual->mutable_data(ctx.GetPlace()); - auto out_data = out->mutable_data(ctx.GetPlace()); - auto in0_data = in0->data(); - auto in1_data = in1->data(); - - auto& dev_ctx = - ctx.template device_context(); - int r = xpu::huber_loss(dev_ctx.x_context(), - in0_data, - in1_data, - residual_data, - out_data, - in0->numel(), - 1, - delta); - PADDLE_ENFORCE_EQ( - r, - XPU_SUCCESS, - platform::errors::External("XPU API(huber_loss) return wrong " - "value[%d %s]", - r, - XPUAPIErrorMsg[r])); - } -}; - -template -class HuberLossGradXPUKernel : public framework::OpKernel { - public: - void Compute(const framework::ExecutionContext& ctx) const override { - auto* residual = ctx.Input("Residual"); - auto* dout = ctx.Input(framework::GradVarName("Out")); - auto* dx = ctx.Output(framework::GradVarName("X")); - auto* dy = ctx.Output(framework::GradVarName("Y")); - auto delta = ctx.Attr("delta"); - - T* dx_data = nullptr; - T* dy_data = nullptr; - if (dx) { - dx_data = dx->mutable_data(ctx.GetPlace()); - } - if (dy) { - dy_data = dy->mutable_data(ctx.GetPlace()); - } - auto dout_data = dout->data(); - auto residual_data = residual->data(); - auto& dev_ctx = - ctx.template device_context(); - int r = xpu::huber_loss_grad(dev_ctx.x_context(), - residual_data, - dout_data, - dx_data, - dy_data, - dout->numel(), - 1, - delta); - PADDLE_ENFORCE_EQ( - r, - XPU_SUCCESS, - platform::errors::External("XPU API(huber_loss_grad) return wrong " - "value[%d %s]", - r, - XPUAPIErrorMsg[r])); - } -}; - -} // namespace operators -} // namespace paddle - -namespace ops = paddle::operators; -namespace plat = paddle::platform; - -REGISTER_OP_XPU_KERNEL(huber_loss, ops::HuberLossXPUKernel); -REGISTER_OP_XPU_KERNEL(huber_loss_grad, ops::HuberLossGradXPUKernel); - -#endif diff --git a/paddle/phi/kernels/xpu/huber_loss_grad_kernel.cc b/paddle/phi/kernels/xpu/huber_loss_grad_kernel.cc new file mode 100644 index 00000000000..2beb7d8533f --- /dev/null +++ b/paddle/phi/kernels/xpu/huber_loss_grad_kernel.cc @@ -0,0 +1,52 @@ +// 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/huber_loss_grad_kernel.h" + +#include "paddle/phi/backends/xpu/enforce_xpu.h" +#include "paddle/phi/core/kernel_registry.h" + +namespace phi { + +template +void HuberLossGradKernel(const Context& dev_ctx, + const DenseTensor& residual, + const DenseTensor& out_grad, + float delta, + DenseTensor* input_grad, + DenseTensor* label_grad) { + T* input_grad_data = nullptr; + T* label_grad_data = nullptr; + if (input_grad) { + input_grad_data = dev_ctx.template Alloc(input_grad); + } + if (label_grad) { + label_grad_data = dev_ctx.template Alloc(label_grad); + } + auto out_grad_data = out_grad.data(); + auto residual_data = residual.data(); + int r = xpu::huber_loss_grad(dev_ctx.x_context(), + residual_data, + out_grad_data, + input_grad_data, + label_grad_data, + out_grad.numel(), + 1, + delta); + PADDLE_ENFORCE_XDNN_SUCCESS(r, "huber_loss_grad"); +} +} // namespace phi + +PD_REGISTER_KERNEL( + huber_loss_grad, XPU, ALL_LAYOUT, phi::HuberLossGradKernel, float) {} diff --git a/paddle/phi/kernels/xpu/huber_loss_kernel.cc b/paddle/phi/kernels/xpu/huber_loss_kernel.cc new file mode 100644 index 00000000000..15812be66e9 --- /dev/null +++ b/paddle/phi/kernels/xpu/huber_loss_kernel.cc @@ -0,0 +1,46 @@ +// 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/huber_loss_kernel.h" + +#include "paddle/phi/backends/xpu/enforce_xpu.h" +#include "paddle/phi/core/kernel_registry.h" + +namespace phi { + +template +void HuberLossKernel(const Context& dev_ctx, + const DenseTensor& input, + const DenseTensor& label, + float delta, + DenseTensor* out, + DenseTensor* residual) { + auto residual_data = dev_ctx.template Alloc(residual); + auto out_data = dev_ctx.template Alloc(out); + auto in0_data = input.data(); + auto in1_data = label.data(); + + int r = xpu::huber_loss(dev_ctx.x_context(), + in0_data, + in1_data, + residual_data, + out_data, + input.numel(), + 1, + delta); + PADDLE_ENFORCE_XDNN_SUCCESS(r, "huber_loss"); +} +} // namespace phi + +PD_REGISTER_KERNEL(huber_loss, XPU, ALL_LAYOUT, phi::HuberLossKernel, float) {} -- GitLab