regression_metric.hpp 9.11 KB
Newer Older
Guolin Ke's avatar
Guolin Ke committed
1
2
3
4
5
#ifndef LIGHTGBM_METRIC_REGRESSION_METRIC_HPP_
#define LIGHTGBM_METRIC_REGRESSION_METRIC_HPP_

#include <LightGBM/metric.h>

Guolin Ke's avatar
Guolin Ke committed
6
7
#include <LightGBM/utils/log.h>

Guolin Ke's avatar
Guolin Ke committed
8
9
10
11
12
13
14
15
16
17
#include <cmath>

namespace LightGBM {
/*!
* \brief Metric for regression task.
* Use static class "PointWiseLossCalculator" to calculate loss point-wise
*/
template<typename PointWiseLossCalculator>
class RegressionMetric: public Metric {
public:
Guolin Ke's avatar
Guolin Ke committed
18
  explicit RegressionMetric(const Config& config) :config_(config) {
Guolin Ke's avatar
Guolin Ke committed
19
20
21
22
23
24
  }

  virtual ~RegressionMetric() {

  }

Guolin Ke's avatar
Guolin Ke committed
25
  const std::vector<std::string>& GetName() const override {
26
    return name_;
27
28
  }

29
  double factor_to_bigger_better() const override {
30
    return -1.0f;
31
32
  }

Guolin Ke's avatar
Guolin Ke committed
33
34
  void Init(const Metadata& metadata, data_size_t num_data) override {
    name_.emplace_back(PointWiseLossCalculator::Name());
Guolin Ke's avatar
Guolin Ke committed
35
36
37
38
39
40
    num_data_ = num_data;
    // get label
    label_ = metadata.label();
    // get weights
    weights_ = metadata.weights();
    if (weights_ == nullptr) {
41
      sum_weights_ = static_cast<double>(num_data_);
Guolin Ke's avatar
Guolin Ke committed
42
43
44
45
46
47
    } else {
      sum_weights_ = 0.0f;
      for (data_size_t i = 0; i < num_data_; ++i) {
        sum_weights_ += weights_[i];
      }
    }
Guolin Ke's avatar
Guolin Ke committed
48
49
50
    for (data_size_t i = 0; i < num_data_; ++i) {
      PointWiseLossCalculator::CheckLabel(label_[i]);
    }
Guolin Ke's avatar
Guolin Ke committed
51
  }
52

Guolin Ke's avatar
Guolin Ke committed
53
  std::vector<double> Eval(const double* score, const ObjectiveFunction* objective) const override {
54
    double sum_loss = 0.0f;
55
56
57
58
59
    if (objective == nullptr) {
      if (weights_ == nullptr) {
        #pragma omp parallel for schedule(static) reduction(+:sum_loss)
        for (data_size_t i = 0; i < num_data_; ++i) {
          // add loss
60
          sum_loss += PointWiseLossCalculator::LossOnPoint(label_[i], score[i], config_);
61
62
63
64
65
        }
      } else {
        #pragma omp parallel for schedule(static) reduction(+:sum_loss)
        for (data_size_t i = 0; i < num_data_; ++i) {
          // add loss
66
          sum_loss += PointWiseLossCalculator::LossOnPoint(label_[i], score[i], config_) * weights_[i];
67
        }
Guolin Ke's avatar
Guolin Ke committed
68
      }
69
    } else {
70
71
72
73
      if (weights_ == nullptr) {
        #pragma omp parallel for schedule(static) reduction(+:sum_loss)
        for (data_size_t i = 0; i < num_data_; ++i) {
          // add loss
Guolin Ke's avatar
Guolin Ke committed
74
75
          double t = 0;
          objective->ConvertOutput(&score[i], &t);
76
          sum_loss += PointWiseLossCalculator::LossOnPoint(label_[i], t, config_);
77
78
79
80
81
        }
      } else {
        #pragma omp parallel for schedule(static) reduction(+:sum_loss)
        for (data_size_t i = 0; i < num_data_; ++i) {
          // add loss
Guolin Ke's avatar
Guolin Ke committed
82
83
          double t = 0;
          objective->ConvertOutput(&score[i], &t);
84
          sum_loss += PointWiseLossCalculator::LossOnPoint(label_[i], t, config_) * weights_[i];
85
        }
wxchan's avatar
wxchan committed
86
      }
Guolin Ke's avatar
Guolin Ke committed
87
    }
88
89
    double loss = PointWiseLossCalculator::AverageLoss(sum_loss, sum_weights_);
    return std::vector<double>(1, loss);
90

Guolin Ke's avatar
Guolin Ke committed
91
92
  }

93
  inline static double AverageLoss(double sum_loss, double sum_weights) {
Guolin Ke's avatar
Guolin Ke committed
94
95
    return sum_loss / sum_weights;
  }
Guolin Ke's avatar
Guolin Ke committed
96
97
98
99

  inline static void CheckLabel(label_t) {
  }

Guolin Ke's avatar
Guolin Ke committed
100
101
102
103
private:
  /*! \brief Number of data */
  data_size_t num_data_;
  /*! \brief Pointer of label */
104
  const label_t* label_;
Guolin Ke's avatar
Guolin Ke committed
105
  /*! \brief Pointer of weighs */
106
  const label_t* weights_;
Guolin Ke's avatar
Guolin Ke committed
107
  /*! \brief Sum weights */
108
  double sum_weights_;
Guolin Ke's avatar
Guolin Ke committed
109
  /*! \brief Name of this test set */
Guolin Ke's avatar
Guolin Ke committed
110
  Config config_;
111
  std::vector<std::string> name_;
Guolin Ke's avatar
Guolin Ke committed
112
113
};

114
115
116
/*! \brief RMSE loss for regression task */
class RMSEMetric: public RegressionMetric<RMSEMetric> {
public:
Guolin Ke's avatar
Guolin Ke committed
117
  explicit RMSEMetric(const Config& config) :RegressionMetric<RMSEMetric>(config) {}
118

Guolin Ke's avatar
Guolin Ke committed
119
  inline static double LossOnPoint(label_t label, double score, const Config&) {
120
121
122
123
124
125
126
127
128
129
130
131
132
    return (score - label)*(score - label);
  }

  inline static double AverageLoss(double sum_loss, double sum_weights) {
    // need sqrt the result for RMSE loss
    return std::sqrt(sum_loss / sum_weights);
  }

  inline static const char* Name() {
    return "rmse";
  }
};

Guolin Ke's avatar
Guolin Ke committed
133
134
135
/*! \brief L2 loss for regression task */
class L2Metric: public RegressionMetric<L2Metric> {
public:
Guolin Ke's avatar
Guolin Ke committed
136
  explicit L2Metric(const Config& config) :RegressionMetric<L2Metric>(config) {}
Guolin Ke's avatar
Guolin Ke committed
137

Guolin Ke's avatar
Guolin Ke committed
138
  inline static double LossOnPoint(label_t label, double score, const Config&) {
Guolin Ke's avatar
Guolin Ke committed
139
140
141
    return (score - label)*(score - label);
  }

142
143
144
145
146
147
148
149
  inline static const char* Name() {
    return "l2";
  }
};

/*! \brief L2 loss for regression task */
class QuantileMetric : public RegressionMetric<QuantileMetric> {
public:
Guolin Ke's avatar
Guolin Ke committed
150
  explicit QuantileMetric(const Config& config) :RegressionMetric<QuantileMetric>(config) {
151
152
  }

Guolin Ke's avatar
Guolin Ke committed
153
  inline static double LossOnPoint(label_t label, double score, const Config& config) {
154
155
156
157
158
159
    double delta = label - score;
    if (delta < 0) {
      return (config.alpha - 1.0f) * delta;
    } else {
      return config.alpha * delta;
    }
Guolin Ke's avatar
Guolin Ke committed
160
161
162
  }

  inline static const char* Name() {
163
    return "quantile";
Guolin Ke's avatar
Guolin Ke committed
164
165
166
  }
};

167

Guolin Ke's avatar
Guolin Ke committed
168
169
170
/*! \brief L1 loss for regression task */
class L1Metric: public RegressionMetric<L1Metric> {
public:
Guolin Ke's avatar
Guolin Ke committed
171
  explicit L1Metric(const Config& config) :RegressionMetric<L1Metric>(config) {}
Guolin Ke's avatar
Guolin Ke committed
172

Guolin Ke's avatar
Guolin Ke committed
173
  inline static double LossOnPoint(label_t label, double score, const Config&) {
Guolin Ke's avatar
Guolin Ke committed
174
175
176
    return std::fabs(score - label);
  }
  inline static const char* Name() {
177
    return "l1";
Guolin Ke's avatar
Guolin Ke committed
178
179
180
  }
};

Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
181
182
183
/*! \brief Huber loss for regression task */
class HuberLossMetric: public RegressionMetric<HuberLossMetric> {
public:
Guolin Ke's avatar
Guolin Ke committed
184
  explicit HuberLossMetric(const Config& config) :RegressionMetric<HuberLossMetric>(config) {
Guolin Ke's avatar
Guolin Ke committed
185
  }
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
186

Guolin Ke's avatar
Guolin Ke committed
187
  inline static double LossOnPoint(label_t label, double score, const Config& config) {
188
    const double diff = score - label;
189
    if (std::abs(diff) <= config.alpha) {
Guolin Ke's avatar
Guolin Ke committed
190
191
      return 0.5f * diff * diff;
    } else {
192
      return config.alpha * (std::abs(diff) - 0.5f * config.alpha);
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
193
    }
Guolin Ke's avatar
Guolin Ke committed
194
  }
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
195

Guolin Ke's avatar
Guolin Ke committed
196
197
198
  inline static const char* Name() {
    return "huber";
  }
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
199
200
};

Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
201
202
203
204
/*! \brief Fair loss for regression task */
// http://research.microsoft.com/en-us/um/people/zhang/INRIA/Publis/Tutorial-Estim/node24.html
class FairLossMetric: public RegressionMetric<FairLossMetric> {
public:
Guolin Ke's avatar
Guolin Ke committed
205
  explicit FairLossMetric(const Config& config) :RegressionMetric<FairLossMetric>(config) {
Guolin Ke's avatar
Guolin Ke committed
206
  }
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
207

Guolin Ke's avatar
Guolin Ke committed
208
  inline static double LossOnPoint(label_t label, double score, const Config& config) {
209
    const double x = std::fabs(score - label);
210
    const double c = config.fair_c;
Guolin Ke's avatar
Guolin Ke committed
211
212
    return c * x - c * c * std::log(1.0f + x / c);
  }
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
213

Guolin Ke's avatar
Guolin Ke committed
214
215
216
  inline static const char* Name() {
    return "fair";
  }
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
217
218
};

219
220
221
/*! \brief Poisson regression loss for regression task */
class PoissonMetric: public RegressionMetric<PoissonMetric> {
public:
Guolin Ke's avatar
Guolin Ke committed
222
  explicit PoissonMetric(const Config& config) :RegressionMetric<PoissonMetric>(config) {
223
224
  }

Guolin Ke's avatar
Guolin Ke committed
225
  inline static double LossOnPoint(label_t label, double score, const Config&) {
226
227
228
229
230
231
232
233
234
235
236
    const double eps = 1e-10f;
    if (score < eps) {
      score = eps;
    }
    return score - label * std::log(score);
  }
  inline static const char* Name() {
    return "poisson";
  }
};

237
238
239
240

/*! \brief Mape regression loss for regression task */
class MAPEMetric : public RegressionMetric<MAPEMetric> {
public:
Guolin Ke's avatar
Guolin Ke committed
241
  explicit MAPEMetric(const Config& config) :RegressionMetric<MAPEMetric>(config) {
242
243
  }

Guolin Ke's avatar
Guolin Ke committed
244
  inline static double LossOnPoint(label_t label, double score, const Config&) {
245
246
247
248
249
250
251
    return std::fabs((label - score)) / std::max(1.0f, std::fabs(label));
  }
  inline static const char* Name() {
    return "mape";
  }
};

Guolin Ke's avatar
Guolin Ke committed
252
253
class GammaMetric : public RegressionMetric<GammaMetric> {
public:
Guolin Ke's avatar
Guolin Ke committed
254
  explicit GammaMetric(const Config& config) :RegressionMetric<GammaMetric>(config) {
Guolin Ke's avatar
Guolin Ke committed
255
256
  }

Guolin Ke's avatar
Guolin Ke committed
257
  inline static double LossOnPoint(label_t label, double score, const Config&) {
Guolin Ke's avatar
Guolin Ke committed
258
259
260
    const double psi = 1.0;
    const double theta = -1.0 / score;
    const double a = psi;
Guolin Ke's avatar
Guolin Ke committed
261
262
    const double b = -Common::SafeLog(-theta);
    const double c = 1. / psi * Common::SafeLog(label / psi) - Common::SafeLog(label) - 0; // 0 = std::lgamma(1.0 / psi) = std::lgamma(1.0);
Guolin Ke's avatar
Guolin Ke committed
263
264
265
266
267
    return -((label * theta - b) / a + c);
  }
  inline static const char* Name() {
    return "gamma";
  }
Guolin Ke's avatar
Guolin Ke committed
268
269
270
271

  inline static void CheckLabel(label_t label) {
    CHECK(label > 0);
  }
Guolin Ke's avatar
Guolin Ke committed
272
273
274
275
276
};


class GammaDevianceMetric : public RegressionMetric<GammaDevianceMetric> {
public:
Guolin Ke's avatar
Guolin Ke committed
277
  explicit GammaDevianceMetric(const Config& config) :RegressionMetric<GammaDevianceMetric>(config) {
Guolin Ke's avatar
Guolin Ke committed
278
279
  }

Guolin Ke's avatar
Guolin Ke committed
280
  inline static double LossOnPoint(label_t label, double score, const Config&) {
Guolin Ke's avatar
Guolin Ke committed
281
282
    const double epsilon = 1.0e-9;
    const double tmp = label / (score + epsilon);
Guolin Ke's avatar
Guolin Ke committed
283
    return tmp - Common::SafeLog(tmp) - 1;
Guolin Ke's avatar
Guolin Ke committed
284
285
286
287
  }
  inline static const char* Name() {
    return "gamma-deviance";
  }
Guolin Ke's avatar
Guolin Ke committed
288
  inline static double AverageLoss(double sum_loss, double) {
Guolin Ke's avatar
Guolin Ke committed
289
290
    return sum_loss * 2;
  }
Guolin Ke's avatar
Guolin Ke committed
291
292
293
  inline static void CheckLabel(label_t label) {
    CHECK(label > 0);
  }
Guolin Ke's avatar
Guolin Ke committed
294
295
296
297
};

class TweedieMetric : public RegressionMetric<TweedieMetric> {
public:
Guolin Ke's avatar
Guolin Ke committed
298
  explicit TweedieMetric(const Config& config) :RegressionMetric<TweedieMetric>(config) {
Guolin Ke's avatar
Guolin Ke committed
299
300
  }

Guolin Ke's avatar
Guolin Ke committed
301
  inline static double LossOnPoint(label_t label, double score, const Config& config) {
Guolin Ke's avatar
Guolin Ke committed
302
    const double rho = config.tweedie_variance_power;
303
304
305
306
    const double eps = 1e-10f;
    if (score < eps) {
      score = eps;
    }
Guolin Ke's avatar
Guolin Ke committed
307
308
309
310
311
312
313
314
315
316
    const double a = label * std::exp((1 - rho) * std::log(score)) / (1 - rho);
    const double b = std::exp((2 - rho) * std::log(score)) / (2 - rho);
    return -a + b;
  }
  inline static const char* Name() {
    return "tweedie";
  }
};


Guolin Ke's avatar
Guolin Ke committed
317
}  // namespace LightGBM
Guolin Ke's avatar
Guolin Ke committed
318
#endif   // LightGBM_METRIC_REGRESSION_METRIC_HPP_