feature_histogram.hpp 16 KB
Newer Older
Guolin Ke's avatar
Guolin Ke committed
1
2
3
4
#ifndef LIGHTGBM_TREELEARNER_FEATURE_HISTOGRAM_HPP_
#define LIGHTGBM_TREELEARNER_FEATURE_HISTOGRAM_HPP_

#include "split_info.hpp"
Guolin Ke's avatar
Guolin Ke committed
5
6
7

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

#include <cstring>

Guolin Ke's avatar
Guolin Ke committed
11
12
namespace LightGBM 
{
Guolin Ke's avatar
Guolin Ke committed
13

Guolin Ke's avatar
Guolin Ke committed
14
15
16
17
18
19
20
21
class FeatureMetainfo {
public:
  int feature_idx;
  int num_bin;
  int bias = 0;
  /*! \brief pointer of tree config */
  const TreeConfig* tree_config;
};
Guolin Ke's avatar
Guolin Ke committed
22
23
24
25
26
/*!
* \brief FeatureHistogram is used to construct and store a histogram for a feature.
*/
class FeatureHistogram {
public:
Guolin Ke's avatar
Guolin Ke committed
27
  FeatureHistogram() {
Guolin Ke's avatar
Guolin Ke committed
28
    data_ = nullptr;
Guolin Ke's avatar
Guolin Ke committed
29
  }
Guolin Ke's avatar
Guolin Ke committed
30

Guolin Ke's avatar
Guolin Ke committed
31
32
33
  ~FeatureHistogram() {
  }

Guolin Ke's avatar
Guolin Ke committed
34
35
36
37
38
  /*! \brief Disable copy */
  FeatureHistogram& operator=(const FeatureHistogram&) = delete;
  /*! \brief Disable copy */
  FeatureHistogram(const FeatureHistogram&) = delete;

Guolin Ke's avatar
Guolin Ke committed
39
40
41
42
43
  /*!
  * \brief Init the feature histogram
  * \param feature the feature data for this histogram
  * \param min_num_data_one_leaf minimal number of data in one leaf
  */
44
  void Init(HistogramBinEntry* data, const FeatureMetainfo* meta, BinType bin_type) {
Guolin Ke's avatar
Guolin Ke committed
45
46
    meta_ = meta;
    data_ = data;
47
48
49
50
51
52
53
    if (bin_type == BinType::NumericalBin) {
      find_best_threshold_fun_ = std::bind(&FeatureHistogram::FindBestThresholdNumerical, this, std::placeholders::_1
        , std::placeholders::_2, std::placeholders::_3, std::placeholders::_4);
    } else {
      find_best_threshold_fun_ = std::bind(&FeatureHistogram::FindBestThresholdCategorical, this, std::placeholders::_1
        , std::placeholders::_2, std::placeholders::_3, std::placeholders::_4);
    }
Guolin Ke's avatar
Guolin Ke committed
54
55
  }

Guolin Ke's avatar
Guolin Ke committed
56
57
  HistogramBinEntry* RawData() {
    return data_;
Guolin Ke's avatar
Guolin Ke committed
58
59
60
61
62
63
  }
  /*!
  * \brief Subtract current histograms with other
  * \param other The histogram that want to subtract
  */
  void Subtract(const FeatureHistogram& other) {
Guolin Ke's avatar
Guolin Ke committed
64
    for (int i = 0; i < meta_->num_bin - meta_->bias; ++i) {
Guolin Ke's avatar
Guolin Ke committed
65
66
67
68
69
      data_[i].cnt -= other.data_[i].cnt;
      data_[i].sum_gradients -= other.data_[i].sum_gradients;
      data_[i].sum_hessians -= other.data_[i].sum_hessians;
    }
  }
70

Guolin Ke's avatar
Guolin Ke committed
71
72
  void FindBestThreshold(double sum_gradient, double sum_hessian, data_size_t num_data,
    SplitInfo* output) {
73
74
75
76
77
    find_best_threshold_fun_(sum_gradient, sum_hessian + 2 * kEpsilon, num_data, output);
  }

  void FindBestThresholdNumerical(double sum_gradient, double sum_hessian, data_size_t num_data,
    SplitInfo* output) {
Guolin Ke's avatar
Guolin Ke committed
78
79
80
    double best_sum_left_gradient = NAN;
    double best_sum_left_hessian = NAN;
    double best_gain = kMinScore;
Guolin Ke's avatar
Guolin Ke committed
81
    data_size_t best_left_count = 0;
Guolin Ke's avatar
Guolin Ke committed
82
    uint32_t best_threshold = static_cast<uint32_t>(meta_->num_bin);
Guolin Ke's avatar
Guolin Ke committed
83
84
    double sum_right_gradient = 0.0f;
    double sum_right_hessian = kEpsilon;
Guolin Ke's avatar
Guolin Ke committed
85
    data_size_t right_count = 0;
Guolin Ke's avatar
Guolin Ke committed
86
    double gain_shift = GetLeafSplitGain(sum_gradient, sum_hessian);
Guolin Ke's avatar
Guolin Ke committed
87
88
89
90
91
    double min_gain_shift = gain_shift + meta_->tree_config->min_gain_to_split;
    is_splittable_ = false;
    const int bias = meta_->bias;
    int t = meta_->num_bin - 1 - bias;
    const int t_end = 1 - bias;
Guolin Ke's avatar
Guolin Ke committed
92
    // from right to left, and we don't need data in bin0
Guolin Ke's avatar
Guolin Ke committed
93
    for (; t >= t_end; --t) {
Guolin Ke's avatar
Guolin Ke committed
94
95
96
97
      sum_right_gradient += data_[t].sum_gradients;
      sum_right_hessian += data_[t].sum_hessians;
      right_count += data_[t].cnt;
      // if data not enough, or sum hessian too small
Guolin Ke's avatar
Guolin Ke committed
98
99
      if (right_count < meta_->tree_config->min_data_in_leaf
        || sum_right_hessian < meta_->tree_config->min_sum_hessian_in_leaf) continue;
Guolin Ke's avatar
Guolin Ke committed
100
      data_size_t left_count = num_data - right_count;
Guolin Ke's avatar
Guolin Ke committed
101
      // if data not enough
Guolin Ke's avatar
Guolin Ke committed
102
      if (left_count < meta_->tree_config->min_data_in_leaf) break;
Guolin Ke's avatar
Guolin Ke committed
103

Guolin Ke's avatar
Guolin Ke committed
104
      double sum_left_hessian = sum_hessian - sum_right_hessian;
Guolin Ke's avatar
Guolin Ke committed
105
      // if sum hessian too small
Guolin Ke's avatar
Guolin Ke committed
106
      if (sum_left_hessian < meta_->tree_config->min_sum_hessian_in_leaf) break;
107

Guolin Ke's avatar
Guolin Ke committed
108
      double sum_left_gradient = sum_gradient - sum_right_gradient;
Guolin Ke's avatar
Guolin Ke committed
109
      // current split gain
Guolin Ke's avatar
Guolin Ke committed
110
111
      double current_gain = GetLeafSplitGain(sum_left_gradient, sum_left_hessian)
        + GetLeafSplitGain(sum_right_gradient, sum_right_hessian);
112
      // gain with split is worse than without split
Guolin Ke's avatar
Guolin Ke committed
113
      if (current_gain <= min_gain_shift) continue;
114

Guolin Ke's avatar
Guolin Ke committed
115
      // mark to is splittable
Guolin Ke's avatar
Guolin Ke committed
116
      is_splittable_ = true;
Guolin Ke's avatar
Guolin Ke committed
117
118
119
120
121
122
      // better split point
      if (current_gain > best_gain) {
        best_left_count = left_count;
        best_sum_left_gradient = sum_left_gradient;
        best_sum_left_hessian = sum_left_hessian;
        // left is <= threshold, right is > threshold.  so this is t-1
Guolin Ke's avatar
Guolin Ke committed
123
        best_threshold = static_cast<uint32_t>(t - 1 + bias);
Guolin Ke's avatar
Guolin Ke committed
124
125
126
        best_gain = current_gain;
      }
    }
Guolin Ke's avatar
Guolin Ke committed
127
    if (is_splittable_) {
Guolin Ke's avatar
Guolin Ke committed
128
      // update split information
Guolin Ke's avatar
Guolin Ke committed
129
      output->feature = meta_->feature_idx;
Guolin Ke's avatar
Guolin Ke committed
130
131
132
133
134
      output->threshold = best_threshold;
      output->left_output = CalculateSplittedLeafOutput(best_sum_left_gradient, best_sum_left_hessian);
      output->left_count = best_left_count;
      output->left_sum_gradient = best_sum_left_gradient;
      output->left_sum_hessian = best_sum_left_hessian;
Guolin Ke's avatar
Guolin Ke committed
135
136
137
138
139
      output->right_output = CalculateSplittedLeafOutput(sum_gradient - best_sum_left_gradient,
        sum_hessian - best_sum_left_hessian);
      output->right_count = num_data - best_left_count;
      output->right_sum_gradient = sum_gradient - best_sum_left_gradient;
      output->right_sum_hessian = sum_hessian - best_sum_left_hessian;
Guolin Ke's avatar
Guolin Ke committed
140
141
      output->gain = best_gain - gain_shift;
    } else {
Guolin Ke's avatar
Guolin Ke committed
142
      output->feature = meta_->feature_idx;
Guolin Ke's avatar
Guolin Ke committed
143
144
      output->gain = kMinScore;
    }
Guolin Ke's avatar
Guolin Ke committed
145
  }
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236

  void FindBestThresholdCategorical(double sum_gradient, double sum_hessian, data_size_t num_data,
    SplitInfo* output) {
    double best_gain = kMinScore;
    uint32_t best_threshold = static_cast<uint32_t>(meta_->num_bin);
    double gain_shift = GetLeafSplitGain(sum_gradient, sum_hessian);
    double min_gain_shift = gain_shift + meta_->tree_config->min_gain_to_split;
    is_splittable_ = false;
    const int bias = meta_->bias;
    int t = meta_->num_bin - 1 - bias;
    const int t_end = 0;
    // from right to left, and we don't need data in bin0
    for (; t >= t_end; --t) {
      // if data not enough, or sum hessian too small
      if (data_[t].cnt < meta_->tree_config->min_data_in_leaf
        || data_[t].sum_hessians < meta_->tree_config->min_sum_hessian_in_leaf) continue;
      data_size_t other_count = num_data - data_[t].cnt;
      // if data not enough
      if (other_count < meta_->tree_config->min_data_in_leaf) continue;

      double sum_other_hessian = sum_hessian - data_[t].sum_hessians - kEpsilon;
      // if sum hessian too small
      if (sum_other_hessian < meta_->tree_config->min_sum_hessian_in_leaf) continue;

      double sum_other_gradient = sum_gradient - data_[t].sum_gradients;
      // current split gain
      double current_gain = GetLeafSplitGain(sum_other_gradient, sum_other_hessian)
        + GetLeafSplitGain(data_[t].sum_gradients, data_[t].sum_hessians + kEpsilon);
      // gain with split is worse than without split
      if (current_gain <= min_gain_shift) continue;

      // mark to is splittable
      is_splittable_ = true;
      // better split point
      if (current_gain > best_gain) {
        best_threshold = static_cast<uint32_t>(t + bias);
        best_gain = current_gain;
      }
    }
    // need restore zero bin
    if (bias == 1) {
      t = meta_->num_bin - 1 - bias;
      double sum_bin0_gradient = sum_gradient;
      double sum_bin0_hessian = sum_hessian;
      data_size_t cnt_bin0 = num_data;
      for (; t >= 0; --t) {
        sum_bin0_gradient -= data_[t].sum_gradients;
        sum_bin0_hessian -= data_[t].sum_hessians;
        cnt_bin0 -= data_[t].cnt;
      }
      data_size_t other_count = num_data - cnt_bin0;
      double sum_other_hessian = sum_hessian - sum_bin0_hessian - kEpsilon;
      if (cnt_bin0 >= meta_->tree_config->min_data_in_leaf
        && sum_bin0_hessian >= meta_->tree_config->min_sum_hessian_in_leaf
        && other_count >= meta_->tree_config->min_data_in_leaf
        && sum_other_hessian >= meta_->tree_config->min_sum_hessian_in_leaf) {
        double sum_other_gradient = sum_gradient - sum_bin0_gradient;
        double current_gain = GetLeafSplitGain(sum_other_gradient, sum_other_hessian)
          + GetLeafSplitGain(sum_bin0_gradient, sum_bin0_hessian + kEpsilon);
        if (current_gain > min_gain_shift) {
          is_splittable_ = true;
          // better split point
          if (current_gain > best_gain) {
            best_threshold = static_cast<uint32_t>(0);
            best_gain = current_gain;
          }
        }
      }
    }
    if (is_splittable_) {
      // update split information
      output->feature =  meta_->feature_idx;
      output->threshold = best_threshold;
      output->left_output = CalculateSplittedLeafOutput(data_[best_threshold].sum_gradients,
        data_[best_threshold].sum_hessians + kEpsilon);
      output->left_count = data_[best_threshold].cnt;
      output->left_sum_gradient = data_[best_threshold].sum_gradients;
      output->left_sum_hessian = data_[best_threshold].sum_hessians + kEpsilon;

      output->right_output = CalculateSplittedLeafOutput(sum_gradient - data_[best_threshold].sum_gradients,
        sum_hessian - data_[best_threshold].sum_hessians - kEpsilon);
      output->right_count = num_data - data_[best_threshold].cnt;
      output->right_sum_gradient = sum_gradient - data_[best_threshold].sum_gradients;
      output->right_sum_hessian = sum_hessian - data_[best_threshold].sum_hessians - kEpsilon;
      output->gain = best_gain - gain_shift;
    } else {
      output->feature = meta_->feature_idx;
      output->gain = kMinScore;
    }
  }

Guolin Ke's avatar
Guolin Ke committed
237
238
239
240
  /*!
  * \brief Binary size of this histogram
  */
  int SizeOfHistgram() const {
Guolin Ke's avatar
Guolin Ke committed
241
    return (meta_->num_bin - meta_->bias) * sizeof(HistogramBinEntry);
Guolin Ke's avatar
Guolin Ke committed
242
243
244
245
246
  }

  /*!
  * \brief Restore histogram from memory
  */
Guolin Ke's avatar
Guolin Ke committed
247
248
  void FromMemory(char* memory_data) {
    std::memcpy(data_, memory_data, (meta_->num_bin - meta_->bias) * sizeof(HistogramBinEntry));
Guolin Ke's avatar
Guolin Ke committed
249
250
251
252
253
254
255
256
257
258
259
260
261
262
  }

  /*!
  * \brief True if this histogram can be splitted
  */
  bool is_splittable() { return is_splittable_; }

  /*!
  * \brief Set splittable to this histogram
  */
  void set_is_splittable(bool val) { is_splittable_ = val; }

private:
  /*!
263
  * \brief Calculate the split gain based on regularized sum_gradients and sum_hessians
Guolin Ke's avatar
Guolin Ke committed
264
265
266
267
  * \param sum_gradients
  * \param sum_hessians
  * \return split gain
  */
Guolin Ke's avatar
Guolin Ke committed
268
  double GetLeafSplitGain(double sum_gradients, double sum_hessians) const {
269
    double abs_sum_gradients = std::fabs(sum_gradients);
Guolin Ke's avatar
Guolin Ke committed
270
271
272
273
    double reg_abs_sum_gradients = std::max(0.0, abs_sum_gradients - meta_->tree_config->lambda_l1);
    return (reg_abs_sum_gradients * reg_abs_sum_gradients)
      / (sum_hessians + meta_->tree_config->lambda_l2);

Guolin Ke's avatar
Guolin Ke committed
274
275
276
  }

  /*!
277
  * \brief Calculate the output of a leaf based on regularized sum_gradients and sum_hessians
Guolin Ke's avatar
Guolin Ke committed
278
279
280
281
  * \param sum_gradients
  * \param sum_hessians
  * \return leaf output
  */
Guolin Ke's avatar
Guolin Ke committed
282
  double CalculateSplittedLeafOutput(double sum_gradients, double sum_hessians) const {
283
    double abs_sum_gradients = std::fabs(sum_gradients);
Guolin Ke's avatar
Guolin Ke committed
284
285
286
    double reg_abs_sum_gradients = std::max(0.0, abs_sum_gradients - meta_->tree_config->lambda_l1);
    return -std::copysign(reg_abs_sum_gradients, sum_gradients)
      / (sum_hessians + meta_->tree_config->lambda_l2);
Guolin Ke's avatar
Guolin Ke committed
287
  }
Guolin Ke's avatar
Guolin Ke committed
288
  const FeatureMetainfo* meta_;
Guolin Ke's avatar
Guolin Ke committed
289
  /*! \brief sum of gradient of each bin */
Guolin Ke's avatar
Guolin Ke committed
290
291
  HistogramBinEntry* data_;
  //std::vector<HistogramBinEntry> data_;
Guolin Ke's avatar
Guolin Ke committed
292
293
  /*! \brief False if this histogram cannot split */
  bool is_splittable_ = true;
294
295

  std::function<void(double, double, data_size_t, SplitInfo*)> find_best_threshold_fun_;
Guolin Ke's avatar
Guolin Ke committed
296
};
Guolin Ke's avatar
Guolin Ke committed
297
298
299
300
301
302
class HistogramPool {
public:
  /*!
  * \brief Constructor
  */
  HistogramPool() {
Guolin Ke's avatar
Guolin Ke committed
303
304
    cache_size_ = 0;
    total_size_ = 0;
Guolin Ke's avatar
Guolin Ke committed
305
306
307
308
309
310
311
312
313
314
315
  }
  /*!
  * \brief Destructor
  */
  ~HistogramPool() {
  }
  /*!
  * \brief Reset pool size
  * \param cache_size Max cache size
  * \param total_size Total size will be used
  */
Guolin Ke's avatar
Guolin Ke committed
316
  void Reset(int cache_size, int total_size) {
Guolin Ke's avatar
Guolin Ke committed
317
318
319
320
321
322
323
324
325
    cache_size_ = cache_size;
    // at least need 2 bucket to store smaller leaf and larger leaf
    CHECK(cache_size_ >= 2);
    total_size_ = total_size;
    if (cache_size_ > total_size_) {
      cache_size_ = total_size_;
    }
    is_enough_ = (cache_size_ == total_size_);
    if (!is_enough_) {
326
327
328
      mapper_.resize(total_size_);
      inverse_mapper_.resize(cache_size_);
      last_used_time_.resize(cache_size_);
Guolin Ke's avatar
Guolin Ke committed
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
      ResetMap();
    }
  }
  /*!
  * \brief Reset mapper
  */
  void ResetMap() {
    if (!is_enough_) {
      cur_time_ = 0;
      std::fill(mapper_.begin(), mapper_.end(), -1);
      std::fill(inverse_mapper_.begin(), inverse_mapper_.end(), -1);
      std::fill(last_used_time_.begin(), last_used_time_.end(), 0);
    }
  }

Guolin Ke's avatar
Guolin Ke committed
344
345
346
347
348
349
350
351
352
353
354
355
356
357
  void DynamicChangeSize(const Dataset* train_data, const TreeConfig* tree_config, int cache_size, int total_size) {
    if (feature_metas_.empty()) {
      feature_metas_.resize(train_data->num_features());
#pragma omp parallel for schedule(static)
      for (int i = 0; i < train_data->num_features(); ++i) {
        feature_metas_[i].feature_idx = i;
        feature_metas_[i].num_bin = train_data->FeatureNumBin(i);
        if (train_data->FeatureBinMapper(i)->GetDefaultBin() == 0) {
          feature_metas_[i].bias = 1;
        } else {
          feature_metas_[i].bias = 0;
        }
        feature_metas_[i].tree_config = tree_config;
      }
Guolin Ke's avatar
Guolin Ke committed
358
    }
Guolin Ke's avatar
Guolin Ke committed
359
360
    uint64_t num_total_bin = train_data->NumTotalBin();
    Log::Info("Total Bins %d", num_total_bin);
Guolin Ke's avatar
Guolin Ke committed
361
362
    int old_cache_size = cache_size_;
    Reset(cache_size, total_size);
Guolin Ke's avatar
Guolin Ke committed
363
364
365
    pool_.resize(cache_size);
    data_.resize(cache_size);
#pragma omp parallel for schedule(static)
Guolin Ke's avatar
Guolin Ke committed
366
    for (int i = old_cache_size; i < cache_size_; ++i) {
Guolin Ke's avatar
Guolin Ke committed
367
368
369
370
371
      pool_[i].reset(new FeatureHistogram[train_data->num_features()]);
      data_[i].resize(num_total_bin);
      uint64_t offset = 0;
      for (int j = 0; j < train_data->num_features(); ++j) {
        offset += static_cast<uint64_t>(train_data->SubFeatureBinOffset(j));
372
        pool_[i][j].Init(data_[i].data() + offset, &feature_metas_[j], train_data->FeatureBinMapper(j)->bin_type());
Guolin Ke's avatar
Guolin Ke committed
373
374
375
376
377
378
379
        auto num_bin = train_data->FeatureNumBin(j);
        if (train_data->FeatureBinMapper(j)->GetDefaultBin() == 0) {
          num_bin -= 1;
        }
        offset += static_cast<uint64_t>(num_bin);
      }
      CHECK(offset == num_total_bin);
Guolin Ke's avatar
Guolin Ke committed
380
381
382
    }
  }

Guolin Ke's avatar
Guolin Ke committed
383
384
385
386
  void ResetConfig(const TreeConfig* tree_config) {
#pragma omp parallel for schedule(static)
    for (int i = 0; i < static_cast<int>(feature_metas_.size()); ++i) {
      feature_metas_[i].tree_config = tree_config;
Guolin Ke's avatar
Guolin Ke committed
387
388
    }
  }
Guolin Ke's avatar
Guolin Ke committed
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
  /*!
  * \brief Get data for the specific index
  * \param idx which index want to get
  * \param out output data will store into this
  * \return True if this index is in the pool, False if this index is not in the pool
  */
  bool Get(int idx, FeatureHistogram** out) {
    if (is_enough_) {
      *out = pool_[idx].get();
      return true;
    } else if (mapper_[idx] >= 0) {
      int slot = mapper_[idx];
      *out = pool_[slot].get();
      last_used_time_[slot] = ++cur_time_;
      return true;
    } else {
      // choose the least used slot 
      int slot = static_cast<int>(ArrayArgs<int>::ArgMin(last_used_time_));
      *out = pool_[slot].get();
      last_used_time_[slot] = ++cur_time_;

      // reset previous mapper
      if (inverse_mapper_[slot] >= 0) mapper_[inverse_mapper_[slot]] = -1;

      // update current mapper
      mapper_[idx] = slot;
      inverse_mapper_[slot] = idx;
      return false;
    }
  }

  /*!
  * \brief Move data from one index to another index
  * \param src_idx
  * \param dst_idx
  */
  void Move(int src_idx, int dst_idx) {
    if (is_enough_) {
      std::swap(pool_[src_idx], pool_[dst_idx]);
      return;
    }
    if (mapper_[src_idx] < 0) {
      return;
    }
    // get slot of src idx
    int slot = mapper_[src_idx];
    // reset src_idx
    mapper_[src_idx] = -1;

    // move to dst idx
    mapper_[dst_idx] = slot;
    last_used_time_[slot] = ++cur_time_;
    inverse_mapper_[slot] = dst_idx;
  }
private:
  std::vector<std::unique_ptr<FeatureHistogram[]>> pool_;
Guolin Ke's avatar
Guolin Ke committed
445
446
  std::vector<std::vector<HistogramBinEntry>> data_;
  std::vector<FeatureMetainfo> feature_metas_;
Guolin Ke's avatar
Guolin Ke committed
447
448
449
450
451
452
453
454
455
  int cache_size_;
  int total_size_;
  bool is_enough_ = false;
  std::vector<int> mapper_;
  std::vector<int> inverse_mapper_;
  std::vector<int> last_used_time_;
  int cur_time_ = 0;
};

Guolin Ke's avatar
Guolin Ke committed
456
}  // namespace LightGBM
Guolin Ke's avatar
Guolin Ke committed
457
#endif   // LightGBM_TREELEARNER_FEATURE_HISTOGRAM_HPP_