regression_objective.hpp 26.8 KB
Newer Older
Guolin Ke's avatar
Guolin Ke committed
1
2
3
#ifndef LIGHTGBM_OBJECTIVE_REGRESSION_OBJECTIVE_HPP_
#define LIGHTGBM_OBJECTIVE_REGRESSION_OBJECTIVE_HPP_

Guolin Ke's avatar
Guolin Ke committed
4
#include <LightGBM/objective_function.h>
5
6
#include <LightGBM/meta.h>

7
#include <LightGBM/utils/array_args.h>
Guolin Ke's avatar
Guolin Ke committed
8
9

namespace LightGBM {
10

11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
#define PercentileFun(T, data_reader, cnt_data, alpha) {\
  std::vector<T> ref_data(cnt_data);\
  for (data_size_t i = 0; i < cnt_data; ++i) {\
    ref_data[i] = data_reader(i);\
  }\
  const double float_pos = (1.0f - alpha) * cnt_data;\
  const data_size_t pos = static_cast<data_size_t>(float_pos);\
  if (pos < 1) {\
    return ref_data[ArrayArgs<T>::ArgMax(ref_data)];\
  } else if (pos >= cnt_data) {\
    return ref_data[ArrayArgs<T>::ArgMin(ref_data)];\
  } else {\
    const double bias = float_pos - pos;\
    if (pos > cnt_data / 2) {\
      ArrayArgs<T>::ArgMaxAtK(&ref_data, 0, cnt_data, pos - 1);\
      T v1 = ref_data[pos - 1];\
      T v2 = ref_data[pos + ArrayArgs<T>::ArgMax(ref_data.data() + pos, cnt_data - pos)];\
      return static_cast<T>(v1 - (v1 - v2) * bias);\
    } else {\
      ArrayArgs<T>::ArgMaxAtK(&ref_data, 0, cnt_data, pos);\
      T v2 = ref_data[pos];\
      T v1 = ref_data[ArrayArgs<T>::ArgMin(ref_data.data(), pos)];\
      return static_cast<T>(v1 - (v1 - v2) * bias);\
    }\
  }\
}\

#define WeightedPercentileFun(T, data_reader, weight_reader, cnt_data, alpha) {\
  std::vector<data_size_t> sorted_idx(cnt_data);\
  for (data_size_t i = 0; i < cnt_data; ++i) {\
    sorted_idx[i] = i;\
  }\
43
  std::stable_sort(sorted_idx.begin(), sorted_idx.end(), [=](data_size_t a, data_size_t b) {return data_reader(a) < data_reader(b); });\
44
45
46
47
48
49
50
  std::vector<double> weighted_cdf(cnt_data);\
  weighted_cdf[0] = weight_reader(sorted_idx[0]);\
  for (data_size_t i = 1; i < cnt_data; ++i) {\
    weighted_cdf[i] = weighted_cdf[i - 1] + weight_reader(sorted_idx[i]);\
  }\
  double threshold = weighted_cdf[cnt_data - 1] * alpha;\
  size_t pos = std::upper_bound(weighted_cdf.begin(), weighted_cdf.end(), threshold) - weighted_cdf.begin();\
Guolin Ke's avatar
Guolin Ke committed
51
  if (pos == 0 || pos ==  static_cast<size_t>(cnt_data - 1)) {\
52
    return data_reader(sorted_idx[pos]);\
53
54
55
56
57
58
59
60
  }\
  CHECK(threshold >= weighted_cdf[pos - 1]);\
  CHECK(threshold < weighted_cdf[pos]);\
  T v1 = data_reader(sorted_idx[pos - 1]);\
  T v2 = data_reader(sorted_idx[pos]);\
  return static_cast<T>((threshold - weighted_cdf[pos]) / (weighted_cdf[pos + 1] - weighted_cdf[pos]) * (v2 - v1) + v1);\
}\

Guolin Ke's avatar
Guolin Ke committed
61
/*!
62
* \brief Objective function for regression
Guolin Ke's avatar
Guolin Ke committed
63
64
65
*/
class RegressionL2loss: public ObjectiveFunction {
public:
Guolin Ke's avatar
Guolin Ke committed
66
  explicit RegressionL2loss(const Config& config) {
67
    sqrt_ = config.reg_sqrt;
Guolin Ke's avatar
Guolin Ke committed
68
69
  }

70
71
72
73
74
75
76
  explicit RegressionL2loss(const std::vector<std::string>& strs) {
    sqrt_ = false;
    for (auto str : strs) {
      if (str == std::string("sqrt")) {
        sqrt_ = true;
      }
    }
77
  }
78
  
Guolin Ke's avatar
Guolin Ke committed
79
80
81
82
83
84
  ~RegressionL2loss() {
  }

  void Init(const Metadata& metadata, data_size_t num_data) override {
    num_data_ = num_data;
    label_ = metadata.label();
85
86
    if (sqrt_) {
      trans_label_.resize(num_data_);
87
      #pragma omp parallel for schedule(static)
88
      for (data_size_t i = 0; i < num_data; ++i) {
89
        trans_label_[i] = Common::Sign(label_[i]) * std::sqrt(std::fabs(label_[i]));
90
91
92
      }
      label_ = trans_label_.data();
    }
Guolin Ke's avatar
Guolin Ke committed
93
94
95
    weights_ = metadata.weights();
  }

96
97
  void GetGradients(const double* score, score_t* gradients,
                    score_t* hessians) const override {
Guolin Ke's avatar
Guolin Ke committed
98
    if (weights_ == nullptr) {
99
      #pragma omp parallel for schedule(static)
Guolin Ke's avatar
Guolin Ke committed
100
      for (data_size_t i = 0; i < num_data_; ++i) {
101
        gradients[i] = static_cast<score_t>(score[i] - label_[i]);
102
        hessians[i] = 1.0f;
Guolin Ke's avatar
Guolin Ke committed
103
104
      }
    } else {
105
      #pragma omp parallel for schedule(static)
Guolin Ke's avatar
Guolin Ke committed
106
      for (data_size_t i = 0; i < num_data_; ++i) {
107
108
        gradients[i] = static_cast<score_t>((score[i] - label_[i]) * weights_[i]);
        hessians[i] = static_cast<score_t>(weights_[i]);
Guolin Ke's avatar
Guolin Ke committed
109
110
111
112
      }
    }
  }

Guolin Ke's avatar
Guolin Ke committed
113
114
  const char* GetName() const override {
    return "regression";
Guolin Ke's avatar
Guolin Ke committed
115
116
  }

117
118
  void ConvertOutput(const double* input, double* output) const override {
    if (sqrt_) {
119
      output[0] = Common::Sign(input[0]) * input[0] * input[0];
120
121
122
123
124
    } else {
      output[0] = input[0];
    }
  }

125
126
127
  std::string ToString() const override {
    std::stringstream str_buf;
    str_buf << GetName();
128
129
130
    if (sqrt_) {
      str_buf << " sqrt";
    }
131
132
133
    return str_buf.str();
  }

134
135
136
137
138
139
140
141
  bool IsConstantHessian() const override {
    if (weights_ == nullptr) {
      return true;
    } else {
      return false;
    }
  }

142
  double BoostFromScore(int) const override {
143
144
145
146
147
148
149
150
    double suml = 0.0f;
    double sumw = 0.0f;
    if (weights_ != nullptr) {
      #pragma omp parallel for schedule(static) reduction(+:suml,sumw)
      for (data_size_t i = 0; i < num_data_; ++i) {
        suml += label_[i] * weights_[i];
        sumw += weights_[i];
      }
151
    } else {
152
153
154
155
156
      sumw = static_cast<double>(num_data_);
      #pragma omp parallel for schedule(static) reduction(+:suml)
      for (data_size_t i = 0; i < num_data_; ++i) {
        suml += label_[i];
      }
157
    }
158
    return suml / sumw;
159
  }
160

161
162
protected:
  bool sqrt_;
Guolin Ke's avatar
Guolin Ke committed
163
164
165
  /*! \brief Number of data */
  data_size_t num_data_;
  /*! \brief Pointer of label */
166
  const label_t* label_;
Guolin Ke's avatar
Guolin Ke committed
167
  /*! \brief Pointer of weights */
168
169
  const label_t* weights_;
  std::vector<label_t> trans_label_;
Guolin Ke's avatar
Guolin Ke committed
170
171
};

Guolin Ke's avatar
Guolin Ke committed
172
173
174
/*!
* \brief L1 regression loss
*/
175
class RegressionL1loss: public RegressionL2loss {
176
public:
Guolin Ke's avatar
Guolin Ke committed
177
  explicit RegressionL1loss(const Config& config): RegressionL2loss(config) {
178
  }
179

180
  explicit RegressionL1loss(const std::vector<std::string>& strs): RegressionL2loss(strs) {
181
182
  }

183
184
  ~RegressionL1loss() {}

185
186
  void GetGradients(const double* score, score_t* gradients,
                    score_t* hessians) const override {
187
    if (weights_ == nullptr) {
188
      #pragma omp parallel for schedule(static)
189
      for (data_size_t i = 0; i < num_data_; ++i) {
190
        const double diff = score[i] - label_[i];
191
192
        gradients[i] = static_cast<score_t>(Common::Sign(diff));
        hessians[i] = 1.0f;
193
194
      }
    } else {
195
      #pragma omp parallel for schedule(static)
196
      for (data_size_t i = 0; i < num_data_; ++i) {
197
        const double diff = score[i] - label_[i];
198
199
        gradients[i] = static_cast<score_t>(Common::Sign(diff) * weights_[i]);
        hessians[i] = weights_[i];
200
201
202
203
      }
    }
  }

204
  double BoostFromScore(int) const override {
205
206
207
208
209
210
211
212
213
214
215
216
    const double alpha = 0.5;
    if (weights_ != nullptr) {
      #define data_reader(i) (label_[i])
      #define weight_reader(i) (weights_[i])
      WeightedPercentileFun(label_t, data_reader, weight_reader, num_data_, alpha);
      #undef data_reader
      #undef weight_reader
    } else {
      #define data_reader(i) (label_[i])
      PercentileFun(label_t, data_reader, num_data_, alpha);
      #undef data_reader
    }
217
218
  }

219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
  bool IsRenewTreeOutput() const override { return true; }

  double RenewTreeOutput(double, const double* pred, 
                         const data_size_t* index_mapper,
                         const data_size_t* bagging_mapper,
                         data_size_t num_data_in_leaf) const override {
    const double alpha = 0.5;
    if (weights_ == nullptr) {
      if (bagging_mapper == nullptr) {
        #define data_reader(i) (label_[index_mapper[i]] - pred[index_mapper[i]])
        PercentileFun(double, data_reader, num_data_in_leaf, alpha);
        #undef data_reader
      } else {
        #define data_reader(i) (label_[bagging_mapper[index_mapper[i]]] - pred[bagging_mapper[index_mapper[i]]])
        PercentileFun(double, data_reader, num_data_in_leaf, alpha);
        #undef data_reader
      }
    } else {
      if (bagging_mapper == nullptr) {
        #define data_reader(i) (label_[index_mapper[i]] - pred[index_mapper[i]])
        #define weight_reader(i) (weights_[index_mapper[i]])
        WeightedPercentileFun(double, data_reader, weight_reader, num_data_in_leaf, alpha);
        #undef data_reader
        #undef weight_reader
      } else {
        #define data_reader(i) (label_[bagging_mapper[index_mapper[i]]] - pred[bagging_mapper[index_mapper[i]]])
        #define weight_reader(i) (weights_[bagging_mapper[index_mapper[i]]])
        WeightedPercentileFun(double, data_reader, weight_reader, num_data_in_leaf, alpha);
        #undef data_reader
        #undef weight_reader
      }
    }
251
252
  }

Guolin Ke's avatar
Guolin Ke committed
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
  double RenewTreeOutput(double, double pred, 
                         const data_size_t* index_mapper,
                         const data_size_t* bagging_mapper,
                         data_size_t num_data_in_leaf) const override {
    const double alpha = 0.5;
    if (weights_ == nullptr) {
      if (bagging_mapper == nullptr) {
        #define data_reader(i) (label_[index_mapper[i]] - pred)
        PercentileFun(double, data_reader, num_data_in_leaf, alpha);
        #undef data_reader
      } else {
        #define data_reader(i) (label_[bagging_mapper[index_mapper[i]]] - pred)
        PercentileFun(double, data_reader, num_data_in_leaf, alpha);
        #undef data_reader
      }
    } else {
      if (bagging_mapper == nullptr) {
        #define data_reader(i) (label_[index_mapper[i]] - pred)
        #define weight_reader(i) (weights_[index_mapper[i]])
        WeightedPercentileFun(double, data_reader, weight_reader, num_data_in_leaf, alpha);
        #undef data_reader
        #undef weight_reader
      } else {
        #define data_reader(i) (label_[bagging_mapper[index_mapper[i]]] - pred)
        #define weight_reader(i) (weights_[bagging_mapper[index_mapper[i]]])
        WeightedPercentileFun(double, data_reader, weight_reader, num_data_in_leaf, alpha);
        #undef data_reader
        #undef weight_reader
      }
    }
  }

285
286
287
  const char* GetName() const override {
    return "regression_l1";
  }
288
289
};

Guolin Ke's avatar
Guolin Ke committed
290
291
292
/*!
* \brief Huber regression loss
*/
293
class RegressionHuberLoss: public RegressionL2loss {
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
294
public:
Guolin Ke's avatar
Guolin Ke committed
295
  explicit RegressionHuberLoss(const Config& config): RegressionL2loss(config) {
296
    alpha_ = static_cast<double>(config.alpha);
Guolin Ke's avatar
Guolin Ke committed
297
298
299
300
    if (sqrt_) {
      Log::Warning("Cannot use sqrt transform in %s Regression, will auto disable it", GetName());
      sqrt_ = false;
    }
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
301
302
  }

303
  explicit RegressionHuberLoss(const std::vector<std::string>& strs): RegressionL2loss(strs) {
Guolin Ke's avatar
Guolin Ke committed
304
305
306
307
    if (sqrt_) {
      Log::Warning("Cannot use sqrt transform in %s Regression, will auto disable it", GetName());
      sqrt_ = false;
    }
308
309
  }

Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
310
  ~RegressionHuberLoss() {
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
311
312
  }

313
314
  void GetGradients(const double* score, score_t* gradients,
                    score_t* hessians) const override {
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
315
    if (weights_ == nullptr) {
316
      #pragma omp parallel for schedule(static)
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
317
      for (data_size_t i = 0; i < num_data_; ++i) {
318
        const double diff = score[i] - label_[i];
319
        if (std::abs(diff) <= alpha_) {
320
          gradients[i] = static_cast<score_t>(diff);
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
321
        } else {
322
          gradients[i] = static_cast<score_t>(Common::Sign(diff) * alpha_);
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
323
        }
324
        hessians[i] = 1.0f;
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
325
326
      }
    } else {
327
      #pragma omp parallel for schedule(static)
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
328
      for (data_size_t i = 0; i < num_data_; ++i) {
329
        const double diff = score[i] - label_[i];
330
        if (std::abs(diff) <= alpha_) {
331
          gradients[i] = static_cast<score_t>(diff * weights_[i]);
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
332
        } else {
333
          gradients[i] = static_cast<score_t>(Common::Sign(diff) * weights_[i] * alpha_);
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
334
        }
335
        hessians[i] = static_cast<score_t>(weights_[i]);
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
336
337
338
339
340
341
342
343
      }
    }
  }

  const char* GetName() const override {
    return "huber";
  }

344
345
  bool IsConstantHessian() const override {
    return false;
346
347
  }

Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
348
349
private:
  /*! \brief delta for Huber loss */
350
  double alpha_;
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
351
352
};

Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
353
354

// http://research.microsoft.com/en-us/um/people/zhang/INRIA/Publis/Tutorial-Estim/node24.html
355
class RegressionFairLoss: public RegressionL2loss {
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
356
public:
Guolin Ke's avatar
Guolin Ke committed
357
  explicit RegressionFairLoss(const Config& config): RegressionL2loss(config) {
358
    c_ = static_cast<double>(config.fair_c);
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
359
360
  }

361
  explicit RegressionFairLoss(const std::vector<std::string>& strs): RegressionL2loss(strs) {
362
363
364

  }

Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
365
366
  ~RegressionFairLoss() {}

367
368
  void GetGradients(const double* score, score_t* gradients,
                    score_t* hessians) const override {
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
369
    if (weights_ == nullptr) {
370
      #pragma omp parallel for schedule(static)
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
371
      for (data_size_t i = 0; i < num_data_; ++i) {
372
        const double x = score[i] - label_[i];
373
374
        gradients[i] = static_cast<score_t>(c_ * x / (std::fabs(x) + c_));
        hessians[i] = static_cast<score_t>(c_ * c_ / ((std::fabs(x) + c_) * (std::fabs(x) + c_)));
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
375
376
      }
    } else {
377
      #pragma omp parallel for schedule(static)
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
378
      for (data_size_t i = 0; i < num_data_; ++i) {
379
        const double x = score[i] - label_[i];
380
381
        gradients[i] = static_cast<score_t>(c_ * x / (std::fabs(x) + c_) * weights_[i]);
        hessians[i] = static_cast<score_t>(c_ * c_ / ((std::fabs(x) + c_) * (std::fabs(x) + c_)) * weights_[i]);
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
382
383
384
385
386
387
388
389
      }
    }
  }

  const char* GetName() const override {
    return "fair";
  }

390
391
  bool IsConstantHessian() const override {
    return false;
392
393
  }

Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
394
395
private:
  /*! \brief c for Fair loss */
396
  double c_;
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
397
398
};

399
400
401
402

/*!
* \brief Objective function for Poisson regression
*/
403
class RegressionPoissonLoss: public RegressionL2loss {
404
public:
Guolin Ke's avatar
Guolin Ke committed
405
  explicit RegressionPoissonLoss(const Config& config): RegressionL2loss(config) {
406
    max_delta_step_ = static_cast<double>(config.poisson_max_delta_step);
407
    if (sqrt_) {
408
      Log::Warning("Cannot use sqrt transform in %s Regression, will auto disable it", GetName());
409
410
      sqrt_ = false;
    }
411
412
  }

413
  explicit RegressionPoissonLoss(const std::vector<std::string>& strs): RegressionL2loss(strs) {
414
415
416

  }

417
418
419
  ~RegressionPoissonLoss() {}

  void Init(const Metadata& metadata, data_size_t num_data) override {
420
    if (sqrt_) {
421
      Log::Warning("Cannot use sqrt transform in %s Regression, will auto disable it", GetName());
422
423
      sqrt_ = false;
    }
424
    RegressionL2loss::Init(metadata, num_data);
425
    // Safety check of labels
426
    label_t miny;
427
    double sumy;
428
    Common::ObtainMinMaxSum(label_, num_data_, &miny, (label_t*)nullptr, &sumy);
429
    if (miny < 0.0f) {
430
      Log::Fatal("[%s]: at least one target label is negative", GetName());
431
432
    }
    if (sumy == 0.0f) {
433
      Log::Fatal("[%s]: sum of labels is zero", GetName());
434
    }
435
436
  }

437
438
439
440
441
442
443
444
445
  /* Parametrize with unbounded internal score "f"; then
   *  loss = exp(f) - label * f
   *  grad = exp(f) - label
   *  hess = exp(f)
   *
   * And the output is exp(f); so the associated metric get s=exp(f)
   * so that its loss = s - label * log(s); a little awkward maybe.
   *
   */
446
447
  void GetGradients(const double* score, score_t* gradients,
                    score_t* hessians) const override {
448
    if (weights_ == nullptr) {
449
      #pragma omp parallel for schedule(static)
450
      for (data_size_t i = 0; i < num_data_; ++i) {
451
452
        gradients[i] = static_cast<score_t>(std::exp(score[i]) - label_[i]);
        hessians[i] = static_cast<score_t>(std::exp(score[i] + max_delta_step_));
453
454
      }
    } else {
455
      #pragma omp parallel for schedule(static)
456
      for (data_size_t i = 0; i < num_data_; ++i) {
457
458
        gradients[i] = static_cast<score_t>((std::exp(score[i]) - label_[i]) * weights_[i]);
        hessians[i] = static_cast<score_t>(std::exp(score[i] + max_delta_step_) * weights_[i]);
459
460
461
462
      }
    }
  }

463
464
465
466
  void ConvertOutput(const double* input, double* output) const override {
    output[0] = std::exp(input[0]);
  }

467
468
469
470
  const char* GetName() const override {
    return "poisson";
  }

471
472
  double BoostFromScore(int) const override {
    return std::log(RegressionL2loss::BoostFromScore(0));
473
474
  }

475
476
477
478
  bool IsConstantHessian() const override {
    return false;
  }

479
480
481
482
483
private:
  /*! \brief used to safeguard optimization */
  double max_delta_step_;
};

484
485
class RegressionQuantileloss : public RegressionL2loss {
public:
Guolin Ke's avatar
Guolin Ke committed
486
  explicit RegressionQuantileloss(const Config& config): RegressionL2loss(config) {
487
    alpha_ = static_cast<score_t>(config.alpha);
Guolin Ke's avatar
Guolin Ke committed
488
    CHECK(alpha_ > 0 && alpha_ < 1);
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
  }

  explicit RegressionQuantileloss(const std::vector<std::string>& strs): RegressionL2loss(strs) {

  }

  ~RegressionQuantileloss() {}

  void GetGradients(const double* score, score_t* gradients,
                    score_t* hessians) const override {
    if (weights_ == nullptr) {
      #pragma omp parallel for schedule(static)
      for (data_size_t i = 0; i < num_data_; ++i) {
        score_t delta = static_cast<score_t>(score[i] - label_[i]);
        if (delta >= 0) {
          gradients[i] = (1.0f - alpha_);
        } else {
          gradients[i] = -alpha_;
        }
        hessians[i] = 1.0f;
      }
    } else {
      #pragma omp parallel for schedule(static)
      for (data_size_t i = 0; i < num_data_; ++i) {
        score_t delta = static_cast<score_t>(score[i] - label_[i]);
        if (delta >= 0) {
515
          gradients[i] = static_cast<score_t>((1.0f - alpha_) * weights_[i]);
516
        } else {
517
          gradients[i] = static_cast<score_t>(-alpha_ * weights_[i]);
518
        }
519
        hessians[i] = static_cast<score_t>(weights_[i]);
520
521
522
523
524
525
526
527
      }
    }
  }

  const char* GetName() const override {
    return "quantile";
  }

528
  double BoostFromScore(int) const override {
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
    if (weights_ != nullptr) {
      #define data_reader(i) (label_[i])
      #define weight_reader(i) (weights_[i])
      WeightedPercentileFun(label_t, data_reader, weight_reader, num_data_, alpha_);
      #undef data_reader
      #undef weight_reader
    } else {
      #define data_reader(i) (label_[i])
      PercentileFun(label_t, data_reader, num_data_, alpha_);
      #undef data_reader
    }
  }

  bool IsRenewTreeOutput() const override { return true; }

  double RenewTreeOutput(double, const double* pred,
                         const data_size_t* index_mapper,
                         const data_size_t* bagging_mapper,
                         data_size_t num_data_in_leaf) const override {
    if (weights_ == nullptr) {
      if (bagging_mapper == nullptr) {
        #define data_reader(i) (label_[index_mapper[i]] - pred[index_mapper[i]])
        PercentileFun(double, data_reader, num_data_in_leaf, alpha_);
        #undef data_reader
      } else {
        #define data_reader(i) (label_[bagging_mapper[index_mapper[i]]] - pred[bagging_mapper[index_mapper[i]]])
        PercentileFun(double, data_reader, num_data_in_leaf, alpha_);
        #undef data_reader
      }
    } else {
      if (bagging_mapper == nullptr) {
        #define data_reader(i) (label_[index_mapper[i]] - pred[index_mapper[i]])
        #define weight_reader(i) (weights_[index_mapper[i]])
        WeightedPercentileFun(double, data_reader, weight_reader, num_data_in_leaf, alpha_);
        #undef data_reader
        #undef weight_reader
      } else {
        #define data_reader(i) (label_[bagging_mapper[index_mapper[i]]] - pred[bagging_mapper[index_mapper[i]]])
        #define weight_reader(i) (weights_[bagging_mapper[index_mapper[i]]])
        WeightedPercentileFun(double, data_reader, weight_reader, num_data_in_leaf, alpha_);
        #undef data_reader
        #undef weight_reader
      }
    }
  }

Guolin Ke's avatar
Guolin Ke committed
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
  double RenewTreeOutput(double, double pred,
                         const data_size_t* index_mapper,
                         const data_size_t* bagging_mapper,
                         data_size_t num_data_in_leaf) const override {
    if (weights_ == nullptr) {
      if (bagging_mapper == nullptr) {
        #define data_reader(i) (label_[index_mapper[i]] - pred)
        PercentileFun(double, data_reader, num_data_in_leaf, alpha_);
        #undef data_reader
      } else {
        #define data_reader(i) (label_[bagging_mapper[index_mapper[i]]] - pred)
        PercentileFun(double, data_reader, num_data_in_leaf, alpha_);
        #undef data_reader
      }
    } else {
      if (bagging_mapper == nullptr) {
        #define data_reader(i) (label_[index_mapper[i]] - pred)
        #define weight_reader(i) (weights_[index_mapper[i]])
        WeightedPercentileFun(double, data_reader, weight_reader, num_data_in_leaf, alpha_);
        #undef data_reader
        #undef weight_reader
      } else {
        #define data_reader(i) (label_[bagging_mapper[index_mapper[i]]] - pred)
        #define weight_reader(i) (weights_[bagging_mapper[index_mapper[i]]])
        WeightedPercentileFun(double, data_reader, weight_reader, num_data_in_leaf, alpha_);
        #undef data_reader
        #undef weight_reader
      }
    }
  }

606
607
608
609
private:
  score_t alpha_;
};

610
611
612
613
614

/*!
* \brief Mape Regression Loss
*/
class RegressionMAPELOSS : public RegressionL1loss {
615
public:
Guolin Ke's avatar
Guolin Ke committed
616
  explicit RegressionMAPELOSS(const Config& config) : RegressionL1loss(config) {
617
618
  }

619
  explicit RegressionMAPELOSS(const std::vector<std::string>& strs) : RegressionL1loss(strs) {
620
621
622

  }

623
624
625
626
627
628
  ~RegressionMAPELOSS() {}

  void Init(const Metadata& metadata, data_size_t num_data) override {
    RegressionL2loss::Init(metadata, num_data);
    for (data_size_t i = 0; i < num_data_; ++i) {
      if (std::fabs(label_[i]) < 1) {
629
        Log::Warning("Met 'abs(label) < 1', will convert them to '1' in MAPE objective and metric");
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
        break;
      }
    }
    label_weight_.resize(num_data);
    if (weights_ == nullptr) {
      #pragma omp parallel for schedule(static)
      for (data_size_t i = 0; i < num_data_; ++i) {
        label_weight_[i] = 1.0f / std::max(1.0f, std::fabs(label_[i]));
      }
    } else {
      #pragma omp parallel for schedule(static)
      for (data_size_t i = 0; i < num_data_; ++i) {
        label_weight_[i] = 1.0f / std::max(1.0f, std::fabs(label_[i])) * weights_[i];
      }
    }
  }
646
647
648
649
650
651

  void GetGradients(const double* score, score_t* gradients,
                    score_t* hessians) const override {
    if (weights_ == nullptr) {
      #pragma omp parallel for schedule(static)
      for (data_size_t i = 0; i < num_data_; ++i) {
652
653
654
        const double diff = score[i] - label_[i];
        gradients[i] = static_cast<score_t>(Common::Sign(diff) * label_weight_[i]);
        hessians[i] = 1.0f;
655
656
657
658
      }
    } else {
      #pragma omp parallel for schedule(static)
      for (data_size_t i = 0; i < num_data_; ++i) {
659
660
661
        const double diff = score[i] - label_[i];
        gradients[i] = static_cast<score_t>(Common::Sign(diff) * label_weight_[i]);
        hessians[i] = weights_[i];
662
663
664
665
      }
    }
  }

666
  double BoostFromScore(int) const override {
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
    const double alpha = 0.5;
    #define data_reader(i) (label_[i])
    #define weight_reader(i) (label_weight_[i])
    WeightedPercentileFun(label_t, data_reader, weight_reader, num_data_, alpha);
    #undef data_reader
    #undef weight_reader
  }

  bool IsRenewTreeOutput() const override { return true; }

  double RenewTreeOutput(double, const double* pred,
                         const data_size_t* index_mapper,
                         const data_size_t* bagging_mapper,
                         data_size_t num_data_in_leaf) const override {
    const double alpha = 0.5;
    if (bagging_mapper == nullptr) {
      #define data_reader(i) (label_[index_mapper[i]] - pred[index_mapper[i]])
      #define weight_reader(i) (label_weight_[index_mapper[i]])
      WeightedPercentileFun(double, data_reader, weight_reader, num_data_in_leaf, alpha);
      #undef data_reader
      #undef weight_reader
    } else {
      #define data_reader(i) (label_[bagging_mapper[index_mapper[i]]] - pred[bagging_mapper[index_mapper[i]]])
      #define weight_reader(i) (label_weight_[bagging_mapper[index_mapper[i]]])
      WeightedPercentileFun(double, data_reader, weight_reader, num_data_in_leaf, alpha);
Guolin Ke's avatar
Guolin Ke committed
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
      #undef data_reader
      #undef weight_reader
    }
  }

  double RenewTreeOutput(double, double pred,
                         const data_size_t* index_mapper,
                         const data_size_t* bagging_mapper,
                         data_size_t num_data_in_leaf) const override {
    const double alpha = 0.5;
    if (bagging_mapper == nullptr) {
      #define data_reader(i) (label_[index_mapper[i]] - pred)
      #define weight_reader(i) (label_weight_[index_mapper[i]])
      WeightedPercentileFun(double, data_reader, weight_reader, num_data_in_leaf, alpha);
      #undef data_reader
      #undef weight_reader
    } else {
      #define data_reader(i) (label_[bagging_mapper[index_mapper[i]]] - pred)
      #define weight_reader(i) (label_weight_[bagging_mapper[index_mapper[i]]])
      WeightedPercentileFun(double, data_reader, weight_reader, num_data_in_leaf, alpha);
712
713
714
      #undef data_reader
      #undef weight_reader
    }
715
716
717
  }

  const char* GetName() const override {
718
719
720
721
722
    return "mape";
  }

  bool IsConstantHessian() const override {
    return true;
723
724
725
  }

private:
726
727
  std::vector<label_t> label_weight_;

728
729
};

Guolin Ke's avatar
Guolin Ke committed
730
731
732
733
734
735
736


/*!
* \brief Objective function for Gamma regression
*/
class RegressionGammaLoss : public RegressionPoissonLoss {
public:
Guolin Ke's avatar
Guolin Ke committed
737
  explicit RegressionGammaLoss(const Config& config) : RegressionPoissonLoss(config) {
Guolin Ke's avatar
Guolin Ke committed
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
  }

  explicit RegressionGammaLoss(const std::vector<std::string>& strs) : RegressionPoissonLoss(strs) {

  }

  ~RegressionGammaLoss() {}

  void GetGradients(const double* score, score_t* gradients,
                    score_t* hessians) const override {
    if (weights_ == nullptr) {
      #pragma omp parallel for schedule(static)
      for (data_size_t i = 0; i < num_data_; ++i) {
        gradients[i] = static_cast<score_t>(1.0 - label_[i] / std::exp(score[i]));
        hessians[i] = static_cast<score_t>(label_[i] / std::exp(score[i]));
      }
    } else {
      #pragma omp parallel for schedule(static)
      for (data_size_t i = 0; i < num_data_; ++i) {
        gradients[i] = static_cast<score_t>(1.0 - label_[i] / std::exp(score[i]) * weights_[i]);
        hessians[i] = static_cast<score_t>(label_[i] / std::exp(score[i]) * weights_[i]);
      }
    }
  }

  const char* GetName() const override {
    return "gamma";
  }
 
};

/*!
* \brief Objective function for Tweedie regression
*/
class RegressionTweedieLoss: public RegressionPoissonLoss {
public:
Guolin Ke's avatar
Guolin Ke committed
774
  explicit RegressionTweedieLoss(const Config& config) : RegressionPoissonLoss(config) {
Guolin Ke's avatar
Guolin Ke committed
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
    rho_ = config.tweedie_variance_power;
  }

  explicit RegressionTweedieLoss(const std::vector<std::string>& strs) : RegressionPoissonLoss(strs) {

  }

  ~RegressionTweedieLoss() {}

  void GetGradients(const double* score, score_t* gradients,
                    score_t* hessians) const override {
    if (weights_ == nullptr) {
      #pragma omp parallel for schedule(static)
      for (data_size_t i = 0; i < num_data_; ++i) {
        gradients[i] = static_cast<score_t>(-label_[i] * std::exp((1 - rho_) * score[i]) + std::exp((2 - rho_) * score[i]));
        hessians[i] = static_cast<score_t>(-label_[i] * (1 - rho_) * std::exp((1 - rho_) * score[i]) + 
          (2 - rho_) * std::exp((2 - rho_) * score[i]));
      }
    } else {
      #pragma omp parallel for schedule(static)
      for (data_size_t i = 0; i < num_data_; ++i) {
        gradients[i] = static_cast<score_t>((-label_[i] * std::exp((1 - rho_) * score[i]) + std::exp((2 - rho_) * score[i])) * weights_[i]);
        hessians[i] = static_cast<score_t>((-label_[i] * (1 - rho_) * std::exp((1 - rho_) * score[i]) +
          (2 - rho_) * std::exp((2 - rho_) * score[i])) * weights_[i]);
      }
    }
  }

  const char* GetName() const override {
    return "tweedie";
  }
private:
  double rho_;
};

810
811
812
#undef PercentileFun
#undef WeightedPercentileFun

Guolin Ke's avatar
Guolin Ke committed
813
}  // namespace LightGBM
Guolin Ke's avatar
Guolin Ke committed
814
#endif   // LightGBM_OBJECTIVE_REGRESSION_OBJECTIVE_HPP_