support auto generate for huber_loss (#51951)

* fix huber_loss

* fix

* fix ops.yaml add intermediate

* fix

* fix test

paddle/fluid/operators/huber_loss_op.cc

-/* Copyright (c) 2016 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 <memory>
-#include <string>
-#include <vector>
-
-#include "paddle/fluid/framework/infershape_utils.h"
-#include "paddle/fluid/framework/op_registry.h"
-#include "paddle/phi/infermeta/binary.h"
-
-namespace paddle {
-namespace operators {
-
-class HuberLossOp : public framework::OperatorWithKernel {
- public:
-  using framework::OperatorWithKernel::OperatorWithKernel;
-};
-
-template <typename AttrType>
-class HuberLossOpMaker : public framework::OpProtoAndCheckerMaker {
- public:
-  void Make() override {
-    AddInput("X",
-             "The input value of huber loss op."
-             "X is a N-D tensor with shape [N_1, N_2,..., N_n].");
-    AddInput("Y",
-             "The target value of huber loss op."
-             "Y is a N-D tensor with shape [N_1, N_2,..., N_n].");
-    AddOutput("Residual",
-              "Intermediate tensor to cache residual value between Y and X."
-              "The shape is same as Input(X) and will be reused in backward.")
-        .AsIntermediate();
-    AddOutput("Out",
-              "The output N-D tensor with shape [N_1, N_2,..., N_n] "
-              "which represents the huber loss.");
-    AddAttr<AttrType>("delta", "Hyper parameter in huber loss.");
-    AddComment(R"DOC(
-HuberLoss Operator.
-
-Huber loss is a loss function used in robust regression. We define X as the
-input value and Y as the target value. Huber loss can evaluate the fitness of
-X to Y. Different from MSE loss, Huber loss is more robust for outliers. If the
-shape of X and Y are [batch_size, 1]. The equation is:
-
-$$
-Out_{\delta}(X, Y)_i =
-\begin{cases}
-0.5 * (Y_i - X_i)^2,
-\quad |Y_i - X_i| \leq \delta \\
-\delta * (|Y_i - X_i| - 0.5 * \delta),
-\quad otherwise
-\end{cases}
-$$
-
-In the above equation, $Out_\delta(X, Y)_i$, $X_i$ and $Y_i$ represent the ith
-element of Out, X and Y.
-
-)DOC");
-  }
-};
-
-class HuberLossGradOp : public framework::OperatorWithKernel {
- public:
-  using framework::OperatorWithKernel::OperatorWithKernel;
-
-  void InferShape(framework::InferShapeContext* ctx) const override {
-    OP_INOUT_CHECK(ctx->HasInputs(framework::GradVarName("Out")),
-                   "Input",
-                   "Out@GRAD",
-                   "HuberLossGrad");
-
-    auto residual_dims = ctx->GetInputDim("Residual");
-
-    auto x_grad_name = framework::GradVarName("X");
-    auto y_grad_name = framework::GradVarName("Y");
-    if (ctx->HasOutput(x_grad_name)) {
-      ctx->SetOutputDim(x_grad_name, residual_dims);
-    }
-    if (ctx->HasOutput(y_grad_name)) {
-      ctx->SetOutputDim(y_grad_name, residual_dims);
-    }
-  }
-};
-
-template <typename T>
-class HuberLossGradOpMaker : public framework::SingleGradOpMaker<T> {
- public:
-  using framework::SingleGradOpMaker<T>::SingleGradOpMaker;
-
- protected:
-  void Apply(GradOpPtr<T> op) const override {
-    op->SetType("huber_loss_grad");
-    op->SetInput("Residual", this->Output("Residual"));
-    op->SetInput(framework::GradVarName("Out"), this->OutputGrad("Out"));
-    op->SetOutput(framework::GradVarName("X"), this->InputGrad("X"));
-    op->SetOutput(framework::GradVarName("Y"), this->InputGrad("Y"));
-    op->SetAttrMap(this->Attrs());
-  }
-};
-
-}  // namespace operators
-}  // namespace paddle
-
-namespace ops = paddle::operators;
-DECLARE_INFER_SHAPE_FUNCTOR(huber_loss,
-                            HuberLossInferShapeFunctor,
-                            PD_INFER_META(phi::HuberLossInferMeta));
-
-REGISTER_OPERATOR(huber_loss,
-                  ops::HuberLossOp,
-                  ops::HuberLossOpMaker<float>,
-                  ops::HuberLossGradOpMaker<paddle::framework::OpDesc>,
-                  ops::HuberLossGradOpMaker<paddle::imperative::OpBase>,
-                  HuberLossInferShapeFunctor);
-REGISTER_OPERATOR(huber_loss_grad, ops::HuberLossGradOp);

paddle/phi/api/yaml/backward.yaml

@@ -680,6 +680,16 @@
     func : hardtanh_grad
   inplace : (out_grad -> x_grad)
 
+- backward_op : huber_loss_grad
+  forward : huber_loss (Tensor input, Tensor label, float delta) -> Tensor(out), Tensor(residual)
+  args : (Tensor residual, Tensor out_grad, float delta)
+  output : Tensor(input_grad), Tensor(label_grad)
+  infer_meta :
+    func : GeneralBinaryGradInferMeta
+    param : [residual, residual]
+  kernel :
+    func : huber_loss_grad
+
 - backward_op : imag_grad
   forward : imag (Tensor x) -> Tensor(out)
   args : (Tensor out_grad)

paddle/phi/api/yaml/legacy_backward.yaml

@@ -564,16 +564,6 @@
   kernel :
     func : hsigmoid_loss_grad
 
-- backward_op : huber_loss_grad
-  forward : huber_loss (Tensor input, Tensor label, float delta) -> Tensor(out), Tensor(residual)
-  args : (Tensor residual, Tensor out_grad, float delta)
-  output : Tensor(input_grad), Tensor(label_grad)
-  infer_meta :
-    func : GeneralBinaryGradInferMeta
-    param : [residual, residual]
-  kernel :
-    func : huber_loss_grad
-
 - backward_op : instance_norm_double_grad
   forward : instance_norm_grad(Tensor x, Tensor fwd_scale, Tensor saved_mean, Tensor saved_variance, Tensor grad_y, float epsilon) -> Tensor(grad_x), Tensor(grad_scale), Tensor(grad_bias)
   args : (Tensor x, Tensor fwd_scale, Tensor saved_mean, Tensor saved_variance, Tensor grad_y, Tensor grad_x_grad, Tensor grad_scale_grad, Tensor grad_bias_grad, float epsilon)

paddle/phi/api/yaml/legacy_ops.yaml

@@ -813,15 +813,6 @@
     data_type : x
   backward : hsigmoid_loss_grad
 
-- op : huber_loss
-  args : (Tensor input, Tensor label, float delta)
-  output : Tensor(out), Tensor(residual)
-  infer_meta :
-    func : HuberLossInferMeta
-  kernel :
-    func : huber_loss
-  backward : huber_loss_grad
-
 - op : increment
   args : (Tensor x, float value = 1.0)
   output : Tensor(out)

paddle/phi/api/yaml/op_compat.yaml

@@ -889,6 +889,13 @@
   outputs :
     out : Out
 
+- op : huber_loss
+  backward : huber_loss_grad
+  inputs :
+    {input : X, label : Y}
+  outputs :
+    {out : Out, residual : Residual}
+
 - op : imag
   backward : imag_grad
   inputs :

paddle/phi/api/yaml/ops.yaml

@@ -671,6 +671,16 @@
   kernel :
     func : histogram
 
+- op : huber_loss
+  args : (Tensor input, Tensor label, float delta)
+  output : Tensor(out), Tensor(residual)
+  infer_meta :
+    func : HuberLossInferMeta
+  kernel :
+    func : huber_loss
+  intermediate : residual
+  backward : huber_loss_grad
+
 - op : imag
   args : (Tensor x)
   output : Tensor (out)

paddle/phi/ops/compat/huber_loss_sig.cc

-// 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/core/compat/op_utils.h"
-
-namespace phi {
-
-KernelSignature HuberLossOpArgumentMapping(const ArgumentMappingContext& ctx) {
-  return KernelSignature(
-      "huber_loss", {"X", "Y"}, {"delta"}, {"Out", "Residual"});
-}
-
-KernelSignature HuberLossGradOpArgumentMapping(
-    const ArgumentMappingContext& ctx) {
-  return KernelSignature("huber_loss_grad",
-                         {"Residual", "Out@GRAD"},
-                         {"delta"},
-                         {"X@GRAD", "Y@GRAD"});
-}
-
-}  // namespace phi
-
-PD_REGISTER_ARG_MAPPING_FN(huber_loss, phi::HuberLossOpArgumentMapping);
-PD_REGISTER_ARG_MAPPING_FN(huber_loss_grad,
-                           phi::HuberLossGradOpArgumentMapping);

python/paddle/fluid/tests/unittests/test_huber_loss_op.py

@@ -29,8 +29,8 @@ def huber_loss_forward(val, delta):
 
 
 def huber_loss_wraper(x, y, delta):
-    a, b = paddle._C_ops.huber_loss(x, y, delta)
-    return a, b
+    a = paddle._C_ops.huber_loss(x, y, delta)
+    return a
 
 
 class TestHuberLossOp(OpTest):

python/paddle/nn/functional/loss.py

@@ -1104,7 +1104,7 @@ def smooth_l1_loss(input, label, reduction='mean', delta=1.0, name=None):
     """
 
     if in_dygraph_mode():
-        out, residual = _C_ops.huber_loss(input, label, delta)
+        out = _C_ops.huber_loss(input, label, delta)
     else:
         check_variable_and_dtype(
             input, 'input', ['float32', 'float64'], 'smooth_l1_loss'