dataset.cpp 33.2 KB
Newer Older
Guolin Ke's avatar
Guolin Ke committed
1
#include <LightGBM/dataset.h>
Guolin Ke's avatar
Guolin Ke committed
2
#include <LightGBM/feature_group.h>
3
#include <LightGBM/utils/openmp_wrapper.h>
Guolin Ke's avatar
Guolin Ke committed
4
5
#include <LightGBM/utils/threading.h>
#include <LightGBM/utils/array_args.h>
Guolin Ke's avatar
Guolin Ke committed
6

zhangyafeikimi's avatar
zhangyafeikimi committed
7
#include <chrono>
Guolin Ke's avatar
Guolin Ke committed
8
9
10
11
12
13
#include <cstdio>
#include <unordered_map>
#include <limits>
#include <vector>
#include <utility>
#include <string>
Guolin Ke's avatar
Guolin Ke committed
14
#include <sstream>
Guolin Ke's avatar
Guolin Ke committed
15
16
17

namespace LightGBM {

18
const char* Dataset::binary_file_token = "______LightGBM_Binary_File_Token______\n";
Guolin Ke's avatar
Guolin Ke committed
19

Guolin Ke's avatar
Guolin Ke committed
20
Dataset::Dataset() {
21
  data_filename_ = "noname";
Guolin Ke's avatar
Guolin Ke committed
22
  num_data_ = 0;
Guolin Ke's avatar
Guolin Ke committed
23
  is_finish_load_ = false;
Guolin Ke's avatar
Guolin Ke committed
24
25
}

26
Dataset::Dataset(data_size_t num_data) {
Guolin Ke's avatar
Guolin Ke committed
27
  CHECK(num_data > 0);
Guolin Ke's avatar
Guolin Ke committed
28
  data_filename_ = "noname";
Guolin Ke's avatar
Guolin Ke committed
29
  num_data_ = num_data;
Guolin Ke's avatar
Guolin Ke committed
30
  metadata_.Init(num_data_, NO_SPECIFIC, NO_SPECIFIC);
Guolin Ke's avatar
Guolin Ke committed
31
  is_finish_load_ = false;
Guolin Ke's avatar
Guolin Ke committed
32
  group_bin_boundaries_.push_back(0);
Guolin Ke's avatar
Guolin Ke committed
33
34
}

Guolin Ke's avatar
Guolin Ke committed
35
Dataset::~Dataset() {
Guolin Ke's avatar
Guolin Ke committed
36
}
Guolin Ke's avatar
Guolin Ke committed
37

Guolin Ke's avatar
Guolin Ke committed
38
39
40
41
42
43
44
45
46
47
std::vector<std::vector<int>> NoGroup(
  const std::vector<int>& used_features) {
  std::vector<std::vector<int>> features_in_group;
  features_in_group.resize(used_features.size());
  for (size_t i = 0; i < used_features.size(); ++i) {
    features_in_group[i].emplace_back(used_features[i]);
  }
  return features_in_group;
}

Guolin Ke's avatar
Guolin Ke committed
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
int GetConfilctCount(const std::vector<bool>& mark, const int* indices, int num_indices, int max_cnt) {
  int ret = 0;
  for (int i = 0; i < num_indices; ++i) {
    if (mark[indices[i]]) {
      ++ret;
      if (ret > max_cnt) {
        return -1;
      }
    }
  }
  return ret;
}
void MarkUsed(std::vector<bool>& mark, const int* indices, int num_indices) {
  for (int i = 0; i < num_indices; ++i) {
    mark[indices[i]] = true;
  }
}

std::vector<std::vector<int>> FindGroups(const std::vector<std::unique_ptr<BinMapper>>& bin_mappers,
                                         const std::vector<int>& find_order,
                                         int** sample_indices,
                                         const int* num_per_col,
                                         size_t total_sample_cnt,
                                         data_size_t max_error_cnt,
                                         data_size_t filter_cnt,
Guolin Ke's avatar
Guolin Ke committed
73
74
                                         data_size_t num_data,
                                         bool is_use_gpu) {
Guolin Ke's avatar
Guolin Ke committed
75
  const int max_search_group = 100;
Guolin Ke's avatar
Guolin Ke committed
76
  const int gpu_max_bin_per_group = 256;
Guolin Ke's avatar
Guolin Ke committed
77
78
79
80
81
82
83
84
85
86
87
88
  Random rand(num_data);
  std::vector<std::vector<int>> features_in_group;
  std::vector<std::vector<bool>> conflict_marks;
  std::vector<int> group_conflict_cnt;
  std::vector<size_t> group_non_zero_cnt;
  std::vector<int> group_num_bin;

  for (auto fidx : find_order) {
    const size_t cur_non_zero_cnt = num_per_col[fidx];
    bool need_new_group = true;
    std::vector<int> available_groups;
    for (int gid = 0; gid < static_cast<int>(features_in_group.size()); ++gid) {
Guolin Ke's avatar
Guolin Ke committed
89
90
91
92
93
      if (group_non_zero_cnt[gid] + cur_non_zero_cnt <= total_sample_cnt + max_error_cnt){
        if (!is_use_gpu || group_num_bin[gid] + bin_mappers[fidx]->num_bin() + (bin_mappers[fidx]->GetDefaultBin() == 0 ? -1 : 0)
            <= gpu_max_bin_per_group) {
          available_groups.push_back(gid);
        }
Guolin Ke's avatar
Guolin Ke committed
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
      }
    }
    std::vector<int> search_groups;
    if (!available_groups.empty()) {
      int last = static_cast<int>(available_groups.size()) - 1;
      auto indices = rand.Sample(last, std::min(last, max_search_group - 1));
      search_groups.push_back(available_groups.back());
      for (auto idx : indices) {
        search_groups.push_back(available_groups[idx]);
      }
    }
    for (auto gid : search_groups) {
      const int rest_max_cnt = max_error_cnt - group_conflict_cnt[gid];
      int cnt = GetConfilctCount(conflict_marks[gid], sample_indices[fidx], num_per_col[fidx], rest_max_cnt);
      if (cnt >= 0 && cnt <= rest_max_cnt) {
        data_size_t rest_non_zero_data = static_cast<data_size_t>(
          static_cast<double>(cur_non_zero_cnt - cnt) * num_data / total_sample_cnt);
        if (rest_non_zero_data < filter_cnt) { continue; }
        need_new_group = false;
        features_in_group[gid].push_back(fidx);
        group_conflict_cnt[gid] += cnt;
        group_non_zero_cnt[gid] += cur_non_zero_cnt - cnt;
        MarkUsed(conflict_marks[gid], sample_indices[fidx], num_per_col[fidx]);
Guolin Ke's avatar
Guolin Ke committed
117
118
119
        if (is_use_gpu) {
          group_num_bin[gid] += bin_mappers[fidx]->num_bin() + (bin_mappers[fidx]->GetDefaultBin() == 0 ? -1 : 0);
        }
Guolin Ke's avatar
Guolin Ke committed
120
121
122
123
124
125
126
127
128
129
        break;
      }
    }
    if (need_new_group) {
      features_in_group.emplace_back();
      features_in_group.back().push_back(fidx);
      group_conflict_cnt.push_back(0);
      conflict_marks.emplace_back(total_sample_cnt, false);
      MarkUsed(conflict_marks.back(), sample_indices[fidx], num_per_col[fidx]);
      group_non_zero_cnt.emplace_back(cur_non_zero_cnt);
Guolin Ke's avatar
Guolin Ke committed
130
131
132
      if (is_use_gpu) {
        group_num_bin.push_back(1 + bin_mappers[fidx]->num_bin() + (bin_mappers[fidx]->GetDefaultBin() == 0 ? -1 : 0));
      }
Guolin Ke's avatar
Guolin Ke committed
133
134
135
136
137
138
139
140
141
142
143
144
145
146
    }
  }
  return features_in_group;
}

std::vector<std::vector<int>> FastFeatureBundling(std::vector<std::unique_ptr<BinMapper>>& bin_mappers,
                                                  int** sample_indices,
                                                  const int* num_per_col,
                                                  size_t total_sample_cnt,
                                                  const std::vector<int>& used_features,
                                                  double max_conflict_rate,
                                                  data_size_t num_data,
                                                  data_size_t min_data,
                                                  double sparse_threshold,
Guolin Ke's avatar
Guolin Ke committed
147
148
                                                  bool is_enable_sparse,
                                                  bool is_use_gpu) {
Guolin Ke's avatar
Guolin Ke committed
149
150
151
152
  // filter is based on sampling data, so decrease its range
  const data_size_t filter_cnt = static_cast<data_size_t>(static_cast<double>(0.95 * min_data) / num_data * total_sample_cnt);
  const data_size_t max_error_cnt = static_cast<data_size_t>(total_sample_cnt * max_conflict_rate);
  std::vector<size_t> feature_non_zero_cnt;
153
  feature_non_zero_cnt.reserve(used_features.size());
Guolin Ke's avatar
Guolin Ke committed
154
155
156
157
158
159
  // put dense feature first
  for (auto fidx : used_features) {
    feature_non_zero_cnt.emplace_back(num_per_col[fidx]);
  }
  // sort by non zero cnt
  std::vector<int> sorted_idx;
160
  sorted_idx.reserve(used_features.size());
161
  for (int i = 0; i < static_cast<int>(used_features.size()); ++i) {
Guolin Ke's avatar
Guolin Ke committed
162
163
164
    sorted_idx.emplace_back(i);
  }
  // sort by non zero cnt, bigger first
165
166
  std::stable_sort(sorted_idx.begin(), sorted_idx.end(),
                   [&feature_non_zero_cnt](int a, int b) {
Guolin Ke's avatar
Guolin Ke committed
167
168
169
170
    return feature_non_zero_cnt[a] > feature_non_zero_cnt[b];
  });

  std::vector<int> feature_order_by_cnt;
171
  feature_order_by_cnt.reserve(sorted_idx.size());
Guolin Ke's avatar
Guolin Ke committed
172
173
174
  for (auto sidx : sorted_idx) {
    feature_order_by_cnt.push_back(used_features[sidx]);
  }
Guolin Ke's avatar
Guolin Ke committed
175
176
  auto features_in_group = FindGroups(bin_mappers, used_features, sample_indices, num_per_col, total_sample_cnt, max_error_cnt, filter_cnt, num_data, is_use_gpu);
  auto group2 = FindGroups(bin_mappers, feature_order_by_cnt, sample_indices, num_per_col, total_sample_cnt, max_error_cnt, filter_cnt, num_data, is_use_gpu);
Guolin Ke's avatar
Guolin Ke committed
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
  if (features_in_group.size() > group2.size()) {
    features_in_group = group2;
  }
  std::vector<std::vector<int>> ret;
  for (size_t i = 0; i < features_in_group.size(); ++i) {
    if (features_in_group[i].size() <= 1 || features_in_group[i].size() >= 5) {
      ret.push_back(features_in_group[i]);
    } else {
      int cnt_non_zero = 0;
      for (size_t j = 0; j < features_in_group[i].size(); ++j) {
        const int fidx = features_in_group[i][j];
        cnt_non_zero += static_cast<int>(num_data * (1.0f - bin_mappers[fidx]->sparse_rate()));
      }
      double sparse_rate = 1.0f - static_cast<double>(cnt_non_zero) / (num_data);
      // take apart small sparse group, due it will not gain on speed 
      if (sparse_rate >= sparse_threshold && is_enable_sparse) {
        for (size_t j = 0; j < features_in_group[i].size(); ++j) {
          const int fidx = features_in_group[i][j];
          ret.emplace_back();
          ret.back().push_back(fidx);
        }
      } else {
        ret.push_back(features_in_group[i]);
      }
    }
  }
  // shuffle groups
  int num_group = static_cast<int>(ret.size());
  Random tmp_rand(12);
  for (int i = 0; i < num_group - 1; ++i) {
    int j = tmp_rand.NextShort(i + 1, num_group);
    std::swap(ret[i], ret[j]);
  }
  return ret;
}

Guolin Ke's avatar
Guolin Ke committed
213
214
void Dataset::Construct(
  std::vector<std::unique_ptr<BinMapper>>& bin_mappers,
Guolin Ke's avatar
Guolin Ke committed
215
216
217
  int** sample_non_zero_indices,
  const int* num_per_col,
  size_t total_sample_cnt,
Guolin Ke's avatar
Guolin Ke committed
218
  const Config& io_config) {
Guolin Ke's avatar
Guolin Ke committed
219

Guolin Ke's avatar
Guolin Ke committed
220
  num_total_features_ = static_cast<int>(bin_mappers.size());
221
  sparse_threshold_ = io_config.sparse_threshold;
Guolin Ke's avatar
Guolin Ke committed
222
223
224
  // get num_features
  std::vector<int> used_features;
  for (int i = 0; i < static_cast<int>(bin_mappers.size()); ++i) {
Lingyi Hu's avatar
Lingyi Hu committed
225
    if (bin_mappers[i] != nullptr && !bin_mappers[i]->is_trivial()) {
Guolin Ke's avatar
Guolin Ke committed
226
      used_features.emplace_back(i);
Guolin Ke's avatar
Guolin Ke committed
227
    }
Guolin Ke's avatar
Guolin Ke committed
228
  }
Guolin Ke's avatar
Guolin Ke committed
229
  if (used_features.empty()) {
230
    Log::Warning("There are no meaningful features, as all feature values are constant.");
Guolin Ke's avatar
Guolin Ke committed
231
  }
Guolin Ke's avatar
Guolin Ke committed
232
233
  auto features_in_group = NoGroup(used_features);

234
  if (io_config.enable_bundle && !used_features.empty()) {
Guolin Ke's avatar
Guolin Ke committed
235
236
237
238
    features_in_group = FastFeatureBundling(bin_mappers,
                                            sample_non_zero_indices, num_per_col, total_sample_cnt,
                                            used_features, io_config.max_conflict_rate,
                                            num_data_, io_config.min_data_in_leaf,
Guolin Ke's avatar
Guolin Ke committed
239
                                            sparse_threshold_, io_config.is_enable_sparse, io_config.device_type == std::string("gpu"));
Guolin Ke's avatar
Guolin Ke committed
240
241
  }

Guolin Ke's avatar
Guolin Ke committed
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
  num_features_ = 0;
  for (const auto& fs : features_in_group) {
    num_features_ += static_cast<int>(fs.size());
  }
  int cur_fidx = 0;
  used_feature_map_ = std::vector<int>(num_total_features_, -1);
  num_groups_ = static_cast<int>(features_in_group.size());
  real_feature_idx_.resize(num_features_);
  feature2group_.resize(num_features_);
  feature2subfeature_.resize(num_features_);
  for (int i = 0; i < num_groups_; ++i) {
    auto cur_features = features_in_group[i];
    int cur_cnt_features = static_cast<int>(cur_features.size());
    // get bin_mappers
    std::vector<std::unique_ptr<BinMapper>> cur_bin_mappers;
    for (int j = 0; j < cur_cnt_features; ++j) {
      int real_fidx = cur_features[j];
      used_feature_map_[real_fidx] = cur_fidx;
      real_feature_idx_[cur_fidx] = real_fidx;
      feature2group_[cur_fidx] = i;
      feature2subfeature_[cur_fidx] = j;
      cur_bin_mappers.emplace_back(bin_mappers[real_fidx].release());
      ++cur_fidx;
    }
    feature_groups_.emplace_back(std::unique_ptr<FeatureGroup>(
Guolin Ke's avatar
Guolin Ke committed
267
268
      new FeatureGroup(cur_cnt_features, cur_bin_mappers, num_data_, sparse_threshold_,
                       io_config.is_enable_sparse)));
Guolin Ke's avatar
Guolin Ke committed
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
  }
  feature_groups_.shrink_to_fit();
  group_bin_boundaries_.clear();
  uint64_t num_total_bin = 0;
  group_bin_boundaries_.push_back(num_total_bin);
  for (int i = 0; i < num_groups_; ++i) {
    num_total_bin += feature_groups_[i]->num_total_bin_;
    group_bin_boundaries_.push_back(num_total_bin);
  }
  int last_group = 0;
  group_feature_start_.reserve(num_groups_);
  group_feature_cnt_.reserve(num_groups_);
  group_feature_start_.push_back(0);
  group_feature_cnt_.push_back(1);
  for (int i = 1; i < num_features_; ++i) {
    const int group = feature2group_[i];
    if (group == last_group) {
      group_feature_cnt_.back() = group_feature_cnt_.back() + 1;
    } else {
      group_feature_start_.push_back(i);
      group_feature_cnt_.push_back(1);
      last_group = group;
    }
  }
Guolin Ke's avatar
Guolin Ke committed
293
294
295
296
297
298
299
300
301
302
303
304
305
306

  if (!io_config.monotone_constraints.empty()) {
    CHECK(static_cast<size_t>(num_total_features_) == io_config.monotone_constraints.size());
    monotone_types_.resize(num_features_);
    for (int i = 0; i < num_total_features_; ++i) {
      int inner_fidx = InnerFeatureIndex(i);
      if (inner_fidx >= 0) {
        monotone_types_[inner_fidx] = io_config.monotone_constraints[i];
      }
    }
    if (ArrayArgs<int8_t>::CheckAllZero(monotone_types_)) {
      monotone_types_.clear();
    }
  }
Guolin Ke's avatar
Guolin Ke committed
307
308
309
310
311
312
313
314
315
316
317
318
319
  if (!io_config.feature_contri.empty()) {
    CHECK(static_cast<size_t>(num_total_features_) == io_config.feature_contri.size());
    feature_penalty_.resize(num_features_);
    for (int i = 0; i < num_total_features_; ++i) {
      int inner_fidx = InnerFeatureIndex(i);
      if (inner_fidx >= 0) {
        feature_penalty_[inner_fidx] = std::max(0.0, io_config.feature_contri[i]);
      }
    }
    if (ArrayArgs<double>::CheckAll(feature_penalty_, 1.0)) {
      feature_penalty_.clear();
    }
  }
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
  max_bin_ = io_config.max_bin;
  min_data_in_bin_ = io_config.min_data_in_bin;
  bin_construct_sample_cnt_ = io_config.bin_construct_sample_cnt;
  use_missing_ = io_config.use_missing;
  zero_as_missing_ = io_config.zero_as_missing;
}

void Dataset::ResetConfig(const char* parameters) {
  auto param = Config::Str2Map(parameters);
  Config io_config;
  io_config.Set(param);
  if (param.count("max_bin") && io_config.max_bin != max_bin_) {
    Log::Warning("Cannot change max_bin after constructed Dataset handle.");
  }
  if (param.count("bin_construct_sample_cnt") && io_config.bin_construct_sample_cnt != bin_construct_sample_cnt_) {
    Log::Warning("Cannot change bin_construct_sample_cnt after constructed Dataset handle.");
  }
  if (param.count("min_data_in_bin") && io_config.min_data_in_bin != min_data_in_bin_) {
    Log::Warning("Cannot change min_data_in_bin after constructed Dataset handle.");
  }
  if (param.count("use_missing") && io_config.use_missing != use_missing_) {
    Log::Warning("Cannot change use_missing after constructed Dataset handle.");
  }
  if (param.count("zero_as_missing") && io_config.zero_as_missing != zero_as_missing_) {
    Log::Warning("Cannot change zero_as_missing after constructed Dataset handle.");
  }
  if (!io_config.monotone_constraints.empty()) {
    CHECK(static_cast<size_t>(num_total_features_) == io_config.monotone_constraints.size());
    monotone_types_.resize(num_features_);
    for (int i = 0; i < num_total_features_; ++i) {
      int inner_fidx = InnerFeatureIndex(i);
      if (inner_fidx >= 0) {
        monotone_types_[inner_fidx] = io_config.monotone_constraints[i];
      }
    }
    if (ArrayArgs<int8_t>::CheckAllZero(monotone_types_)) {
      monotone_types_.clear();
    }
  }
  if (!io_config.feature_contri.empty()) {
    CHECK(static_cast<size_t>(num_total_features_) == io_config.feature_contri.size());
    feature_penalty_.resize(num_features_);
    for (int i = 0; i < num_total_features_; ++i) {
      int inner_fidx = InnerFeatureIndex(i);
      if (inner_fidx >= 0) {
        feature_penalty_[inner_fidx] = std::max(0.0, io_config.feature_contri[i]);
      }
    }
    if (ArrayArgs<double>::CheckAll(feature_penalty_, 1.0)) {
      feature_penalty_.clear();
    }
  }
Guolin Ke's avatar
Guolin Ke committed
372
373
}

Guolin Ke's avatar
Guolin Ke committed
374
void Dataset::FinishLoad() {
Guolin Ke's avatar
Guolin Ke committed
375
  if (is_finish_load_) { return; }
376
377
378
379
380
381
382
383
384
  if (num_groups_ > 0) {
    OMP_INIT_EX();
#pragma omp parallel for schedule(guided)
    for (int i = 0; i < num_groups_; ++i) {
      OMP_LOOP_EX_BEGIN();
      feature_groups_[i]->bin_data_->FinishLoad();
      OMP_LOOP_EX_END();
    }
    OMP_THROW_EX();
Guolin Ke's avatar
Guolin Ke committed
385
  }
Guolin Ke's avatar
Guolin Ke committed
386
  is_finish_load_ = true;
Guolin Ke's avatar
Guolin Ke committed
387
}
Guolin Ke's avatar
Guolin Ke committed
388

389
void Dataset::CopyFeatureMapperFrom(const Dataset* dataset) {
Guolin Ke's avatar
Guolin Ke committed
390
  feature_groups_.clear();
Guolin Ke's avatar
Guolin Ke committed
391
  num_features_ = dataset->num_features_;
Guolin Ke's avatar
Guolin Ke committed
392
  num_groups_ = dataset->num_groups_;
393
  sparse_threshold_ = dataset->sparse_threshold_;
Guolin Ke's avatar
Guolin Ke committed
394
  // copy feature bin mapper data
Guolin Ke's avatar
Guolin Ke committed
395
396
397
398
399
400
401
402
  for (int i = 0; i < num_groups_; ++i) {
    std::vector<std::unique_ptr<BinMapper>> bin_mappers;
    for (int j = 0; j < dataset->feature_groups_[i]->num_feature_; ++j) {
      bin_mappers.emplace_back(new BinMapper(*(dataset->feature_groups_[i]->bin_mappers_[j])));
    }
    feature_groups_.emplace_back(new FeatureGroup(
      dataset->feature_groups_[i]->num_feature_,
      bin_mappers,
Guolin Ke's avatar
Guolin Ke committed
403
      num_data_,
Guolin Ke's avatar
Guolin Ke committed
404
      dataset->feature_groups_[i]->is_sparse_));
Guolin Ke's avatar
Guolin Ke committed
405
  }
Guolin Ke's avatar
Guolin Ke committed
406
  feature_groups_.shrink_to_fit();
Guolin Ke's avatar
Guolin Ke committed
407
408
409
  used_feature_map_ = dataset->used_feature_map_;
  num_total_features_ = dataset->num_total_features_;
  feature_names_ = dataset->feature_names_;
Guolin Ke's avatar
Guolin Ke committed
410
  label_idx_ = dataset->label_idx_;
Guolin Ke's avatar
Guolin Ke committed
411
412
413
414
415
416
  real_feature_idx_ = dataset->real_feature_idx_;
  feature2group_ = dataset->feature2group_;
  feature2subfeature_ = dataset->feature2subfeature_;
  group_bin_boundaries_ = dataset->group_bin_boundaries_;
  group_feature_start_ = dataset->group_feature_start_;
  group_feature_cnt_ = dataset->group_feature_cnt_;
Guolin Ke's avatar
Guolin Ke committed
417
  monotone_types_ = dataset->monotone_types_;
Guolin Ke's avatar
Guolin Ke committed
418
  feature_penalty_ = dataset->feature_penalty_;
Guolin Ke's avatar
Guolin Ke committed
419
420
421
422
423
424
}

void Dataset::CreateValid(const Dataset* dataset) {
  feature_groups_.clear();
  num_features_ = dataset->num_features_;
  num_groups_ = num_features_;
425
  sparse_threshold_ = dataset->sparse_threshold_;
Guolin Ke's avatar
Guolin Ke committed
426
427
428
429
430
431
432
433
434
435
436
  bool is_enable_sparse = true;
  feature2group_.clear();
  feature2subfeature_.clear();
  // copy feature bin mapper data
  for (int i = 0; i < num_features_; ++i) {
    std::vector<std::unique_ptr<BinMapper>> bin_mappers;
    bin_mappers.emplace_back(new BinMapper(*(dataset->FeatureBinMapper(i))));
    feature_groups_.emplace_back(new FeatureGroup(
      1,
      bin_mappers,
      num_data_,
437
      dataset->sparse_threshold_,
Guolin Ke's avatar
Guolin Ke committed
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
      is_enable_sparse));
    feature2group_.push_back(i);
    feature2subfeature_.push_back(0);
  }

  feature_groups_.shrink_to_fit();
  used_feature_map_ = dataset->used_feature_map_;
  num_total_features_ = dataset->num_total_features_;
  feature_names_ = dataset->feature_names_;
  label_idx_ = dataset->label_idx_;
  real_feature_idx_ = dataset->real_feature_idx_;
  group_bin_boundaries_.clear();
  uint64_t num_total_bin = 0;
  group_bin_boundaries_.push_back(num_total_bin);
  for (int i = 0; i < num_groups_; ++i) {
    num_total_bin += feature_groups_[i]->num_total_bin_;
    group_bin_boundaries_.push_back(num_total_bin);
  }
  int last_group = 0;
  group_feature_start_.reserve(num_groups_);
  group_feature_cnt_.reserve(num_groups_);
  group_feature_start_.push_back(0);
  group_feature_cnt_.push_back(1);
  for (int i = 1; i < num_features_; ++i) {
    const int group = feature2group_[i];
    if (group == last_group) {
      group_feature_cnt_.back() = group_feature_cnt_.back() + 1;
    } else {
      group_feature_start_.push_back(i);
      group_feature_cnt_.push_back(1);
      last_group = group;
    }
  }
Guolin Ke's avatar
Guolin Ke committed
471
  monotone_types_ = dataset->monotone_types_;
Guolin Ke's avatar
Guolin Ke committed
472
  feature_penalty_ = dataset->feature_penalty_;
Guolin Ke's avatar
Guolin Ke committed
473
474
}

Guolin Ke's avatar
Guolin Ke committed
475
476
477
void Dataset::ReSize(data_size_t num_data) {
  if (num_data_ != num_data) {
    num_data_ = num_data;
478
    OMP_INIT_EX();
Guolin Ke's avatar
Guolin Ke committed
479
    #pragma omp parallel for schedule(static)
Guolin Ke's avatar
Guolin Ke committed
480
    for (int group = 0; group < num_groups_; ++group) {
481
      OMP_LOOP_EX_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
482
      feature_groups_[group]->bin_data_->ReSize(num_data_);
483
      OMP_LOOP_EX_END();
Guolin Ke's avatar
Guolin Ke committed
484
    }
485
    OMP_THROW_EX();
Guolin Ke's avatar
Guolin Ke committed
486
487
488
489
490
  }
}

void Dataset::CopySubset(const Dataset* fullset, const data_size_t* used_indices, data_size_t num_used_indices, bool need_meta_data) {
  CHECK(num_used_indices == num_data_);
491
  OMP_INIT_EX();
Guolin Ke's avatar
Guolin Ke committed
492
  #pragma omp parallel for schedule(static)
Guolin Ke's avatar
Guolin Ke committed
493
  for (int group = 0; group < num_groups_; ++group) {
494
    OMP_LOOP_EX_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
495
    feature_groups_[group]->CopySubset(fullset->feature_groups_[group].get(), used_indices, num_used_indices);
496
    OMP_LOOP_EX_END();
Guolin Ke's avatar
Guolin Ke committed
497
  }
498
  OMP_THROW_EX();
Guolin Ke's avatar
Guolin Ke committed
499
  if (need_meta_data) {
Guolin Ke's avatar
Guolin Ke committed
500
    metadata_.Init(fullset->metadata_, used_indices, num_used_indices);
Guolin Ke's avatar
Guolin Ke committed
501
  }
Guolin Ke's avatar
Guolin Ke committed
502
  is_finish_load_ = true;
Guolin Ke's avatar
Guolin Ke committed
503
504
}

505
bool Dataset::SetFloatField(const char* field_name, const float* field_data, data_size_t num_element) {
Guolin Ke's avatar
Guolin Ke committed
506
507
508
  std::string name(field_name);
  name = Common::Trim(name);
  if (name == std::string("label") || name == std::string("target")) {
509
    #ifdef LABEL_T_USE_DOUBLE
510
    Log::Fatal("Don't support LABEL_T_USE_DOUBLE");
511
    #else
512
    metadata_.SetLabel(field_data, num_element);
513
    #endif
Guolin Ke's avatar
Guolin Ke committed
514
  } else if (name == std::string("weight") || name == std::string("weights")) {
515
    #ifdef LABEL_T_USE_DOUBLE
516
    Log::Fatal("Don't support LABEL_T_USE_DOUBLE");
517
    #else
518
    metadata_.SetWeights(field_data, num_element);
519
    #endif
Guolin Ke's avatar
Guolin Ke committed
520
521
522
523
524
525
526
527
528
529
  } else {
    return false;
  }
  return true;
}

bool Dataset::SetDoubleField(const char* field_name, const double* field_data, data_size_t num_element) {
  std::string name(field_name);
  name = Common::Trim(name);
  if (name == std::string("init_score")) {
530
    metadata_.SetInitScore(field_data, num_element);
Guolin Ke's avatar
Guolin Ke committed
531
  } else {
532
    return false;
Guolin Ke's avatar
Guolin Ke committed
533
  }
534
  return true;
Guolin Ke's avatar
Guolin Ke committed
535
536
}

537
538
539
540
bool Dataset::SetIntField(const char* field_name, const int* field_data, data_size_t num_element) {
  std::string name(field_name);
  name = Common::Trim(name);
  if (name == std::string("query") || name == std::string("group")) {
Guolin Ke's avatar
Guolin Ke committed
541
    metadata_.SetQuery(field_data, num_element);
542
543
544
545
546
547
  } else {
    return false;
  }
  return true;
}

Guolin Ke's avatar
Guolin Ke committed
548
bool Dataset::GetFloatField(const char* field_name, data_size_t* out_len, const float** out_ptr) {
549
550
551
  std::string name(field_name);
  name = Common::Trim(name);
  if (name == std::string("label") || name == std::string("target")) {
552
    #ifdef LABEL_T_USE_DOUBLE
553
    Log::Fatal("Don't support LABEL_T_USE_DOUBLE");
554
    #else
555
556
    *out_ptr = metadata_.label();
    *out_len = num_data_;
557
    #endif
558
  } else if (name == std::string("weight") || name == std::string("weights")) {
559
    #ifdef LABEL_T_USE_DOUBLE
560
    Log::Fatal("Don't support LABEL_T_USE_DOUBLE");
561
    #else
562
563
    *out_ptr = metadata_.weights();
    *out_len = num_data_;
564
    #endif
Guolin Ke's avatar
Guolin Ke committed
565
566
567
568
569
570
571
572
573
574
  } else {
    return false;
  }
  return true;
}

bool Dataset::GetDoubleField(const char* field_name, data_size_t* out_len, const double** out_ptr) {
  std::string name(field_name);
  name = Common::Trim(name);
  if (name == std::string("init_score")) {
575
    *out_ptr = metadata_.init_score();
Guolin Ke's avatar
Guolin Ke committed
576
    *out_len = static_cast<data_size_t>(metadata_.num_init_score());
577
578
579
  } else {
    return false;
  }
580
  return true;
581
582
}

Guolin Ke's avatar
Guolin Ke committed
583
bool Dataset::GetIntField(const char* field_name, data_size_t* out_len, const int** out_ptr) {
584
585
586
  std::string name(field_name);
  name = Common::Trim(name);
  if (name == std::string("query") || name == std::string("group")) {
587
    *out_ptr = metadata_.query_boundaries();
Guolin Ke's avatar
Guolin Ke committed
588
    *out_len = metadata_.num_queries() + 1;
Guolin Ke's avatar
Guolin Ke committed
589
590
591
  } else {
    return false;
  }
592
  return true;
593
594
}

Guolin Ke's avatar
Guolin Ke committed
595
void Dataset::SaveBinaryFile(const char* bin_filename) {
Guolin Ke's avatar
Guolin Ke committed
596
  if (bin_filename != nullptr
Guolin Ke's avatar
Guolin Ke committed
597
      && std::string(bin_filename) == data_filename_) {
598
    Log::Warning("Bianry file %s already exists", bin_filename);
Guolin Ke's avatar
Guolin Ke committed
599
600
    return;
  }
Guolin Ke's avatar
Guolin Ke committed
601
  // if not pass a filename, just append ".bin" of original file
Guolin Ke's avatar
Guolin Ke committed
602
  std::string bin_filename_str(data_filename_);
Guolin Ke's avatar
Guolin Ke committed
603
604
605
606
  if (bin_filename == nullptr || bin_filename[0] == '\0') {
    bin_filename_str.append(".bin");
    bin_filename = bin_filename_str.c_str();
  }
Guolin Ke's avatar
Guolin Ke committed
607
  bool is_file_existed = false;
608
609

  if (VirtualFileWriter::Exists(bin_filename)) {
Guolin Ke's avatar
Guolin Ke committed
610
    is_file_existed = true;
611
    Log::Warning("File %s exists, cannot save binary to it", bin_filename);
Guolin Ke's avatar
Guolin Ke committed
612
  }
Guolin Ke's avatar
Guolin Ke committed
613

Guolin Ke's avatar
Guolin Ke committed
614
  if (!is_file_existed) {
615
616
    auto writer = VirtualFileWriter::Make(bin_filename);
    if (!writer->Init()) {
Guolin Ke's avatar
Guolin Ke committed
617
      Log::Fatal("Cannot write binary data to %s ", bin_filename);
Guolin Ke's avatar
Guolin Ke committed
618
    }
619
    Log::Info("Saving data to binary file %s", bin_filename);
620
    size_t size_of_token = std::strlen(binary_file_token);
621
    writer->Write(binary_file_token, size_of_token);
Guolin Ke's avatar
Guolin Ke committed
622
    // get size of header
Guolin Ke's avatar
Guolin Ke committed
623
    size_t size_of_header = sizeof(num_data_) + sizeof(num_features_) + sizeof(num_total_features_)
Guolin Ke's avatar
Guolin Ke committed
624
      + sizeof(int) * num_total_features_ + sizeof(label_idx_) + sizeof(num_groups_)
Guolin Ke's avatar
Guolin Ke committed
625
      + 3 * sizeof(int) * num_features_ + sizeof(uint64_t) * (num_groups_ + 1) + 2 * sizeof(int) * num_groups_ + sizeof(int8_t) * num_features_
626
      + sizeof(double) * num_features_ + sizeof(int) * 3 + sizeof(bool) * 2;
627
628
629
630
    // size of feature names
    for (int i = 0; i < num_total_features_; ++i) {
      size_of_header += feature_names_[i].size() + sizeof(int);
    }
631
    writer->Write(&size_of_header, sizeof(size_of_header));
Guolin Ke's avatar
Guolin Ke committed
632
    // write header
633
634
635
636
    writer->Write(&num_data_, sizeof(num_data_));
    writer->Write(&num_features_, sizeof(num_features_));
    writer->Write(&num_total_features_, sizeof(num_total_features_));
    writer->Write(&label_idx_, sizeof(label_idx_));
637
638
639
640
641
    writer->Write(&max_bin_, sizeof(max_bin_));
    writer->Write(&bin_construct_sample_cnt_, sizeof(bin_construct_sample_cnt_));
    writer->Write(&min_data_in_bin_, sizeof(min_data_in_bin_));
    writer->Write(&use_missing_, sizeof(use_missing_));
    writer->Write(&zero_as_missing_, sizeof(zero_as_missing_));
642
643
644
645
646
647
648
649
    writer->Write(used_feature_map_.data(), sizeof(int) * num_total_features_);
    writer->Write(&num_groups_, sizeof(num_groups_));
    writer->Write(real_feature_idx_.data(), sizeof(int) * num_features_);
    writer->Write(feature2group_.data(), sizeof(int) * num_features_);
    writer->Write(feature2subfeature_.data(), sizeof(int) * num_features_);
    writer->Write(group_bin_boundaries_.data(), sizeof(uint64_t) * (num_groups_ + 1));
    writer->Write(group_feature_start_.data(), sizeof(int) * num_groups_);
    writer->Write(group_feature_cnt_.data(), sizeof(int) * num_groups_);
Guolin Ke's avatar
Guolin Ke committed
650
651
652
653
654
655
656
    if (monotone_types_.empty()) {
      ArrayArgs<int8_t>::Assign(&monotone_types_, 0, num_features_);
    }
    writer->Write(monotone_types_.data(), sizeof(int8_t) * num_features_);
    if (ArrayArgs<int8_t>::CheckAllZero(monotone_types_)) {
      monotone_types_.clear();
    }
Guolin Ke's avatar
Guolin Ke committed
657
658
659
660
661
662
663
    if (feature_penalty_.empty()) {
      ArrayArgs<double>::Assign(&feature_penalty_, 1.0, num_features_);
    }
    writer->Write(feature_penalty_.data(), sizeof(double) * num_features_);
    if (ArrayArgs<double>::CheckAll(feature_penalty_, 1.0)) {
      feature_penalty_.clear();
    }
664
665
666
    // write feature names
    for (int i = 0; i < num_total_features_; ++i) {
      int str_len = static_cast<int>(feature_names_[i].size());
667
      writer->Write(&str_len, sizeof(int));
668
      const char* c_str = feature_names_[i].c_str();
669
      writer->Write(c_str, sizeof(char) * str_len);
670
671
    }

Guolin Ke's avatar
Guolin Ke committed
672
673
    // get size of meta data
    size_t size_of_metadata = metadata_.SizesInByte();
674
    writer->Write(&size_of_metadata, sizeof(size_of_metadata));
Guolin Ke's avatar
Guolin Ke committed
675
    // write meta data
676
    metadata_.SaveBinaryToFile(writer.get());
Guolin Ke's avatar
Guolin Ke committed
677
678

    // write feature data
Guolin Ke's avatar
Guolin Ke committed
679
    for (int i = 0; i < num_groups_; ++i) {
Guolin Ke's avatar
Guolin Ke committed
680
      // get size of feature
Guolin Ke's avatar
Guolin Ke committed
681
      size_t size_of_feature = feature_groups_[i]->SizesInByte();
682
      writer->Write(&size_of_feature, sizeof(size_of_feature));
Guolin Ke's avatar
Guolin Ke committed
683
      // write feature
684
      feature_groups_[i]->SaveBinaryToFile(writer.get());
Guolin Ke's avatar
Guolin Ke committed
685
686
687
688
    }
  }
}

689
690
691
692
void Dataset::ConstructHistograms(const std::vector<int8_t>& is_feature_used,
                                  const data_size_t* data_indices, data_size_t num_data,
                                  int leaf_idx,
                                  std::vector<std::unique_ptr<OrderedBin>>& ordered_bins,
693
694
                                  const score_t* gradients, const score_t* hessians,
                                  score_t* ordered_gradients, score_t* ordered_hessians,
695
696
                                  bool is_constant_hessian,
                                  HistogramBinEntry* hist_data) const {
Guolin Ke's avatar
Guolin Ke committed
697

zhangjin's avatar
zhangjin committed
698
  if (leaf_idx < 0 || num_data < 0 || hist_data == nullptr) {
Guolin Ke's avatar
Guolin Ke committed
699
700
    return;
  }
Guolin Ke's avatar
Guolin Ke committed
701
702
703
704
705

  std::vector<int> used_group;
  used_group.reserve(num_groups_);
  for (int group = 0; group < num_groups_; ++group) {
    const int f_cnt = group_feature_cnt_[group];
706
    bool is_group_used = false;
Guolin Ke's avatar
Guolin Ke committed
707
708
709
    for (int j = 0; j < f_cnt; ++j) {
      const int fidx = group_feature_start_[group] + j;
      if (is_feature_used[fidx]) {
710
        is_group_used = true;
Guolin Ke's avatar
Guolin Ke committed
711
712
713
        break;
      }
    }
714
715
716
    if (is_group_used) {
      used_group.push_back(group);
    }
Guolin Ke's avatar
Guolin Ke committed
717
718
  }
  int num_used_group = static_cast<int>(used_group.size());
Guolin Ke's avatar
Guolin Ke committed
719
720
721
  auto ptr_ordered_grad = gradients;
  auto ptr_ordered_hess = hessians;
  if (data_indices != nullptr && num_data < num_data_) {
722
723
724
725
726
727
728
729
730
731
732
    if (!is_constant_hessian) {
      #pragma omp parallel for schedule(static)
      for (data_size_t i = 0; i < num_data; ++i) {
        ordered_gradients[i] = gradients[data_indices[i]];
        ordered_hessians[i] = hessians[data_indices[i]];
      }
    } else {
      #pragma omp parallel for schedule(static)
      for (data_size_t i = 0; i < num_data; ++i) {
        ordered_gradients[i] = gradients[data_indices[i]];
      }
Guolin Ke's avatar
Guolin Ke committed
733
734
735
    }
    ptr_ordered_grad = ordered_gradients;
    ptr_ordered_hess = ordered_hessians;
736
737
738
    if (!is_constant_hessian) {
      OMP_INIT_EX();
      #pragma omp parallel for schedule(static)
Guolin Ke's avatar
Guolin Ke committed
739
      for (int gi = 0; gi < num_used_group; ++gi) {
740
        OMP_LOOP_EX_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
741
        int group = used_group[gi];
742
743
744
        // feature is not used
        auto data_ptr = hist_data + group_bin_boundaries_[group];
        const int num_bin = feature_groups_[group]->num_total_bin_;
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
745
        std::memset((void*)(data_ptr + 1), 0, (num_bin - 1) * sizeof(HistogramBinEntry));
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
        // construct histograms for smaller leaf
        if (ordered_bins[group] == nullptr) {
          // if not use ordered bin
          feature_groups_[group]->bin_data_->ConstructHistogram(
            data_indices,
            num_data,
            ptr_ordered_grad,
            ptr_ordered_hess,
            data_ptr);
        } else {
          // used ordered bin
          ordered_bins[group]->ConstructHistogram(leaf_idx,
                                                  gradients,
                                                  hessians,
                                                  data_ptr);
761
        }
762
        OMP_LOOP_EX_END();
763
      }
764
765
766
767
      OMP_THROW_EX();
    } else {
      OMP_INIT_EX();
      #pragma omp parallel for schedule(static)
Guolin Ke's avatar
Guolin Ke committed
768
      for (int gi = 0; gi < num_used_group; ++gi) {
769
        OMP_LOOP_EX_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
770
        int group = used_group[gi];
771
772
773
        // feature is not used
        auto data_ptr = hist_data + group_bin_boundaries_[group];
        const int num_bin = feature_groups_[group]->num_total_bin_;
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
774
        std::memset((void*)(data_ptr + 1), 0, (num_bin - 1) * sizeof(HistogramBinEntry));
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
        // construct histograms for smaller leaf
        if (ordered_bins[group] == nullptr) {
          // if not use ordered bin
          feature_groups_[group]->bin_data_->ConstructHistogram(
            data_indices,
            num_data,
            ptr_ordered_grad,
            data_ptr);
        } else {
          // used ordered bin
          ordered_bins[group]->ConstructHistogram(leaf_idx,
                                                  gradients,
                                                  data_ptr);
        }
        // fixed hessian.
        for (int i = 0; i < num_bin; ++i) {
          data_ptr[i].sum_hessians = data_ptr[i].cnt * hessians[0];
        }
        OMP_LOOP_EX_END();
Guolin Ke's avatar
Guolin Ke committed
794
      }
795
      OMP_THROW_EX();
Guolin Ke's avatar
Guolin Ke committed
796
    }
797
  } else {
798
799
800
    if (!is_constant_hessian) {
      OMP_INIT_EX();
      #pragma omp parallel for schedule(static)
Guolin Ke's avatar
Guolin Ke committed
801
      for (int gi = 0; gi < num_used_group; ++gi) {
802
        OMP_LOOP_EX_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
803
        int group = used_group[gi];
804
805
806
        // feature is not used
        auto data_ptr = hist_data + group_bin_boundaries_[group];
        const int num_bin = feature_groups_[group]->num_total_bin_;
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
807
        std::memset((void*)(data_ptr + 1), 0, (num_bin - 1) * sizeof(HistogramBinEntry));
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
        // construct histograms for smaller leaf
        if (ordered_bins[group] == nullptr) {
          // if not use ordered bin
          feature_groups_[group]->bin_data_->ConstructHistogram(
            num_data,
            ptr_ordered_grad,
            ptr_ordered_hess,
            data_ptr);
        } else {
          // used ordered bin
          ordered_bins[group]->ConstructHistogram(leaf_idx,
                                                  gradients,
                                                  hessians,
                                                  data_ptr);
        }
        OMP_LOOP_EX_END();
824
      }
825
826
827
828
      OMP_THROW_EX();
    } else {
      OMP_INIT_EX();
      #pragma omp parallel for schedule(static)
Guolin Ke's avatar
Guolin Ke committed
829
      for (int gi = 0; gi < num_used_group; ++gi) {
830
        OMP_LOOP_EX_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
831
        int group = used_group[gi];
832
833
834
        // feature is not used
        auto data_ptr = hist_data + group_bin_boundaries_[group];
        const int num_bin = feature_groups_[group]->num_total_bin_;
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
835
        std::memset((void*)(data_ptr + 1), 0, (num_bin - 1) * sizeof(HistogramBinEntry));
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
        // construct histograms for smaller leaf
        if (ordered_bins[group] == nullptr) {
          // if not use ordered bin
          feature_groups_[group]->bin_data_->ConstructHistogram(
            num_data,
            ptr_ordered_grad,
            data_ptr);
        } else {
          // used ordered bin
          ordered_bins[group]->ConstructHistogram(leaf_idx,
                                                  gradients,
                                                  data_ptr);
        }
        // fixed hessian.
        for (int i = 0; i < num_bin; ++i) {
          data_ptr[i].sum_hessians = data_ptr[i].cnt * hessians[0];
        }
        OMP_LOOP_EX_END();
854
      }
855
      OMP_THROW_EX();
Guolin Ke's avatar
Guolin Ke committed
856
857
858
859
860
    }
  }
}

void Dataset::FixHistogram(int feature_idx, double sum_gradient, double sum_hessian, data_size_t num_data,
861
                           HistogramBinEntry* data) const {
Guolin Ke's avatar
Guolin Ke committed
862
863
864
865
866
867
  const int group = feature2group_[feature_idx];
  const int sub_feature = feature2subfeature_[feature_idx];
  const BinMapper* bin_mapper = feature_groups_[group]->bin_mappers_[sub_feature].get();
  const int default_bin = bin_mapper->GetDefaultBin();
  if (default_bin > 0) {
    const int num_bin = bin_mapper->num_bin();
868
869
870
    data[default_bin].sum_gradients = sum_gradient;
    data[default_bin].sum_hessians = sum_hessian;
    data[default_bin].cnt = num_data;
Guolin Ke's avatar
Guolin Ke committed
871
872
    for (int i = 0; i < num_bin; ++i) {
      if (i != default_bin) {
873
874
875
        data[default_bin].sum_gradients -= data[i].sum_gradients;
        data[default_bin].sum_hessians -= data[i].sum_hessians;
        data[default_bin].cnt -= data[i].cnt;
Guolin Ke's avatar
Guolin Ke committed
876
877
878
879
880
      }
    }
  }
}

Guolin Ke's avatar
Guolin Ke committed
881
}  // namespace LightGBM