huber_loss_op.cc 4.8 KB
Newer Older
1
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved.
Y
yangyaming 已提交
2 3 4 5 6 7 8 9 10 11 12 13 14

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. */

Y
Yi Wang 已提交
15
#include "paddle/fluid/operators/huber_loss_op.h"
Y
yangyaming 已提交
16 17 18 19 20 21 22 23

namespace paddle {
namespace operators {

class HuberLossOp : public framework::OperatorWithKernel {
 public:
  using framework::OperatorWithKernel::OperatorWithKernel;

24 25 26
  void InferShape(framework::InferShapeContext* ctx) const override {
    PADDLE_ENFORCE(ctx->HasInput("X"), "Input(X) must be initialized.");
    PADDLE_ENFORCE(ctx->HasInput("Y"), "Input(Y) must be initialized.");
Y
yangyaming 已提交
27

28 29
    auto x_dims = ctx->GetInputDim("X");
    auto y_dims = ctx->GetInputDim("Y");
Y
yangyaming 已提交
30

31 32
    PADDLE_ENFORCE_EQ(x_dims, y_dims);
    PADDLE_ENFORCE_EQ(x_dims.size(), 2,
33 34
                      "The rank of Input(X) must be 2 and the shape is "
                      "[batch_size, 1].");
35
    PADDLE_ENFORCE_EQ(x_dims[1], 1,
36 37
                      "Each row of Input(X) contains a real value, "
                      "so the 2nd dimension of Input(X) must be 1.");
Y
yangyaming 已提交
38

39 40 41
    ctx->SetOutputDim("Residual", x_dims);
    ctx->SetOutputDim("Out", {x_dims[0], 1});
    ctx->ShareLoD("X", "Out");
Y
yangyaming 已提交
42 43 44 45 46 47
  }
};

template <typename AttrType>
class HuberLossOpMaker : public framework::OpProtoAndCheckerMaker {
 public:
Y
Yu Yang 已提交
48
  void Make() override {
49 50 51 52 53 54
    AddInput("X",
             "The input value of huber loss op."
             "X is a 2-D tensor with shape [batch_size, 1].");
    AddInput("Y",
             "The target value of huber loss op."
             "Y is a 2-D tensor with shape [batch_size, 1].");
55
    AddOutput("Residual",
56
              "Intermediate tensor to cache residual value between Y and X."
57
              "The shape is same as Input(X) and will be reused in backward.")
Y
yangyaming 已提交
58
        .AsIntermediate();
59
    AddOutput("Out",
K
kexinzhao 已提交
60 61
              "The output tensor with shape [batch_size, 1] "
              "which represents the huber loss.");
Y
yangyaming 已提交
62 63
    AddAttr<AttrType>("delta", "Hyper parameter in huber loss.");
    AddComment(R"DOC(
K
kexinzhao 已提交
64 65
HuberLoss Operator.

66 67 68 69
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. The
shape of X and Y are [batch_size, 1]. The equation is:
Y
yangyaming 已提交
70

71
$$
Y
yangyaming 已提交
72
Out_{\delta}(X, Y)_i =
73
\begin{cases}
Y
yangyaming 已提交
74 75 76
0.5 * (Y_i - X_i)^2,
\quad |Y_i - X_i| \leq \delta \\
\delta * (|Y_i - X_i| - 0.5 * \delta),
77
\quad otherwise
78
\end{cases}
79
$$
Y
yangyaming 已提交
80

Y
yangyaming 已提交
81 82 83
In the above equation, $Out_\delta(X, Y)_i$, $X_i$ and $Y_i$ represent the ith
element of Out, X and Y.

Y
yangyaming 已提交
84 85 86 87 88 89 90 91
)DOC");
  }
};

class HuberLossGradOp : public framework::OperatorWithKernel {
 public:
  using framework::OperatorWithKernel::OperatorWithKernel;

92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115
  void InferShape(framework::InferShapeContext* ctx) const override {
    PADDLE_ENFORCE(ctx->HasInput("X"), "Input(X) should not be null.");
    PADDLE_ENFORCE(ctx->HasInput("Y"), "Input(Y) should not be null.");
    PADDLE_ENFORCE(ctx->HasInput("Residual"),
                   "Input(Residual) should not be null.");
    PADDLE_ENFORCE(ctx->HasInput(framework::GradVarName("Out")),
                   "Input(Out@GRAD) should not be null.");

    auto x_dims = ctx->GetInputDim("X");
    auto y_dims = ctx->GetInputDim("Y");
    auto residual_dims = ctx->GetInputDim("Residual");
    auto out_grad_dims = ctx->GetInputDim(framework::GradVarName("Out"));

    PADDLE_ENFORCE_EQ(residual_dims, x_dims);
    PADDLE_ENFORCE_EQ(out_grad_dims, x_dims);

    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, x_dims);
    }
    if (ctx->HasOutput(y_grad_name)) {
      ctx->SetOutputDim(y_grad_name, y_dims);
    }
Y
yangyaming 已提交
116 117 118 119 120 121 122
  }
};

}  // namespace operators
}  // namespace paddle

namespace ops = paddle::operators;
Y
Yang Yang 已提交
123
REGISTER_OPERATOR(huber_loss, ops::HuberLossOp, ops::HuberLossOpMaker<float>,
124 125
                  paddle::framework::DefaultGradOpDescMaker<true>);
REGISTER_OPERATOR(huber_loss_grad, ops::HuberLossGradOp);
Q
QI JUN 已提交
126
REGISTER_OP_CPU_KERNEL(
127 128
    huber_loss, ops::HuberLossKernel<paddle::platform::CPUDeviceContext, float>,
    ops::HuberLossKernel<paddle::platform::CPUDeviceContext, double>);
Y
yangyaming 已提交
129 130
REGISTER_OP_CPU_KERNEL(
    huber_loss_grad,
131 132
    ops::HuberLossGradKernel<paddle::platform::CPUDeviceContext, float>,
    ops::HuberLossGradKernel<paddle::platform::CPUDeviceContext, double>);