dataset.cpp 37.9 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
#include <cstdio>
#include <unordered_map>
#include <limits>
11
#include <memory>
Guolin Ke's avatar
Guolin Ke committed
12
13
14
#include <vector>
#include <utility>
#include <string>
Guolin Ke's avatar
Guolin Ke committed
15
#include <sstream>
Guolin Ke's avatar
Guolin Ke committed
16
17
18

namespace LightGBM {

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

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

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

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

Guolin Ke's avatar
Guolin Ke committed
39
40
41
42
43
44
45
46
47
48
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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
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
74
75
                                         data_size_t num_data,
                                         bool is_use_gpu) {
Guolin Ke's avatar
Guolin Ke committed
76
  const int max_search_group = 100;
Guolin Ke's avatar
Guolin Ke committed
77
  const int gpu_max_bin_per_group = 256;
Guolin Ke's avatar
Guolin Ke committed
78
79
80
81
82
83
84
85
86
87
88
89
  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) {
90
      if (group_non_zero_cnt[gid] + cur_non_zero_cnt <= total_sample_cnt + max_error_cnt) {
Guolin Ke's avatar
Guolin Ke committed
91
92
93
94
        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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
      }
    }
    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
118
119
120
        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
121
122
123
124
125
126
127
128
129
130
        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
131
132
133
      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
134
135
136
137
138
139
140
141
142
143
144
145
146
147
    }
  }
  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
148
149
                                                  bool is_enable_sparse,
                                                  bool is_use_gpu) {
Guolin Ke's avatar
Guolin Ke committed
150
151
152
153
  // 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;
154
  feature_non_zero_cnt.reserve(used_features.size());
Guolin Ke's avatar
Guolin Ke committed
155
156
157
158
159
160
  // 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;
161
  sorted_idx.reserve(used_features.size());
162
  for (int i = 0; i < static_cast<int>(used_features.size()); ++i) {
Guolin Ke's avatar
Guolin Ke committed
163
164
165
    sorted_idx.emplace_back(i);
  }
  // sort by non zero cnt, bigger first
166
167
  std::stable_sort(sorted_idx.begin(), sorted_idx.end(),
                   [&feature_non_zero_cnt](int a, int b) {
Guolin Ke's avatar
Guolin Ke committed
168
169
170
171
    return feature_non_zero_cnt[a] > feature_non_zero_cnt[b];
  });

  std::vector<int> feature_order_by_cnt;
172
  feature_order_by_cnt.reserve(sorted_idx.size());
Guolin Ke's avatar
Guolin Ke committed
173
174
175
  for (auto sidx : sorted_idx) {
    feature_order_by_cnt.push_back(used_features[sidx]);
  }
Guolin Ke's avatar
Guolin Ke committed
176
177
  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
178
179
180
181
182
183
184
185
186
187
188
189
190
191
  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);
192
      // take apart small sparse group, due it will not gain on speed
Guolin Ke's avatar
Guolin Ke committed
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
      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
214
215
void Dataset::Construct(
  std::vector<std::unique_ptr<BinMapper>>& bin_mappers,
Guolin Ke's avatar
Guolin Ke committed
216
217
218
  int** sample_non_zero_indices,
  const int* num_per_col,
  size_t total_sample_cnt,
Guolin Ke's avatar
Guolin Ke committed
219
  const Config& io_config) {
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
  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.");
  }
Guolin Ke's avatar
Guolin Ke committed
346
347
348
349
  if (param.count("sparse_threshold") && io_config.sparse_threshold != sparse_threshold_) {
    Log::Warning("Cannot change sparse_threshold after constructed Dataset handle.");
  }

350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
  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
376
377
}

Guolin Ke's avatar
Guolin Ke committed
378
void Dataset::FinishLoad() {
Guolin Ke's avatar
Guolin Ke committed
379
  if (is_finish_load_) { return; }
380
381
382
383
384
385
386
387
388
  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
389
  }
Guolin Ke's avatar
Guolin Ke committed
390
  is_finish_load_ = true;
Guolin Ke's avatar
Guolin Ke committed
391
}
Guolin Ke's avatar
Guolin Ke committed
392

393
void Dataset::CopyFeatureMapperFrom(const Dataset* dataset) {
Guolin Ke's avatar
Guolin Ke committed
394
  feature_groups_.clear();
Guolin Ke's avatar
Guolin Ke committed
395
  num_features_ = dataset->num_features_;
Guolin Ke's avatar
Guolin Ke committed
396
  num_groups_ = dataset->num_groups_;
397
  sparse_threshold_ = dataset->sparse_threshold_;
Guolin Ke's avatar
Guolin Ke committed
398
  // copy feature bin mapper data
Guolin Ke's avatar
Guolin Ke committed
399
400
401
402
403
404
405
406
  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
407
      num_data_,
Guolin Ke's avatar
Guolin Ke committed
408
      dataset->feature_groups_[i]->is_sparse_));
Guolin Ke's avatar
Guolin Ke committed
409
  }
Guolin Ke's avatar
Guolin Ke committed
410
  feature_groups_.shrink_to_fit();
Guolin Ke's avatar
Guolin Ke committed
411
412
413
  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
414
  label_idx_ = dataset->label_idx_;
Guolin Ke's avatar
Guolin Ke committed
415
416
417
418
419
420
  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
421
  monotone_types_ = dataset->monotone_types_;
Guolin Ke's avatar
Guolin Ke committed
422
  feature_penalty_ = dataset->feature_penalty_;
Guolin Ke's avatar
Guolin Ke committed
423
424
425
426
427
428
}

void Dataset::CreateValid(const Dataset* dataset) {
  feature_groups_.clear();
  num_features_ = dataset->num_features_;
  num_groups_ = num_features_;
429
  sparse_threshold_ = dataset->sparse_threshold_;
Guolin Ke's avatar
Guolin Ke committed
430
431
432
433
434
435
436
437
438
439
440
  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_,
Guolin Ke's avatar
Guolin Ke committed
441
      sparse_threshold_,
Guolin Ke's avatar
Guolin Ke committed
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
471
472
473
474
      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
475
  monotone_types_ = dataset->monotone_types_;
Guolin Ke's avatar
Guolin Ke committed
476
  feature_penalty_ = dataset->feature_penalty_;
Guolin Ke's avatar
Guolin Ke committed
477
478
}

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

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_);
495
  OMP_INIT_EX();
Guolin Ke's avatar
Guolin Ke committed
496
  #pragma omp parallel for schedule(static)
Guolin Ke's avatar
Guolin Ke committed
497
  for (int group = 0; group < num_groups_; ++group) {
498
    OMP_LOOP_EX_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
499
    feature_groups_[group]->CopySubset(fullset->feature_groups_[group].get(), used_indices, num_used_indices);
500
    OMP_LOOP_EX_END();
Guolin Ke's avatar
Guolin Ke committed
501
  }
502
  OMP_THROW_EX();
Guolin Ke's avatar
Guolin Ke committed
503
  if (need_meta_data) {
Guolin Ke's avatar
Guolin Ke committed
504
    metadata_.Init(fullset->metadata_, used_indices, num_used_indices);
Guolin Ke's avatar
Guolin Ke committed
505
  }
Guolin Ke's avatar
Guolin Ke committed
506
  is_finish_load_ = true;
Guolin Ke's avatar
Guolin Ke committed
507
508
}

509
bool Dataset::SetFloatField(const char* field_name, const float* field_data, data_size_t num_element) {
Guolin Ke's avatar
Guolin Ke committed
510
511
512
  std::string name(field_name);
  name = Common::Trim(name);
  if (name == std::string("label") || name == std::string("target")) {
513
    #ifdef LABEL_T_USE_DOUBLE
514
    Log::Fatal("Don't support LABEL_T_USE_DOUBLE");
515
    #else
516
    metadata_.SetLabel(field_data, num_element);
517
    #endif
Guolin Ke's avatar
Guolin Ke committed
518
  } else if (name == std::string("weight") || name == std::string("weights")) {
519
    #ifdef LABEL_T_USE_DOUBLE
520
    Log::Fatal("Don't support LABEL_T_USE_DOUBLE");
521
    #else
522
    metadata_.SetWeights(field_data, num_element);
523
    #endif
Guolin Ke's avatar
Guolin Ke committed
524
525
526
527
528
529
530
531
532
533
  } 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")) {
534
    metadata_.SetInitScore(field_data, num_element);
Guolin Ke's avatar
Guolin Ke committed
535
  } else {
536
    return false;
Guolin Ke's avatar
Guolin Ke committed
537
  }
538
  return true;
Guolin Ke's avatar
Guolin Ke committed
539
540
}

541
542
543
544
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
545
    metadata_.SetQuery(field_data, num_element);
546
547
548
549
550
551
  } else {
    return false;
  }
  return true;
}

Guolin Ke's avatar
Guolin Ke committed
552
bool Dataset::GetFloatField(const char* field_name, data_size_t* out_len, const float** out_ptr) {
553
554
555
  std::string name(field_name);
  name = Common::Trim(name);
  if (name == std::string("label") || name == std::string("target")) {
556
    #ifdef LABEL_T_USE_DOUBLE
557
    Log::Fatal("Don't support LABEL_T_USE_DOUBLE");
558
    #else
559
560
    *out_ptr = metadata_.label();
    *out_len = num_data_;
561
    #endif
562
  } else if (name == std::string("weight") || name == std::string("weights")) {
563
    #ifdef LABEL_T_USE_DOUBLE
564
    Log::Fatal("Don't support LABEL_T_USE_DOUBLE");
565
    #else
566
567
    *out_ptr = metadata_.weights();
    *out_len = num_data_;
568
    #endif
Guolin Ke's avatar
Guolin Ke committed
569
570
571
572
573
574
575
576
577
578
  } 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")) {
579
    *out_ptr = metadata_.init_score();
Guolin Ke's avatar
Guolin Ke committed
580
    *out_len = static_cast<data_size_t>(metadata_.num_init_score());
581
  } else if (name == std::string("feature_penalty")) {
582
    *out_ptr = feature_penalty_.data();
Guolin Ke's avatar
Guolin Ke committed
583
    *out_len = static_cast<data_size_t>(feature_penalty_.size());
584
  } else {
585
586
    return false;
  }
587
  return true;
588
589
}

Guolin Ke's avatar
Guolin Ke committed
590
bool Dataset::GetIntField(const char* field_name, data_size_t* out_len, const int** out_ptr) {
591
592
593
  std::string name(field_name);
  name = Common::Trim(name);
  if (name == std::string("query") || name == std::string("group")) {
594
    *out_ptr = metadata_.query_boundaries();
Guolin Ke's avatar
Guolin Ke committed
595
    *out_len = metadata_.num_queries() + 1;
Guolin Ke's avatar
Guolin Ke committed
596
597
598
  } else {
    return false;
  }
599
  return true;
600
601
}

602
603
604
605
606
bool Dataset::GetInt8Field(const char* field_name, data_size_t* out_len, const int8_t** out_ptr) {
  std::string name(field_name);
  name = Common::Trim(name);
  if (name == std::string("monotone_constraints")) {
    *out_ptr = monotone_types_.data();
Guolin Ke's avatar
Guolin Ke committed
607
    *out_len = static_cast<data_size_t>(monotone_types_.size());
608
609
610
611
612
613
  } else {
    return false;
  }
  return true;
}

Guolin Ke's avatar
Guolin Ke committed
614
void Dataset::SaveBinaryFile(const char* bin_filename) {
Guolin Ke's avatar
Guolin Ke committed
615
  if (bin_filename != nullptr
Guolin Ke's avatar
Guolin Ke committed
616
      && std::string(bin_filename) == data_filename_) {
617
    Log::Warning("Bianry file %s already exists", bin_filename);
Guolin Ke's avatar
Guolin Ke committed
618
619
    return;
  }
Guolin Ke's avatar
Guolin Ke committed
620
  // if not pass a filename, just append ".bin" of original file
Guolin Ke's avatar
Guolin Ke committed
621
  std::string bin_filename_str(data_filename_);
Guolin Ke's avatar
Guolin Ke committed
622
623
624
625
  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
626
  bool is_file_existed = false;
627
628

  if (VirtualFileWriter::Exists(bin_filename)) {
Guolin Ke's avatar
Guolin Ke committed
629
    is_file_existed = true;
630
    Log::Warning("File %s exists, cannot save binary to it", bin_filename);
Guolin Ke's avatar
Guolin Ke committed
631
  }
Guolin Ke's avatar
Guolin Ke committed
632

Guolin Ke's avatar
Guolin Ke committed
633
  if (!is_file_existed) {
634
635
    auto writer = VirtualFileWriter::Make(bin_filename);
    if (!writer->Init()) {
Guolin Ke's avatar
Guolin Ke committed
636
      Log::Fatal("Cannot write binary data to %s ", bin_filename);
Guolin Ke's avatar
Guolin Ke committed
637
    }
638
    Log::Info("Saving data to binary file %s", bin_filename);
639
    size_t size_of_token = std::strlen(binary_file_token);
640
    writer->Write(binary_file_token, size_of_token);
Guolin Ke's avatar
Guolin Ke committed
641
    // get size of header
Guolin Ke's avatar
Guolin Ke committed
642
    size_t size_of_header = sizeof(num_data_) + sizeof(num_features_) + sizeof(num_total_features_)
Guolin Ke's avatar
Guolin Ke committed
643
      + sizeof(int) * num_total_features_ + sizeof(label_idx_) + sizeof(num_groups_) + sizeof(sparse_threshold_)
Guolin Ke's avatar
Guolin Ke committed
644
      + 3 * sizeof(int) * num_features_ + sizeof(uint64_t) * (num_groups_ + 1) + 2 * sizeof(int) * num_groups_ + sizeof(int8_t) * num_features_
645
      + sizeof(double) * num_features_ + sizeof(int) * 3 + sizeof(bool) * 2;
646
647
648
649
    // size of feature names
    for (int i = 0; i < num_total_features_; ++i) {
      size_of_header += feature_names_[i].size() + sizeof(int);
    }
650
    writer->Write(&size_of_header, sizeof(size_of_header));
Guolin Ke's avatar
Guolin Ke committed
651
    // write header
652
653
654
655
    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_));
656
657
658
659
660
    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_));
Guolin Ke's avatar
Guolin Ke committed
661
    writer->Write(&sparse_threshold_, sizeof(sparse_threshold_));
662
663
664
665
666
667
668
669
    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
670
671
672
673
674
675
676
    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
677
678
679
680
681
682
683
    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();
    }
684
685
686
    // write feature names
    for (int i = 0; i < num_total_features_; ++i) {
      int str_len = static_cast<int>(feature_names_[i].size());
687
      writer->Write(&str_len, sizeof(int));
688
      const char* c_str = feature_names_[i].c_str();
689
      writer->Write(c_str, sizeof(char) * str_len);
690
691
    }

Guolin Ke's avatar
Guolin Ke committed
692
693
    // get size of meta data
    size_t size_of_metadata = metadata_.SizesInByte();
694
    writer->Write(&size_of_metadata, sizeof(size_of_metadata));
Guolin Ke's avatar
Guolin Ke committed
695
    // write meta data
696
    metadata_.SaveBinaryToFile(writer.get());
Guolin Ke's avatar
Guolin Ke committed
697
698

    // write feature data
Guolin Ke's avatar
Guolin Ke committed
699
    for (int i = 0; i < num_groups_; ++i) {
Guolin Ke's avatar
Guolin Ke committed
700
      // get size of feature
Guolin Ke's avatar
Guolin Ke committed
701
      size_t size_of_feature = feature_groups_[i]->SizesInByte();
702
      writer->Write(&size_of_feature, sizeof(size_of_feature));
Guolin Ke's avatar
Guolin Ke committed
703
      // write feature
704
      feature_groups_[i]->SaveBinaryToFile(writer.get());
Guolin Ke's avatar
Guolin Ke committed
705
706
707
708
    }
  }
}

709
void Dataset::DumpTextFile(const char* text_filename) {
Guolin Ke's avatar
Guolin Ke committed
710
711
712
713
714
715
  FILE* file = NULL;
#if _MSC_VER
  fopen_s(&file, text_filename, "wt");
#else
  file = fopen(text_filename, "wt");
#endif
716
717
718
719
720
  fprintf(file, "num_features: %d\n", num_features_);
  fprintf(file, "num_total_features: %d\n", num_total_features_);
  fprintf(file, "num_groups: %d\n", num_groups_);
  fprintf(file, "num_data: %d\n", num_data_);
  fprintf(file, "feature_names: ");
721
  for (auto n : feature_names_) {
722
723
724
    fprintf(file, "%s, ", n.c_str());
  }
  fprintf(file, "\nmonotone_constraints: ");
725
  for (auto i : monotone_types_) {
726
727
728
    fprintf(file, "%d, ", i);
  }
  fprintf(file, "\nfeature_penalty: ");
729
  for (auto i : feature_penalty_) {
730
731
732
    fprintf(file, "%lf, ", i);
  }
  fprintf(file, "\n");
733
  for (auto n : feature_names_) {
734
735
736
737
    fprintf(file, "%s, ", n.c_str());
  }
  std::vector<std::unique_ptr<BinIterator>> iterators;
  iterators.reserve(num_features_);
738
  for (int j = 0; j < num_features_; ++j) {
739
740
741
742
    auto group_idx = feature2group_[j];
    auto sub_idx = feature2subfeature_[j];
    iterators.emplace_back(feature_groups_[group_idx]->SubFeatureIterator(sub_idx));
  }
743
  for (data_size_t i = 0; i < num_data_; ++i) {
744
    fprintf(file, "\n");
745
    for (int j = 0; j < num_total_features_; ++j) {
746
      auto inner_feature_idx = used_feature_map_[j];
747
748
      if (inner_feature_idx < 0) {
        fprintf(file, "NA, ");
749
      } else {
750
        fprintf(file, "%d, ", iterators[inner_feature_idx]->RawGet(i));
751
752
753
754
755
756
      }
    }
  }
  fclose(file);
}

757
758
759
760
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,
761
762
                                  const score_t* gradients, const score_t* hessians,
                                  score_t* ordered_gradients, score_t* ordered_hessians,
763
764
                                  bool is_constant_hessian,
                                  HistogramBinEntry* hist_data) const {
zhangjin's avatar
zhangjin committed
765
  if (leaf_idx < 0 || num_data < 0 || hist_data == nullptr) {
Guolin Ke's avatar
Guolin Ke committed
766
767
    return;
  }
Guolin Ke's avatar
Guolin Ke committed
768
769
770
771
772

  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];
773
    bool is_group_used = false;
Guolin Ke's avatar
Guolin Ke committed
774
775
776
    for (int j = 0; j < f_cnt; ++j) {
      const int fidx = group_feature_start_[group] + j;
      if (is_feature_used[fidx]) {
777
        is_group_used = true;
Guolin Ke's avatar
Guolin Ke committed
778
779
780
        break;
      }
    }
781
782
783
    if (is_group_used) {
      used_group.push_back(group);
    }
Guolin Ke's avatar
Guolin Ke committed
784
785
  }
  int num_used_group = static_cast<int>(used_group.size());
Guolin Ke's avatar
Guolin Ke committed
786
787
788
  auto ptr_ordered_grad = gradients;
  auto ptr_ordered_hess = hessians;
  if (data_indices != nullptr && num_data < num_data_) {
789
790
791
792
793
794
795
796
797
798
799
    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
800
801
802
    }
    ptr_ordered_grad = ordered_gradients;
    ptr_ordered_hess = ordered_hessians;
803
804
805
    if (!is_constant_hessian) {
      OMP_INIT_EX();
      #pragma omp parallel for schedule(static)
Guolin Ke's avatar
Guolin Ke committed
806
      for (int gi = 0; gi < num_used_group; ++gi) {
807
        OMP_LOOP_EX_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
808
        int group = used_group[gi];
809
810
811
        // 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
812
        std::memset((void*)(data_ptr + 1), 0, (num_bin - 1) * sizeof(HistogramBinEntry));
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
        // 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);
828
        }
829
        OMP_LOOP_EX_END();
830
      }
831
832
833
834
      OMP_THROW_EX();
    } else {
      OMP_INIT_EX();
      #pragma omp parallel for schedule(static)
Guolin Ke's avatar
Guolin Ke committed
835
      for (int gi = 0; gi < num_used_group; ++gi) {
836
        OMP_LOOP_EX_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
837
        int group = used_group[gi];
838
839
840
        // 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
841
        std::memset((void*)(data_ptr + 1), 0, (num_bin - 1) * sizeof(HistogramBinEntry));
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
        // 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
861
      }
862
      OMP_THROW_EX();
Guolin Ke's avatar
Guolin Ke committed
863
    }
864
  } else {
865
866
867
    if (!is_constant_hessian) {
      OMP_INIT_EX();
      #pragma omp parallel for schedule(static)
Guolin Ke's avatar
Guolin Ke committed
868
      for (int gi = 0; gi < num_used_group; ++gi) {
869
        OMP_LOOP_EX_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
870
        int group = used_group[gi];
871
872
873
        // 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
874
        std::memset((void*)(data_ptr + 1), 0, (num_bin - 1) * sizeof(HistogramBinEntry));
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
        // 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();
891
      }
892
893
894
895
      OMP_THROW_EX();
    } else {
      OMP_INIT_EX();
      #pragma omp parallel for schedule(static)
Guolin Ke's avatar
Guolin Ke committed
896
      for (int gi = 0; gi < num_used_group; ++gi) {
897
        OMP_LOOP_EX_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
898
        int group = used_group[gi];
899
900
901
        // 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
902
        std::memset((void*)(data_ptr + 1), 0, (num_bin - 1) * sizeof(HistogramBinEntry));
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
        // 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();
921
      }
922
      OMP_THROW_EX();
Guolin Ke's avatar
Guolin Ke committed
923
924
925
926
927
    }
  }
}

void Dataset::FixHistogram(int feature_idx, double sum_gradient, double sum_hessian, data_size_t num_data,
928
                           HistogramBinEntry* data) const {
Guolin Ke's avatar
Guolin Ke committed
929
930
931
932
933
934
  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();
935
936
937
    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
938
939
    for (int i = 0; i < num_bin; ++i) {
      if (i != default_bin) {
940
941
942
        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
943
944
945
946
947
      }
    }
  }
}

948
template<typename T>
949
void PushVector(std::vector<T>& dest, const std::vector<T>& src) {
950
  dest.reserve(dest.size() + src.size());
951
  for (auto i : src) {
952
953
954
955
956
    dest.push_back(i);
  }
}

template<typename T>
957
void PushOffset(std::vector<T>& dest, const std::vector<T>& src, const T& offset) {
958
  dest.reserve(dest.size() + src.size());
959
  for (auto i : src) {
960
961
962
963
964
    dest.push_back(i + offset);
  }
}

template<typename T>
965
966
void PushClearIfEmpty(std::vector<T>& dest, const size_t dest_len, const std::vector<T>& src, const size_t src_len, const T& deflt) {
  if (!dest.empty() && !src.empty()) {
967
    PushVector(dest, src);
968
969
  } else if (!dest.empty() && src.empty()) {
    for (size_t i = 0; i < src_len; ++i) {
970
971
      dest.push_back(deflt);
    }
972
973
  } else if (dest.empty() && !src.empty()) {
    for (size_t i = 0; i < dest_len; ++i) {
974
975
976
977
978
979
      dest.push_back(deflt);
    }
    PushVector(dest, src);
  }
}

980
981
void Dataset::addFeaturesFrom(Dataset* other) {
  if (other->num_data_ != num_data_) {
982
983
984
985
986
987
    throw std::runtime_error("Cannot add features from other Dataset with a different number of rows");
  }
  PushVector(feature_names_, other->feature_names_);
  PushVector(feature2subfeature_, other->feature2subfeature_);
  PushVector(group_feature_cnt_, other->group_feature_cnt_);
  feature_groups_.reserve(other->feature_groups_.size());
988
  for (auto& fg : other->feature_groups_) {
989
990
    feature_groups_.emplace_back(new FeatureGroup(*fg));
  }
991
992
  for (auto feature_idx : other->used_feature_map_) {
    if (feature_idx >= 0) {
993
994
995
996
997
998
999
1000
1001
      used_feature_map_.push_back(feature_idx + num_features_);
    } else {
      used_feature_map_.push_back(-1);  // Unused feature.
    }
  }
  PushOffset(real_feature_idx_, other->real_feature_idx_, num_total_features_);
  PushOffset(feature2group_, other->feature2group_, num_groups_);
  auto bin_offset = group_bin_boundaries_.back();
  // Skip the leading 0 when copying group_bin_boundaries.
1002
  for (auto i = other->group_bin_boundaries_.begin()+1; i < other->group_bin_boundaries_.end(); ++i) {
1003
1004
1005
1006
1007
1008
    group_bin_boundaries_.push_back(*i + bin_offset);
  }
  PushOffset(group_feature_start_, other->group_feature_start_, num_features_);

  PushClearIfEmpty(monotone_types_, num_total_features_, other->monotone_types_, other->num_total_features_, (int8_t)0);
  PushClearIfEmpty(feature_penalty_, num_total_features_, other->feature_penalty_, other->num_total_features_, 1.0);
1009

1010
1011
1012
1013
1014
  num_features_ += other->num_features_;
  num_total_features_ += other->num_total_features_;
  num_groups_ += other->num_groups_;
}

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