cross_entropy_op.h 3.1 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserve.

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
C
caoying03 已提交
16
#include "paddle/framework/eigen.h"
D
dongzhihong 已提交
17
#include "paddle/framework/op_registry.h"
18
#include "paddle/operators/math/cross_entropy.h"
Q
qijun 已提交
19
#include "paddle/operators/math/math_function.h"
20 21 22 23

namespace paddle {
namespace operators {

D
dongzhihong 已提交
24
using Tensor = framework::Tensor;
C
caoying03 已提交
25 26 27
template <typename T, int MajorType = Eigen::RowMajor,
          typename IndexType = Eigen::DenseIndex>
using EigenMatrix = framework::EigenMatrix<T, MajorType, IndexType>;
D
dongzhihong 已提交
28

29
template <typename T>
30
class CrossEntropyOpKernel : public framework::OpKernel<T> {
31
 public:
D
dongzhihong 已提交
32
  void Compute(const framework::ExecutionContext& ctx) const override {
33
    PADDLE_ENFORCE(platform::is_cpu_place(ctx.GetPlace()),
C
caoying03 已提交
34
                   "This kernel only runs on CPU.");
C
caoying03 已提交
35 36 37
    const Tensor* x = ctx.Input<Tensor>("X");
    const Tensor* labels = ctx.Input<Tensor>("Label");
    Tensor* y = ctx.Output<Tensor>("Y");
38
    y->mutable_data<T>(ctx.GetPlace());
C
caoying03 已提交
39

40
    math::CrossEntropyFunctor<platform::CPUPlace, T>()(
Q
qijun 已提交
41
        ctx.device_context(), y, x, labels, ctx.Attr<bool>("softLabel"));
42 43 44
  }
};

45
template <typename T>
46
class CrossEntropyGradientOpKernel : public framework::OpKernel<T> {
47
 public:
D
dongzhihong 已提交
48
  void Compute(const framework::ExecutionContext& ctx) const override {
49
    PADDLE_ENFORCE(platform::is_cpu_place(ctx.GetPlace()),
C
caoying03 已提交
50 51 52 53 54 55
                   "This kernel only runs on CPU.");
    const Tensor* x = ctx.Input<Tensor>("X");
    const Tensor* dy = ctx.Input<Tensor>(framework::GradVarName("Y"));
    const Tensor* label = ctx.Input<Tensor>("Label");
    Tensor* dx = ctx.Output<Tensor>(framework::GradVarName("X"));
    T* dx_data = dx->mutable_data<T>(ctx.GetPlace());
56

57
    int class_num = x->dims()[1];
C
caoying03 已提交
58 59 60 61 62 63 64 65 66
    if (ctx.Attr<bool>("softLabel")) {
      auto x_mat = EigenMatrix<T>::From(*x);
      auto dy_mat = EigenMatrix<T>::From(*dy);
      auto lbl_mat = EigenMatrix<T>::From(*label);
      auto dx_mat = EigenMatrix<T>::From(*dx);

      dx_mat.device(ctx.GetEigenDevice<platform::CPUPlace>()) =
          -(lbl_mat * dy_mat.broadcast(Eigen::DSizes<int, 2>(1, class_num)) /
            x_mat);
67
    } else {
C
caoying03 已提交
68 69 70 71 72
      int batch_size = x->dims()[0];
      const T* dy_data = dy->data<T>();
      const T* x_data = x->data<T>();
      const int* label_data = label->data<int>();

73 74
      math::SetConstant<platform::CPUPlace, T> functor;
      functor(ctx.device_context(), dx, 0);
C
caoying03 已提交
75

76 77 78 79 80
      for (int i = 0; i < batch_size; ++i) {
        PADDLE_ASSERT(label_data[i] >= 0 || label_data[i] < class_num);
        int index = i * class_num + label_data[i];
        dx_data[index] = -dy_data[i] / x_data[index];
      }
81 82 83 84 85 86
    }
  }
};

}  // namespace operators
}  // namespace paddle