auc_op.h 7.0 KB
Newer Older
1
/* Copyright (c) 2016 PaddlePaddle Authors. All Rights Reserved.
T
typhoonzero 已提交
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
T
tangwei12 已提交
16

17 18
#include <string>
#include <vector>
Y
Yi Wang 已提交
19
#include "paddle/fluid/framework/op_registry.h"
T
typhoonzero 已提交
20 21 22 23 24 25

namespace paddle {
namespace operators {

using Tensor = framework::Tensor;

Q
QI JUN 已提交
26
template <typename DeviceContext, typename T>
T
typhoonzero 已提交
27
class AucKernel : public framework::OpKernel<T> {
T
typhoonzero 已提交
28
 public:
T
tangwei12 已提交
29 30 31 32 33
  void Compute(const framework::ExecutionContext &ctx) const override {
    auto *predict = ctx.Input<Tensor>("Predict");
    auto *label = ctx.Input<Tensor>("Label");

    int num_thresholds = ctx.Attr<int>("num_thresholds");
T
tangwei12 已提交
34
    int slide_steps = ctx.Attr<int>("slide_steps");
T
tangwei12 已提交
35

W
Wu Yi 已提交
36 37
    // Only use output var for now, make sure it's persistable and
    // not cleaned up for each batch.
38
    auto *auc_tensor = ctx.Output<Tensor>("AUC");
T
tangwei12 已提交
39 40
    auto *stat_pos = ctx.Output<Tensor>("StatPosOut");
    auto *stat_neg = ctx.Output<Tensor>("StatNegOut");
T
typhoonzero 已提交
41

T
tangwei12 已提交
42 43
    auto *origin_stat_pos = stat_pos->mutable_data<int64_t>(ctx.GetPlace());
    auto *origin_stat_neg = stat_neg->mutable_data<int64_t>(ctx.GetPlace());
44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72
    auto *auc_value = auc_tensor->mutable_data<double>(ctx.GetPlace());

    // Just for pass UT, since UT's input & output connot be set same var
    auto *stat_pos_in_tensor = ctx.Input<Tensor>("StatPos");
    auto *pos_in_data = stat_pos_in_tensor->data<int64_t>();
    auto *stat_neg_in_tensor = ctx.Input<Tensor>("StatNeg");
    auto *neg_in_data = stat_neg_in_tensor->data<int64_t>();
    if (stat_pos_in_tensor != stat_pos) {
      memcpy(origin_stat_pos, pos_in_data,
             ((1 + slide_steps) * (num_thresholds + 1) +
              (slide_steps > 0 ? 1 : 0)) *
                 sizeof(int64_t));
    }
    if (stat_neg_in_tensor != stat_neg) {
      memcpy(origin_stat_neg, neg_in_data,
             ((1 + slide_steps) * (num_thresholds + 1) +
              (slide_steps > 0 ? 1 : 0)) *
                 sizeof(int64_t));
    }
    statAuc(label, predict, num_thresholds, slide_steps, origin_stat_pos,
            origin_stat_neg);

    int sum_offset = slide_steps * (num_thresholds + 1);
    calcAuc(origin_stat_pos + sum_offset, origin_stat_neg + sum_offset,
            num_thresholds, auc_value);
    if (slide_steps) {
      origin_stat_pos[(slide_steps + 1) * (num_thresholds + 1)] += 1;
      origin_stat_neg[(slide_steps + 1) * (num_thresholds + 1)] += 1;
    }
T
tangwei12 已提交
73
  }
T
typhoonzero 已提交
74

T
tangwei12 已提交
75 76 77 78 79 80
 private:
  inline static double trapezoidArea(double X1, double X2, double Y1,
                                     double Y2) {
    return (X1 > X2 ? (X1 - X2) : (X2 - X1)) * (Y1 + Y2) / 2.0;
  }

T
tangwei12 已提交
81
  inline static void statAuc(const framework::Tensor *label,
T
tangwei12 已提交
82
                             const framework::Tensor *predict,
T
tangwei12 已提交
83
                             const int num_thresholds, const int slide_steps,
84 85
                             int64_t *origin_stat_pos,
                             int64_t *origin_stat_neg) {
Q
Qiao Longfei 已提交
86 87
    size_t batch_size = predict->dims()[0];
    size_t inference_width = predict->dims()[1];
T
tangwei12 已提交
88 89
    const T *inference_data = predict->data<T>();
    const auto *label_data = label->data<int64_t>();
90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130
    const int bucket_length = num_thresholds + 1;
    if (slide_steps == 0) {
      for (size_t i = 0; i < batch_size; i++) {
        // if predict_data[i] has dim of 2, then predict_data[i][1] is pos prob
        // if predict_data[i] has dim of 1, then predict_data[i][0] is pos prob
        auto predict_data =
            inference_data[i * inference_width + (inference_width - 1)];
        PADDLE_ENFORCE_LE(predict_data, 1,
                          platform::errors::PreconditionNotMet(
                              "The predict data must less or equal 1."));
        PADDLE_ENFORCE_GE(predict_data, 0,
                          platform::errors::PreconditionNotMet(
                              "The predict data must gather or equal 0."));

        uint32_t binIdx = static_cast<uint32_t>(predict_data * num_thresholds);
        if (label_data[i]) {
          origin_stat_pos[binIdx] += 1;
        } else {
          origin_stat_neg[binIdx] += 1;
        }
      }
      return;
    }
    // the last number of origin_stat_pos store the index should be used in
    // current step
    int cur_step_index =
        static_cast<int>(origin_stat_pos[(slide_steps + 1) * bucket_length]) %
        slide_steps;
    int cur_step_begin = cur_step_index * bucket_length;
    int sum_step_begin = slide_steps * bucket_length;
    for (int i = 0; i < bucket_length; ++i) {
      origin_stat_pos[sum_step_begin + i] -=
          origin_stat_pos[cur_step_begin + i];
      origin_stat_neg[sum_step_begin + i] -=
          origin_stat_neg[cur_step_begin + i];
    }

    std::memset(origin_stat_pos + cur_step_begin, 0,
                bucket_length * sizeof(int64_t));
    std::memset(origin_stat_neg + cur_step_begin, 0,
                bucket_length * sizeof(int64_t));
T
tangwei12 已提交
131 132

    for (size_t i = 0; i < batch_size; i++) {
133 134 135 136
      // if predict_data[i] has dim of 2, then predict_data[i][1] is pos prob
      // if predict_data[i] has dim of 1, then predict_data[i][0] is pos prob
      auto predict_data =
          inference_data[i * inference_width + (inference_width - 1)];
T
tangwei12 已提交
137
      PADDLE_ENFORCE_LE(predict_data, 1,
138 139
                        platform::errors::PreconditionNotMet(
                            "The predict data must less or equal 1."));
T
tangwei12 已提交
140
      PADDLE_ENFORCE_GE(predict_data, 0,
141 142
                        platform::errors::PreconditionNotMet(
                            "The predict data must gather or equal 0."));
T
tangwei12 已提交
143 144

      uint32_t binIdx = static_cast<uint32_t>(predict_data * num_thresholds);
T
tangwei12 已提交
145
      if (label_data[i]) {
146
        origin_stat_pos[cur_step_begin + binIdx] += 1;
T
tangwei12 已提交
147
      } else {
148
        origin_stat_neg[cur_step_begin + binIdx] += 1;
T
typhoonzero 已提交
149 150
      }
    }
151 152 153 154 155
    for (int i = 0; i < bucket_length; ++i) {
      origin_stat_pos[sum_step_begin + i] +=
          origin_stat_pos[cur_step_begin + i];
      origin_stat_neg[sum_step_begin + i] +=
          origin_stat_neg[cur_step_begin + i];
T
tangwei12 已提交
156 157 158
    }
  }

159 160
  inline static void calcAuc(const int64_t *stat_pos, const int64_t *stat_neg,
                             int num_thresholds, double *auc) {
T
tangwei12 已提交
161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176
    *auc = 0.0f;

    double totPos = 0.0;
    double totNeg = 0.0;
    double totPosPrev = 0.0;
    double totNegPrev = 0.0;

    int idx = num_thresholds;

    while (idx >= 0) {
      totPosPrev = totPos;
      totNegPrev = totNeg;
      totPos += stat_pos[idx];
      totNeg += stat_neg[idx];
      *auc += trapezoidArea(totNeg, totNegPrev, totPos, totPosPrev);
      --idx;
T
typhoonzero 已提交
177
    }
T
tangwei12 已提交
178 179 180

    if (totPos > 0.0 && totNeg > 0.0) {
      *auc = *auc / totPos / totNeg;
T
typhoonzero 已提交
181 182 183 184 185 186
    }
  }
};

}  // namespace operators
}  // namespace paddle