cross_entropy_op.h 10.1 KB
Newer Older
1
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved.
Q
Qiao Longfei 已提交
2 3 4 5 6 7 8 9 10 11 12 13 14 15

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
Y
Yi Wang 已提交
16 17
#include "paddle/fluid/framework/eigen.h"
#include "paddle/fluid/framework/op_registry.h"
18
#include "paddle/fluid/platform/for_range.h"
19
#include "paddle/phi/kernels/funcs/cross_entropy.h"
20
#include "paddle/phi/kernels/funcs/math.h"
21
#include "paddle/phi/kernels/funcs/math_function.h"
Q
Qiao Longfei 已提交
22 23 24 25

namespace paddle {
namespace operators {

26
template <typename DeviceContext, typename T>
Y
Yu Yang 已提交
27
class CrossEntropyOpKernel : public framework::OpKernel<T> {
28
 public:
D
dongzhihong 已提交
29
  void Compute(const framework::ExecutionContext& ctx) const override {
30 31 32
    auto* x = ctx.Input<phi::DenseTensor>("X");
    auto* labels = ctx.Input<phi::DenseTensor>("Label");
    auto* y = ctx.Output<phi::DenseTensor>("Y");
33
    y->mutable_data<T>(ctx.GetPlace());
C
caoying03 已提交
34

35
    int rank = x->dims().size();
36
    auto label_dims = labels->dims();
37 38
    phi::DenseTensor x_2d = framework::ReshapeToMatrix(*x, rank - 1);
    phi::DenseTensor labels_2d, y_2d;
39 40
    if (label_dims.size() < rank) {
      labels_2d.ShareDataWith(*labels);
41
      labels_2d.Resize({phi::product(label_dims), 1});
42 43

      y_2d.ShareDataWith(*y);
44
      y_2d.Resize({phi::product(y->dims()), 1});
45 46 47 48 49

    } else {
      labels_2d = framework::ReshapeToMatrix(*labels, rank - 1);
      y_2d = framework::ReshapeToMatrix(*y, rank - 1);
    }
50

51
    int axis_dim = x->dims()[rank - 1];
52
    phi::funcs::CrossEntropyFunctor<DeviceContext, T>()(
53 54 55 56 57 58 59
        ctx.template device_context<DeviceContext>(),
        &y_2d,
        &x_2d,
        &labels_2d,
        ctx.Attr<bool>("soft_label"),
        ctx.Attr<int>("ignore_index"),
        axis_dim);
Y
Yan Chunwei 已提交
60 61 62
  }
};

63
template <typename T>
64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92
class XeSoftlabelGradFunctor {
 public:
  XeSoftlabelGradFunctor(T* dx,
                         const T* dy,     // NOLINT
                         const T* x,      // NOLINT
                         const T* label,  // NOLINT
                         size_t num_classes)
      : dx_(dx), dy_(dy), x_(x), label_(label), num_classes_(num_classes) {}

  HOSTDEVICE void operator()(size_t i) {
    auto row_ids = i / num_classes_;
    dx_[i] = -label_[i] * dy_[row_ids] / x_[i];
  }

 private:
  T* dx_;
  const T* dy_;
  const T* x_;
  const T* label_;
  size_t num_classes_;
};

template <typename T>
class XeGradFunctor {
 public:
  XeGradFunctor(T* dx,
                const T* dy,           // NOLINT
                const T* x,            // NOLINT
                const int64_t* label,  // NOLINT
93 94
                size_t num_classes,
                size_t ignore_index)
95 96 97 98 99 100
      : dx_(dx),
        dy_(dy),
        x_(x),
        label_(label),
        num_classes_(num_classes),
        ignore_index_(ignore_index) {}
101

Y
Yu Yang 已提交
102 103 104
  HOSTDEVICE void operator()(size_t sample_id) {
    auto x_is_true_offset = sample_id * num_classes_ + label_[sample_id];
    for (size_t x_offset = sample_id * num_classes_;
105 106
         x_offset < (sample_id + 1) * num_classes_;
         ++x_offset) {
C
chengduoZH 已提交
107 108 109 110
      dx_[x_offset] = (x_offset != x_is_true_offset ||
                       label_[sample_id] == static_cast<int64_t>(ignore_index_))
                          ? static_cast<T>(0)
                          : -dy_[sample_id] / x_[x_offset];
111 112 113 114 115 116 117 118 119
    }
  }

 private:
  T* dx_;
  const T* dy_;
  const T* x_;
  const int64_t* label_;
  size_t num_classes_;
120
  size_t ignore_index_;
121 122 123
};

template <typename DeviceContext, typename T>
Y
Yu Yang 已提交
124
class CrossEntropyGradientOpKernel : public framework::OpKernel<T> {
Y
Yan Chunwei 已提交
125
 public:
D
dongzhihong 已提交
126
  void Compute(const framework::ExecutionContext& ctx) const override {
127 128 129 130
    auto* x = ctx.Input<phi::DenseTensor>("X");
    auto* dy = ctx.Input<phi::DenseTensor>(framework::GradVarName("Y"));
    auto* label = ctx.Input<phi::DenseTensor>("Label");
    auto* dx = ctx.Output<phi::DenseTensor>(framework::GradVarName("X"));
131
    T* dx_data = dx->mutable_data<T>(ctx.GetPlace());
Y
Yan Chunwei 已提交
132

133 134 135 136
    // Following computation only depends on the last dimension size. So it's
    // unnecessary to convert tensors to 2-D views.
    int rank = x->dims().size();
    int64_t class_num = x->dims()[rank - 1];
137
    int64_t ignore_index = ctx.Attr<int>("ignore_index");
138
    if (ctx.Attr<bool>("soft_label")) {
139 140 141
      XeSoftlabelGradFunctor<T> functor(dx_data,
                                        dy->data<T>(),
                                        x->data<T>(),
142 143 144 145 146 147
                                        label->data<T>(),
                                        static_cast<size_t>(class_num));
      platform::ForRange<DeviceContext> for_range(
          ctx.template device_context<DeviceContext>(),
          static_cast<size_t>(dx->numel()));
      for_range(functor);
148
    } else {
149 150 151 152 153 154
      XeGradFunctor<T> functor(dx_data,
                               dy->data<T>(),
                               x->data<T>(),
                               label->data<int64_t>(),
                               static_cast<size_t>(class_num),
                               static_cast<size_t>(ignore_index));
155 156 157 158
      platform::ForRange<DeviceContext> for_range(
          ctx.template device_context<DeviceContext>(),
          static_cast<size_t>(dy->numel()));
      for_range(functor);
Q
Qiao Longfei 已提交
159 160 161 162
    }
  }
};

S
sneaxiy 已提交
163 164
template <typename T>
struct HardLabelCrossEntropyForwardFunctor {
165 166 167
  HardLabelCrossEntropyForwardFunctor(const T* x,
                                      T* y,
                                      T* match_x,
S
sneaxiy 已提交
168 169 170 171 172 173 174 175 176 177 178 179 180
                                      const int64_t* label,
                                      int64_t ignore_index,
                                      int64_t feature_size)
      : x_(x),
        y_(y),
        match_x_(match_x),
        label_(label),
        ignore_index_(ignore_index),
        feature_size_(feature_size) {}

  HOSTDEVICE void operator()(int64_t idx) const {
    auto label = label_[idx];
    if (label != ignore_index_) {
181 182
      // don't update to PADDLE_ENFORCE_GE and PADDLE_ENFORCE_LT cause
      // can't use platform::errors::InvalidArgument in HOSTDEVICE
183 184 185 186
      PADDLE_ENFORCE(label >= 0 && label < feature_size_,
                     "Variable value (label) of "
                     "OP(fluid.layers.cross_entropy) expected >= 0 "
                     "and < %ld, but got %ld. Please check label value.",
187 188
                     feature_size_,
                     label);
189

S
sneaxiy 已提交
190
      auto match_x = x_[idx * feature_size_ + label];
191
      y_[idx] = -phi::funcs::TolerableValue<T>()(phi::funcs::real_log(match_x));
S
sneaxiy 已提交
192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
      match_x_[idx] = match_x;
    } else {
      y_[idx] = 0;
      match_x_[idx] = 0;  // any value is ok
    }
  }

  const T* x_;
  T* y_;
  T* match_x_;
  const int64_t* label_;
  int64_t ignore_index_;
  int64_t feature_size_;
};

S
sneaxiy 已提交
207 208
template <typename T>
struct HardLabelCrossEntropyBackwardFunctor {
209 210 211
  HardLabelCrossEntropyBackwardFunctor(T* dx,
                                       const T* dy,
                                       const T* match_x,
S
sneaxiy 已提交
212 213 214 215 216
                                       const int64_t* label,
                                       int64_t ignore_index,
                                       int64_t feature_size)
      : dx_(dx),
        dy_(dy),
S
sneaxiy 已提交
217
        match_x_(match_x),
S
sneaxiy 已提交
218 219 220 221 222 223 224 225 226
        label_(label),
        ignore_index_(ignore_index),
        feature_size_(feature_size) {}

  HOSTDEVICE void operator()(int64_t idx) const {
    auto row_idx = idx / feature_size_;
    auto col_idx = idx % feature_size_;
    auto label = label_[row_idx];
    if (label == col_idx && label != ignore_index_) {
S
sneaxiy 已提交
227
      dx_[idx] = -dy_[row_idx] / match_x_[row_idx];
S
sneaxiy 已提交
228 229 230 231 232 233 234
    } else {
      dx_[idx] = 0;
    }
  }

  T* dx_;
  const T* dy_;
S
sneaxiy 已提交
235
  const T* match_x_;
S
sneaxiy 已提交
236 237 238 239 240 241 242 243 244
  const int64_t* label_;
  int64_t ignore_index_;
  int64_t feature_size_;
};

template <typename DeviceContext, typename T>
class CrossEntropyOpKernel2 : public framework::OpKernel<T> {
 public:
  void Compute(const framework::ExecutionContext& ctx) const override {
245 246 247 248
    auto* x = ctx.Input<phi::DenseTensor>("X");
    auto* label = ctx.Input<phi::DenseTensor>("Label");
    auto* y = ctx.Output<phi::DenseTensor>("Y");
    auto* match_x = ctx.Output<phi::DenseTensor>("MatchX");
S
sneaxiy 已提交
249 250 251

    auto& x_dims = x->dims();
    auto feature_size = x_dims[x_dims.size() - 1];
252
    auto batch_size = phi::product(x->dims()) / feature_size;
S
sneaxiy 已提交
253 254 255 256 257

    auto* p_x = x->data<T>();
    auto* p_label = label->data<int64_t>();
    auto* p_y = y->mutable_data<T>(ctx.GetPlace());
    auto* p_match_x = match_x->mutable_data<T>(ctx.GetPlace());
S
sneaxiy 已提交
258 259 260

    auto ignore_index = ctx.Attr<int>("ignore_index");

S
sneaxiy 已提交
261 262 263 264
    platform::ForRange<DeviceContext> for_range(
        ctx.template device_context<DeviceContext>(), batch_size);
    for_range(HardLabelCrossEntropyForwardFunctor<T>(
        p_x, p_y, p_match_x, p_label, ignore_index, feature_size));
S
sneaxiy 已提交
265 266 267 268 269 270 271
  }
};

template <typename DeviceContext, typename T>
class CrossEntropyGradientOpKernel2 : public framework::OpKernel<T> {
 public:
  void Compute(const framework::ExecutionContext& ctx) const override {
272 273 274 275
    auto* dx = ctx.Output<phi::DenseTensor>(framework::GradVarName("X"));
    auto* dy = ctx.Input<phi::DenseTensor>(framework::GradVarName("Y"));
    auto* match_x = ctx.Input<phi::DenseTensor>("MatchX");
    auto* label = ctx.Input<phi::DenseTensor>("Label");
S
sneaxiy 已提交
276 277 278

    auto* p_dx = dx->mutable_data<T>(ctx.GetPlace());
    auto* p_dy = dy->data<T>();
S
sneaxiy 已提交
279
    auto* p_match_x = match_x->data<T>();
S
sneaxiy 已提交
280 281 282 283 284
    auto* p_label = label->data<int64_t>();

    int64_t ignore_index = ctx.Attr<int>("ignore_index");
    int rank = dx->dims().size();
    int64_t feature_size = dx->dims()[rank - 1];
285
    int64_t batch_size = phi::product(dx->dims()) / feature_size;
S
sneaxiy 已提交
286 287 288 289 290

    platform::ForRange<DeviceContext> for_range(
        ctx.template device_context<DeviceContext>(),
        batch_size * feature_size);
    for_range(HardLabelCrossEntropyBackwardFunctor<T>(
S
sneaxiy 已提交
291
        p_dx, p_dy, p_match_x, p_label, ignore_index, feature_size));
S
sneaxiy 已提交
292 293 294
  }
};

Q
Qiao Longfei 已提交
295 296
}  // namespace operators
}  // namespace paddle