c_api.cpp 97 KB
Newer Older
1
2
3
4
/*!
 * Copyright (c) 2016 Microsoft Corporation. All rights reserved.
 * Licensed under the MIT License. See LICENSE file in the project root for license information.
 */
Guolin Ke's avatar
Guolin Ke committed
5
#include <LightGBM/c_api.h>
Guolin Ke's avatar
Guolin Ke committed
6

Guolin Ke's avatar
Guolin Ke committed
7
8
#include <LightGBM/boosting.h>
#include <LightGBM/config.h>
9
10
11
#include <LightGBM/dataset.h>
#include <LightGBM/dataset_loader.h>
#include <LightGBM/metric.h>
12
#include <LightGBM/network.h>
13
14
15
16
17
18
19
#include <LightGBM/objective_function.h>
#include <LightGBM/prediction_early_stop.h>
#include <LightGBM/utils/common.h>
#include <LightGBM/utils/log.h>
#include <LightGBM/utils/openmp_wrapper.h>
#include <LightGBM/utils/random.h>
#include <LightGBM/utils/threading.h>
Guolin Ke's avatar
Guolin Ke committed
20

21
22
23
24
25
26
27
28
#include <string>
#include <cstdio>
#include <functional>
#include <memory>
#include <mutex>
#include <stdexcept>
#include <vector>

29
#include "application/predictor.hpp"
30
31
#include <LightGBM/utils/yamc/alternate_shared_mutex.hpp>
#include <LightGBM/utils/yamc/yamc_shared_lock.hpp>
Guolin Ke's avatar
Guolin Ke committed
32

Guolin Ke's avatar
Guolin Ke committed
33
34
namespace LightGBM {

Guolin Ke's avatar
Guolin Ke committed
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
inline int LGBM_APIHandleException(const std::exception& ex) {
  LGBM_SetLastError(ex.what());
  return -1;
}
inline int LGBM_APIHandleException(const std::string& ex) {
  LGBM_SetLastError(ex.c_str());
  return -1;
}

#define API_BEGIN() try {
#define API_END() } \
catch(std::exception& ex) { return LGBM_APIHandleException(ex); } \
catch(std::string& ex) { return LGBM_APIHandleException(ex); } \
catch(...) { return LGBM_APIHandleException("unknown exception"); } \
return 0;

51
52
53
54
55
56
#define UNIQUE_LOCK(mtx) \
std::unique_lock<yamc::alternate::shared_mutex> lock(mtx);

#define SHARED_LOCK(mtx) \
yamc::shared_lock<yamc::alternate::shared_mutex> lock(&mtx);

57
58
59
60
61
62
63
64
const int PREDICTOR_TYPES = 4;

// Single row predictor to abstract away caching logic
class SingleRowPredictor {
 public:
  PredictFunction predict_function;
  int64_t num_pred_in_one_row;

65
  SingleRowPredictor(int predict_type, Boosting* boosting, const Config& config, int start_iter, int num_iter) {
66
67
68
69
70
71
72
73
74
75
76
77
78
    bool is_predict_leaf = false;
    bool is_raw_score = false;
    bool predict_contrib = false;
    if (predict_type == C_API_PREDICT_LEAF_INDEX) {
      is_predict_leaf = true;
    } else if (predict_type == C_API_PREDICT_RAW_SCORE) {
      is_raw_score = true;
    } else if (predict_type == C_API_PREDICT_CONTRIB) {
      predict_contrib = true;
    }
    early_stop_ = config.pred_early_stop;
    early_stop_freq_ = config.pred_early_stop_freq;
    early_stop_margin_ = config.pred_early_stop_margin;
79
80
    iter_ = num_iter;
    predictor_.reset(new Predictor(boosting, start_iter, iter_, is_raw_score, is_predict_leaf, predict_contrib,
81
                                   early_stop_, early_stop_freq_, early_stop_margin_));
82
    num_pred_in_one_row = boosting->NumPredictOneRow(start_iter, iter_, is_predict_leaf, predict_contrib);
83
    predict_function = predictor_->GetPredictFunction();
Guolin Ke's avatar
Guolin Ke committed
84
    num_total_model_ = boosting->NumberOfTotalModel();
85
  }
86

87
  ~SingleRowPredictor() {}
88

Guolin Ke's avatar
Guolin Ke committed
89
  bool IsPredictorEqual(const Config& config, int iter, Boosting* boosting) {
90
91
92
93
94
    return early_stop_ == config.pred_early_stop &&
      early_stop_freq_ == config.pred_early_stop_freq &&
      early_stop_margin_ == config.pred_early_stop_margin &&
      iter_ == iter &&
      num_total_model_ == boosting->NumberOfTotalModel();
95
  }
Guolin Ke's avatar
Guolin Ke committed
96

97
98
99
100
101
102
103
104
105
 private:
  std::unique_ptr<Predictor> predictor_;
  bool early_stop_;
  int early_stop_freq_;
  double early_stop_margin_;
  int iter_;
  int num_total_model_;
};

Guolin Ke's avatar
Guolin Ke committed
106
class Booster {
Nikita Titov's avatar
Nikita Titov committed
107
 public:
Guolin Ke's avatar
Guolin Ke committed
108
  explicit Booster(const char* filename) {
109
    boosting_.reset(Boosting::CreateBoosting("gbdt", filename));
110
111
  }

Guolin Ke's avatar
Guolin Ke committed
112
  Booster(const Dataset* train_data,
113
          const char* parameters) {
Guolin Ke's avatar
Guolin Ke committed
114
    auto param = Config::Str2Map(parameters);
wxchan's avatar
wxchan committed
115
    config_.Set(param);
116
117
118
    if (config_.num_threads > 0) {
      omp_set_num_threads(config_.num_threads);
    }
Guolin Ke's avatar
Guolin Ke committed
119
    // create boosting
Guolin Ke's avatar
Guolin Ke committed
120
    if (config_.input_model.size() > 0) {
121
122
      Log::Warning("Continued train from model is not supported for c_api,\n"
                   "please use continued train with input score");
Guolin Ke's avatar
Guolin Ke committed
123
    }
Guolin Ke's avatar
Guolin Ke committed
124

Guolin Ke's avatar
Guolin Ke committed
125
    boosting_.reset(Boosting::CreateBoosting(config_.boosting, nullptr));
Guolin Ke's avatar
Guolin Ke committed
126

127
128
    train_data_ = train_data;
    CreateObjectiveAndMetrics();
Guolin Ke's avatar
Guolin Ke committed
129
    // initialize the boosting
Guolin Ke's avatar
Guolin Ke committed
130
    if (config_.tree_learner == std::string("feature")) {
131
      Log::Fatal("Do not support feature parallel in c api");
132
    }
Guolin Ke's avatar
Guolin Ke committed
133
    if (Network::num_machines() == 1 && config_.tree_learner != std::string("serial")) {
134
      Log::Warning("Only find one worker, will switch to serial tree learner");
Guolin Ke's avatar
Guolin Ke committed
135
      config_.tree_learner = "serial";
136
    }
Guolin Ke's avatar
Guolin Ke committed
137
    boosting_->Init(&config_, train_data_, objective_fun_.get(),
138
                    Common::ConstPtrInVectorWrapper<Metric>(train_metric_));
wxchan's avatar
wxchan committed
139
140
141
  }

  void MergeFrom(const Booster* other) {
142
    UNIQUE_LOCK(mutex_)
wxchan's avatar
wxchan committed
143
    boosting_->MergeFrom(other->boosting_.get());
Guolin Ke's avatar
Guolin Ke committed
144
145
146
147
  }

  ~Booster() {
  }
148

149
  void CreateObjectiveAndMetrics() {
Guolin Ke's avatar
Guolin Ke committed
150
    // create objective function
Guolin Ke's avatar
Guolin Ke committed
151
152
    objective_fun_.reset(ObjectiveFunction::CreateObjectiveFunction(config_.objective,
                                                                    config_));
Guolin Ke's avatar
Guolin Ke committed
153
154
155
156
157
158
159
160
161
162
    if (objective_fun_ == nullptr) {
      Log::Warning("Using self-defined objective function");
    }
    // initialize the objective function
    if (objective_fun_ != nullptr) {
      objective_fun_->Init(train_data_->metadata(), train_data_->num_data());
    }

    // create training metric
    train_metric_.clear();
Guolin Ke's avatar
Guolin Ke committed
163
    for (auto metric_type : config_.metric) {
Guolin Ke's avatar
Guolin Ke committed
164
      auto metric = std::unique_ptr<Metric>(
Guolin Ke's avatar
Guolin Ke committed
165
        Metric::CreateMetric(metric_type, config_));
Guolin Ke's avatar
Guolin Ke committed
166
167
168
169
170
      if (metric == nullptr) { continue; }
      metric->Init(train_data_->metadata(), train_data_->num_data());
      train_metric_.push_back(std::move(metric));
    }
    train_metric_.shrink_to_fit();
171
172
173
174
  }

  void ResetTrainingData(const Dataset* train_data) {
    if (train_data != train_data_) {
175
      UNIQUE_LOCK(mutex_)
176
177
178
179
180
181
      train_data_ = train_data;
      CreateObjectiveAndMetrics();
      // reset the boosting
      boosting_->ResetTrainingData(train_data_,
                                   objective_fun_.get(), Common::ConstPtrInVectorWrapper<Metric>(train_metric_));
    }
wxchan's avatar
wxchan committed
182
183
  }

184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
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
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
  static void CheckDatasetResetConfig(
      const Config& old_config,
      const std::unordered_map<std::string, std::string>& new_param) {
    Config new_config;
    new_config.Set(new_param);
    if (new_param.count("data_random_seed") &&
        new_config.data_random_seed != old_config.data_random_seed) {
      Log::Fatal("Cannot change data_random_seed after constructed Dataset handle.");
    }
    if (new_param.count("max_bin") &&
        new_config.max_bin != old_config.max_bin) {
      Log::Fatal("Cannot change max_bin after constructed Dataset handle.");
    }
    if (new_param.count("max_bin_by_feature") &&
        new_config.max_bin_by_feature != old_config.max_bin_by_feature) {
      Log::Fatal(
          "Cannot change max_bin_by_feature after constructed Dataset handle.");
    }
    if (new_param.count("bin_construct_sample_cnt") &&
        new_config.bin_construct_sample_cnt !=
            old_config.bin_construct_sample_cnt) {
      Log::Fatal(
          "Cannot change bin_construct_sample_cnt after constructed Dataset "
          "handle.");
    }
    if (new_param.count("min_data_in_bin") &&
        new_config.min_data_in_bin != old_config.min_data_in_bin) {
      Log::Fatal(
          "Cannot change min_data_in_bin after constructed Dataset handle.");
    }
    if (new_param.count("use_missing") &&
        new_config.use_missing != old_config.use_missing) {
      Log::Fatal("Cannot change use_missing after constructed Dataset handle.");
    }
    if (new_param.count("zero_as_missing") &&
        new_config.zero_as_missing != old_config.zero_as_missing) {
      Log::Fatal(
          "Cannot change zero_as_missing after constructed Dataset handle.");
    }
    if (new_param.count("categorical_feature") &&
        new_config.categorical_feature != old_config.categorical_feature) {
      Log::Fatal(
          "Cannot change categorical_feature after constructed Dataset "
          "handle.");
    }
    if (new_param.count("feature_pre_filter") &&
        new_config.feature_pre_filter != old_config.feature_pre_filter) {
      Log::Fatal(
          "Cannot change feature_pre_filter after constructed Dataset handle.");
    }
    if (new_param.count("is_enable_sparse") &&
        new_config.is_enable_sparse != old_config.is_enable_sparse) {
      Log::Fatal(
          "Cannot change is_enable_sparse after constructed Dataset handle.");
    }
    if (new_param.count("pre_partition") &&
        new_config.pre_partition != old_config.pre_partition) {
      Log::Fatal(
          "Cannot change pre_partition after constructed Dataset handle.");
    }
    if (new_param.count("enable_bundle") &&
        new_config.enable_bundle != old_config.enable_bundle) {
      Log::Fatal(
          "Cannot change enable_bundle after constructed Dataset handle.");
    }
    if (new_param.count("header") && new_config.header != old_config.header) {
      Log::Fatal("Cannot change header after constructed Dataset handle.");
    }
    if (new_param.count("two_round") &&
        new_config.two_round != old_config.two_round) {
      Log::Fatal("Cannot change two_round after constructed Dataset handle.");
    }
    if (new_param.count("label_column") &&
        new_config.label_column != old_config.label_column) {
      Log::Fatal(
          "Cannot change label_column after constructed Dataset handle.");
    }
    if (new_param.count("weight_column") &&
        new_config.weight_column != old_config.weight_column) {
      Log::Fatal(
          "Cannot change weight_column after constructed Dataset handle.");
    }
    if (new_param.count("group_column") &&
        new_config.group_column != old_config.group_column) {
      Log::Fatal(
          "Cannot change group_column after constructed Dataset handle.");
    }
    if (new_param.count("ignore_column") &&
        new_config.ignore_column != old_config.ignore_column) {
      Log::Fatal(
          "Cannot change ignore_column after constructed Dataset handle.");
    }
    if (new_param.count("forcedbins_filename")) {
      Log::Fatal("Cannot change forced bins after constructed Dataset handle.");
    }
    if (new_param.count("min_data_in_leaf") &&
        new_config.min_data_in_leaf < old_config.min_data_in_leaf &&
        old_config.feature_pre_filter) {
      Log::Fatal(
          "Reducing `min_data_in_leaf` with `feature_pre_filter=true` may "
          "cause unexpected behaviour "
          "for features that were pre-filtered by the larger "
          "`min_data_in_leaf`.\n"
          "You need to set `feature_pre_filter=false` to dynamically change "
          "the `min_data_in_leaf`.");
    }
Nikita Titov's avatar
Nikita Titov committed
290
    if (new_param.count("linear_tree") && new_config.linear_tree != old_config.linear_tree) {
291
      Log::Fatal("Cannot change linear_tree after constructed Dataset handle.");
292
    }
Nikita Titov's avatar
Nikita Titov committed
293
294
295
296
    if (new_param.count("precise_float_parser") &&
        new_config.precise_float_parser != old_config.precise_float_parser) {
      Log::Fatal("Cannot change precise_float_parser after constructed Dataset handle.");
    }
297
298
  }

wxchan's avatar
wxchan committed
299
  void ResetConfig(const char* parameters) {
300
    UNIQUE_LOCK(mutex_)
Guolin Ke's avatar
Guolin Ke committed
301
    auto param = Config::Str2Map(parameters);
302
303
304
    Config new_config;
    new_config.Set(param);
    if (param.count("num_class") && new_config.num_class != config_.num_class) {
305
      Log::Fatal("Cannot change num_class during training");
wxchan's avatar
wxchan committed
306
    }
307
    if (param.count("boosting") && new_config.boosting != config_.boosting) {
Guolin Ke's avatar
Guolin Ke committed
308
      Log::Fatal("Cannot change boosting during training");
wxchan's avatar
wxchan committed
309
    }
310
    if (param.count("metric") && new_config.metric != config_.metric) {
311
      Log::Fatal("Cannot change metric during training");
Guolin Ke's avatar
Guolin Ke committed
312
    }
313
314
    CheckDatasetResetConfig(config_, param);

Guolin Ke's avatar
Guolin Ke committed
315
    config_.Set(param);
316

317
318
319
    if (config_.num_threads > 0) {
      omp_set_num_threads(config_.num_threads);
    }
Guolin Ke's avatar
Guolin Ke committed
320
321
322

    if (param.count("objective")) {
      // create objective function
Guolin Ke's avatar
Guolin Ke committed
323
324
      objective_fun_.reset(ObjectiveFunction::CreateObjectiveFunction(config_.objective,
                                                                      config_));
Guolin Ke's avatar
Guolin Ke committed
325
326
327
328
329
330
331
      if (objective_fun_ == nullptr) {
        Log::Warning("Using self-defined objective function");
      }
      // initialize the objective function
      if (objective_fun_ != nullptr) {
        objective_fun_->Init(train_data_->metadata(), train_data_->num_data());
      }
332
333
      boosting_->ResetTrainingData(train_data_,
                                   objective_fun_.get(), Common::ConstPtrInVectorWrapper<Metric>(train_metric_));
wxchan's avatar
wxchan committed
334
    }
Guolin Ke's avatar
Guolin Ke committed
335

Guolin Ke's avatar
Guolin Ke committed
336
    boosting_->ResetConfig(&config_);
wxchan's avatar
wxchan committed
337
338
339
  }

  void AddValidData(const Dataset* valid_data) {
340
    UNIQUE_LOCK(mutex_)
wxchan's avatar
wxchan committed
341
    valid_metrics_.emplace_back();
Guolin Ke's avatar
Guolin Ke committed
342
343
    for (auto metric_type : config_.metric) {
      auto metric = std::unique_ptr<Metric>(Metric::CreateMetric(metric_type, config_));
wxchan's avatar
wxchan committed
344
345
346
347
348
349
      if (metric == nullptr) { continue; }
      metric->Init(valid_data->metadata(), valid_data->num_data());
      valid_metrics_.back().push_back(std::move(metric));
    }
    valid_metrics_.back().shrink_to_fit();
    boosting_->AddValidDataset(valid_data,
350
                               Common::ConstPtrInVectorWrapper<Metric>(valid_metrics_.back()));
wxchan's avatar
wxchan committed
351
  }
Guolin Ke's avatar
Guolin Ke committed
352

353
  bool TrainOneIter() {
354
    UNIQUE_LOCK(mutex_)
Guolin Ke's avatar
Guolin Ke committed
355
    return boosting_->TrainOneIter(nullptr, nullptr);
356
357
  }

Guolin Ke's avatar
Guolin Ke committed
358
  void Refit(const int32_t* leaf_preds, int32_t nrow, int32_t ncol) {
359
    UNIQUE_LOCK(mutex_)
Guolin Ke's avatar
Guolin Ke committed
360
361
362
    std::vector<std::vector<int32_t>> v_leaf_preds(nrow, std::vector<int32_t>(ncol, 0));
    for (int i = 0; i < nrow; ++i) {
      for (int j = 0; j < ncol; ++j) {
363
        v_leaf_preds[i][j] = leaf_preds[static_cast<size_t>(i) * static_cast<size_t>(ncol) + static_cast<size_t>(j)];
Guolin Ke's avatar
Guolin Ke committed
364
365
366
367
368
      }
    }
    boosting_->RefitTree(v_leaf_preds);
  }

369
  bool TrainOneIter(const score_t* gradients, const score_t* hessians) {
370
    UNIQUE_LOCK(mutex_)
Guolin Ke's avatar
Guolin Ke committed
371
    return boosting_->TrainOneIter(gradients, hessians);
372
373
  }

wxchan's avatar
wxchan committed
374
  void RollbackOneIter() {
375
    UNIQUE_LOCK(mutex_)
wxchan's avatar
wxchan committed
376
377
378
    boosting_->RollbackOneIter();
  }

379
  void SetSingleRowPredictor(int start_iteration, int num_iteration, int predict_type, const Config& config) {
380
381
382
383
      UNIQUE_LOCK(mutex_)
      if (single_row_predictor_[predict_type].get() == nullptr ||
          !single_row_predictor_[predict_type]->IsPredictorEqual(config, num_iteration, boosting_.get())) {
        single_row_predictor_[predict_type].reset(new SingleRowPredictor(predict_type, boosting_.get(),
384
                                                                         config, start_iteration, num_iteration));
385
386
387
388
      }
  }

  void PredictSingleRow(int predict_type, int ncol,
389
390
               std::function<std::vector<std::pair<int, double>>(int row_idx)> get_row_fun,
               const Config& config,
391
               double* out_result, int64_t* out_len) const {
392
393
394
    if (!config.predict_disable_shape_check && ncol != boosting_->MaxFeatureIdx() + 1) {
      Log::Fatal("The number of features in data (%d) is not the same as it was in training data (%d).\n"\
                 "You can set ``predict_disable_shape_check=true`` to discard this error, but please be aware what you are doing.", ncol, boosting_->MaxFeatureIdx() + 1);
395
    }
396
    UNIQUE_LOCK(mutex_)
397
    const auto& single_row_predictor = single_row_predictor_[predict_type];
398
399
    auto one_row = get_row_fun(0);
    auto pred_wrt_ptr = out_result;
400
    single_row_predictor->predict_function(one_row, pred_wrt_ptr);
401

402
    *out_len = single_row_predictor->num_pred_in_one_row;
403
404
  }

405
  Predictor CreatePredictor(int start_iteration, int num_iteration, int predict_type, int ncol, const Config& config) const {
406
407
408
    if (!config.predict_disable_shape_check && ncol != boosting_->MaxFeatureIdx() + 1) {
      Log::Fatal("The number of features in data (%d) is not the same as it was in training data (%d).\n" \
                 "You can set ``predict_disable_shape_check=true`` to discard this error, but please be aware what you are doing.", ncol, boosting_->MaxFeatureIdx() + 1);
409
    }
Guolin Ke's avatar
Guolin Ke committed
410
411
    bool is_predict_leaf = false;
    bool is_raw_score = false;
Guolin Ke's avatar
Guolin Ke committed
412
    bool predict_contrib = false;
Guolin Ke's avatar
Guolin Ke committed
413
    if (predict_type == C_API_PREDICT_LEAF_INDEX) {
Guolin Ke's avatar
Guolin Ke committed
414
      is_predict_leaf = true;
Guolin Ke's avatar
Guolin Ke committed
415
    } else if (predict_type == C_API_PREDICT_RAW_SCORE) {
Guolin Ke's avatar
Guolin Ke committed
416
      is_raw_score = true;
417
    } else if (predict_type == C_API_PREDICT_CONTRIB) {
Guolin Ke's avatar
Guolin Ke committed
418
      predict_contrib = true;
Guolin Ke's avatar
Guolin Ke committed
419
420
    } else {
      is_raw_score = false;
Guolin Ke's avatar
Guolin Ke committed
421
    }
Guolin Ke's avatar
Guolin Ke committed
422

423
    return Predictor(boosting_.get(), start_iteration, num_iteration, is_raw_score, is_predict_leaf, predict_contrib,
424
                        config.pred_early_stop, config.pred_early_stop_freq, config.pred_early_stop_margin);
425
426
  }

427
  void Predict(int start_iteration, int num_iteration, int predict_type, int nrow, int ncol,
428
429
               std::function<std::vector<std::pair<int, double>>(int row_idx)> get_row_fun,
               const Config& config,
430
431
               double* out_result, int64_t* out_len) const {
    SHARED_LOCK(mutex_);
432
    auto predictor = CreatePredictor(start_iteration, num_iteration, predict_type, ncol, config);
433
434
435
436
437
438
439
    bool is_predict_leaf = false;
    bool predict_contrib = false;
    if (predict_type == C_API_PREDICT_LEAF_INDEX) {
      is_predict_leaf = true;
    } else if (predict_type == C_API_PREDICT_CONTRIB) {
      predict_contrib = true;
    }
440
    int64_t num_pred_in_one_row = boosting_->NumPredictOneRow(start_iteration, num_iteration, is_predict_leaf, predict_contrib);
Guolin Ke's avatar
Guolin Ke committed
441
    auto pred_fun = predictor.GetPredictFunction();
442
443
    OMP_INIT_EX();
    #pragma omp parallel for schedule(static)
Guolin Ke's avatar
Guolin Ke committed
444
    for (int i = 0; i < nrow; ++i) {
445
      OMP_LOOP_EX_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
446
      auto one_row = get_row_fun(i);
Tony-Y's avatar
Tony-Y committed
447
      auto pred_wrt_ptr = out_result + static_cast<size_t>(num_pred_in_one_row) * i;
Guolin Ke's avatar
Guolin Ke committed
448
      pred_fun(one_row, pred_wrt_ptr);
449
      OMP_LOOP_EX_END();
Guolin Ke's avatar
Guolin Ke committed
450
    }
451
    OMP_THROW_EX();
452
    *out_len = num_pred_in_one_row * nrow;
Guolin Ke's avatar
Guolin Ke committed
453
454
  }

455
  void PredictSparse(int start_iteration, int num_iteration, int predict_type, int64_t nrow, int ncol,
456
457
458
459
                     std::function<std::vector<std::pair<int, double>>(int64_t row_idx)> get_row_fun,
                     const Config& config, int64_t* out_elements_size,
                     std::vector<std::vector<std::unordered_map<int, double>>>* agg_ptr,
                     int32_t** out_indices, void** out_data, int data_type,
460
                     bool* is_data_float32_ptr, int num_matrices) const {
461
    auto predictor = CreatePredictor(start_iteration, num_iteration, predict_type, ncol, config);
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
    auto pred_sparse_fun = predictor.GetPredictSparseFunction();
    std::vector<std::vector<std::unordered_map<int, double>>>& agg = *agg_ptr;
    OMP_INIT_EX();
    #pragma omp parallel for schedule(static)
    for (int64_t i = 0; i < nrow; ++i) {
      OMP_LOOP_EX_BEGIN();
      auto one_row = get_row_fun(i);
      agg[i] = std::vector<std::unordered_map<int, double>>(num_matrices);
      pred_sparse_fun(one_row, &agg[i]);
      OMP_LOOP_EX_END();
    }
    OMP_THROW_EX();
    // calculate the nonzero data and indices size
    int64_t elements_size = 0;
    for (int64_t i = 0; i < static_cast<int64_t>(agg.size()); ++i) {
      auto row_vector = agg[i];
      for (int j = 0; j < static_cast<int>(row_vector.size()); ++j) {
        elements_size += static_cast<int64_t>(row_vector[j].size());
      }
    }
    *out_elements_size = elements_size;
    *is_data_float32_ptr = false;
    // allocate data and indices arrays
    if (data_type == C_API_DTYPE_FLOAT32) {
      *out_data = new float[elements_size];
      *is_data_float32_ptr = true;
    } else if (data_type == C_API_DTYPE_FLOAT64) {
      *out_data = new double[elements_size];
    } else {
      Log::Fatal("Unknown data type in PredictSparse");
      return;
    }
    *out_indices = new int32_t[elements_size];
  }

497
  void PredictSparseCSR(int start_iteration, int num_iteration, int predict_type, int64_t nrow, int ncol,
498
499
500
                        std::function<std::vector<std::pair<int, double>>(int64_t row_idx)> get_row_fun,
                        const Config& config,
                        int64_t* out_len, void** out_indptr, int indptr_type,
501
502
                        int32_t** out_indices, void** out_data, int data_type) const {
    SHARED_LOCK(mutex_);
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
    // Get the number of trees per iteration (for multiclass scenario we output multiple sparse matrices)
    int num_matrices = boosting_->NumModelPerIteration();
    bool is_indptr_int32 = false;
    bool is_data_float32 = false;
    int64_t indptr_size = (nrow + 1) * num_matrices;
    if (indptr_type == C_API_DTYPE_INT32) {
      *out_indptr = new int32_t[indptr_size];
      is_indptr_int32 = true;
    } else if (indptr_type == C_API_DTYPE_INT64) {
      *out_indptr = new int64_t[indptr_size];
    } else {
      Log::Fatal("Unknown indptr type in PredictSparseCSR");
      return;
    }
    // aggregated per row feature contribution results
    std::vector<std::vector<std::unordered_map<int, double>>> agg(nrow);
    int64_t elements_size = 0;
520
    PredictSparse(start_iteration, num_iteration, predict_type, nrow, ncol, get_row_fun, config, &elements_size, &agg,
521
522
523
                  out_indices, out_data, data_type, &is_data_float32, num_matrices);
    std::vector<int> row_sizes(num_matrices * nrow);
    std::vector<int64_t> row_matrix_offsets(num_matrices * nrow);
524
    std::vector<int64_t> matrix_offsets(num_matrices);
525
526
527
528
529
530
531
532
533
534
535
536
537
538
    int64_t row_vector_cnt = 0;
    for (int m = 0; m < num_matrices; ++m) {
      for (int64_t i = 0; i < static_cast<int64_t>(agg.size()); ++i) {
        auto row_vector = agg[i];
        auto row_vector_size = row_vector[m].size();
        // keep track of the row_vector sizes for parallelization
        row_sizes[row_vector_cnt] = static_cast<int>(row_vector_size);
        if (i == 0) {
          row_matrix_offsets[row_vector_cnt] = 0;
        } else {
          row_matrix_offsets[row_vector_cnt] = static_cast<int64_t>(row_sizes[row_vector_cnt - 1] + row_matrix_offsets[row_vector_cnt - 1]);
        }
        row_vector_cnt++;
      }
539
540
541
542
543
544
      if (m == 0) {
        matrix_offsets[m] = 0;
      }
      if (m + 1 < num_matrices) {
        matrix_offsets[m + 1] = static_cast<int64_t>(matrix_offsets[m] + row_matrix_offsets[row_vector_cnt - 1] + row_sizes[row_vector_cnt - 1]);
      }
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
    }
    // copy vector results to output for each row
    int64_t indptr_index = 0;
    for (int m = 0; m < num_matrices; ++m) {
      if (is_indptr_int32) {
        (reinterpret_cast<int32_t*>(*out_indptr))[indptr_index] = 0;
      } else {
        (reinterpret_cast<int64_t*>(*out_indptr))[indptr_index] = 0;
      }
      indptr_index++;
      int64_t matrix_start_index = m * static_cast<int64_t>(agg.size());
      OMP_INIT_EX();
      #pragma omp parallel for schedule(static)
      for (int64_t i = 0; i < static_cast<int64_t>(agg.size()); ++i) {
        OMP_LOOP_EX_BEGIN();
        auto row_vector = agg[i];
        int64_t row_start_index = matrix_start_index + i;
562
        int64_t element_index = row_matrix_offsets[row_start_index] + matrix_offsets[m];
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
        int64_t indptr_loop_index = indptr_index + i;
        for (auto it = row_vector[m].begin(); it != row_vector[m].end(); ++it) {
          (*out_indices)[element_index] = it->first;
          if (is_data_float32) {
            (reinterpret_cast<float*>(*out_data))[element_index] = static_cast<float>(it->second);
          } else {
            (reinterpret_cast<double*>(*out_data))[element_index] = it->second;
          }
          element_index++;
        }
        int64_t indptr_value = row_matrix_offsets[row_start_index] + row_sizes[row_start_index];
        if (is_indptr_int32) {
          (reinterpret_cast<int32_t*>(*out_indptr))[indptr_loop_index] = static_cast<int32_t>(indptr_value);
        } else {
          (reinterpret_cast<int64_t*>(*out_indptr))[indptr_loop_index] = indptr_value;
        }
        OMP_LOOP_EX_END();
      }
      OMP_THROW_EX();
      indptr_index += static_cast<int64_t>(agg.size());
    }
    out_len[0] = elements_size;
    out_len[1] = indptr_size;
  }

588
  void PredictSparseCSC(int start_iteration, int num_iteration, int predict_type, int64_t nrow, int ncol,
589
590
591
                        std::function<std::vector<std::pair<int, double>>(int64_t row_idx)> get_row_fun,
                        const Config& config,
                        int64_t* out_len, void** out_col_ptr, int col_ptr_type,
592
593
                        int32_t** out_indices, void** out_data, int data_type) const {
    SHARED_LOCK(mutex_);
594
595
    // Get the number of trees per iteration (for multiclass scenario we output multiple sparse matrices)
    int num_matrices = boosting_->NumModelPerIteration();
596
    auto predictor = CreatePredictor(start_iteration, num_iteration, predict_type, ncol, config);
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
    auto pred_sparse_fun = predictor.GetPredictSparseFunction();
    bool is_col_ptr_int32 = false;
    bool is_data_float32 = false;
    int num_output_cols = ncol + 1;
    int col_ptr_size = (num_output_cols + 1) * num_matrices;
    if (col_ptr_type == C_API_DTYPE_INT32) {
      *out_col_ptr = new int32_t[col_ptr_size];
      is_col_ptr_int32 = true;
    } else if (col_ptr_type == C_API_DTYPE_INT64) {
      *out_col_ptr = new int64_t[col_ptr_size];
    } else {
      Log::Fatal("Unknown col_ptr type in PredictSparseCSC");
      return;
    }
    // aggregated per row feature contribution results
    std::vector<std::vector<std::unordered_map<int, double>>> agg(nrow);
    int64_t elements_size = 0;
614
    PredictSparse(start_iteration, num_iteration, predict_type, nrow, ncol, get_row_fun, config, &elements_size, &agg,
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
                  out_indices, out_data, data_type, &is_data_float32, num_matrices);
    // calculate number of elements per column to construct
    // the CSC matrix with random access
    std::vector<std::vector<int64_t>> column_sizes(num_matrices);
    for (int m = 0; m < num_matrices; ++m) {
      column_sizes[m] = std::vector<int64_t>(num_output_cols, 0);
      for (int64_t i = 0; i < static_cast<int64_t>(agg.size()); ++i) {
        auto row_vector = agg[i];
        for (auto it = row_vector[m].begin(); it != row_vector[m].end(); ++it) {
          column_sizes[m][it->first] += 1;
        }
      }
    }
    // keep track of column counts
    std::vector<std::vector<int64_t>> column_counts(num_matrices);
    // keep track of beginning index for each column
    std::vector<std::vector<int64_t>> column_start_indices(num_matrices);
    // keep track of beginning index for each matrix
    std::vector<int64_t> matrix_start_indices(num_matrices, 0);
    int col_ptr_index = 0;
    for (int m = 0; m < num_matrices; ++m) {
      int64_t col_ptr_value = 0;
      column_start_indices[m] = std::vector<int64_t>(num_output_cols, 0);
      column_counts[m] = std::vector<int64_t>(num_output_cols, 0);
      if (is_col_ptr_int32) {
        (reinterpret_cast<int32_t*>(*out_col_ptr))[col_ptr_index] = static_cast<int32_t>(col_ptr_value);
      } else {
        (reinterpret_cast<int64_t*>(*out_col_ptr))[col_ptr_index] = col_ptr_value;
      }
      col_ptr_index++;
      for (int64_t i = 1; i < static_cast<int64_t>(column_sizes[m].size()); ++i) {
        column_start_indices[m][i] = column_sizes[m][i - 1] + column_start_indices[m][i - 1];
        if (is_col_ptr_int32) {
          (reinterpret_cast<int32_t*>(*out_col_ptr))[col_ptr_index] = static_cast<int32_t>(column_start_indices[m][i]);
        } else {
          (reinterpret_cast<int64_t*>(*out_col_ptr))[col_ptr_index] = column_start_indices[m][i];
        }
        col_ptr_index++;
      }
      int64_t last_elem_index = static_cast<int64_t>(column_sizes[m].size()) - 1;
      int64_t last_column_start_index = column_start_indices[m][last_elem_index];
      int64_t last_column_size = column_sizes[m][last_elem_index];
      if (is_col_ptr_int32) {
        (reinterpret_cast<int32_t*>(*out_col_ptr))[col_ptr_index] = static_cast<int32_t>(last_column_start_index + last_column_size);
      } else {
        (reinterpret_cast<int64_t*>(*out_col_ptr))[col_ptr_index] = last_column_start_index + last_column_size;
      }
662
663
      if (m + 1 < num_matrices) {
        matrix_start_indices[m + 1] = matrix_start_indices[m] + last_column_start_index + last_column_size;
664
      }
665
      col_ptr_index++;
666
    }
667
668
669
    // Note: we parallelize across matrices instead of rows because of the column_counts[m][col_idx] increment inside the loop
    OMP_INIT_EX();
    #pragma omp parallel for schedule(static)
670
    for (int m = 0; m < num_matrices; ++m) {
671
      OMP_LOOP_EX_BEGIN();
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
      for (int64_t i = 0; i < static_cast<int64_t>(agg.size()); ++i) {
        auto row_vector = agg[i];
        for (auto it = row_vector[m].begin(); it != row_vector[m].end(); ++it) {
          int64_t col_idx = it->first;
          int64_t element_index = column_start_indices[m][col_idx] +
            matrix_start_indices[m] +
            column_counts[m][col_idx];
          // store the row index
          (*out_indices)[element_index] = static_cast<int32_t>(i);
          // update column count
          column_counts[m][col_idx]++;
          if (is_data_float32) {
            (reinterpret_cast<float*>(*out_data))[element_index] = static_cast<float>(it->second);
          } else {
            (reinterpret_cast<double*>(*out_data))[element_index] = it->second;
          }
        }
      }
690
      OMP_LOOP_EX_END();
691
    }
692
    OMP_THROW_EX();
693
694
695
696
    out_len[0] = elements_size;
    out_len[1] = col_ptr_size;
  }

697
  void Predict(int start_iteration, int num_iteration, int predict_type, const char* data_filename,
Guolin Ke's avatar
Guolin Ke committed
698
               int data_has_header, const Config& config,
699
700
               const char* result_filename) const {
    SHARED_LOCK(mutex_)
Guolin Ke's avatar
Guolin Ke committed
701
702
    bool is_predict_leaf = false;
    bool is_raw_score = false;
Guolin Ke's avatar
Guolin Ke committed
703
    bool predict_contrib = false;
Guolin Ke's avatar
Guolin Ke committed
704
705
706
707
    if (predict_type == C_API_PREDICT_LEAF_INDEX) {
      is_predict_leaf = true;
    } else if (predict_type == C_API_PREDICT_RAW_SCORE) {
      is_raw_score = true;
708
    } else if (predict_type == C_API_PREDICT_CONTRIB) {
Guolin Ke's avatar
Guolin Ke committed
709
      predict_contrib = true;
Guolin Ke's avatar
Guolin Ke committed
710
711
712
    } else {
      is_raw_score = false;
    }
713
    Predictor predictor(boosting_.get(), start_iteration, num_iteration, is_raw_score, is_predict_leaf, predict_contrib,
714
                        config.pred_early_stop, config.pred_early_stop_freq, config.pred_early_stop_margin);
Guolin Ke's avatar
Guolin Ke committed
715
    bool bool_data_has_header = data_has_header > 0 ? true : false;
Chen Yufei's avatar
Chen Yufei committed
716
717
    predictor.Predict(data_filename, result_filename, bool_data_has_header, config.predict_disable_shape_check,
                      config.precise_float_parser);
Guolin Ke's avatar
Guolin Ke committed
718
719
  }

720
  void GetPredictAt(int data_idx, double* out_result, int64_t* out_len) const {
wxchan's avatar
wxchan committed
721
722
723
    boosting_->GetPredictAt(data_idx, out_result, out_len);
  }

724
  void SaveModelToFile(int start_iteration, int num_iteration, int feature_importance_type, const char* filename) const {
725
    boosting_->SaveModelToFile(start_iteration, num_iteration, feature_importance_type, filename);
Guolin Ke's avatar
Guolin Ke committed
726
  }
727

728
  void LoadModelFromString(const char* model_str) {
729
730
    size_t len = std::strlen(model_str);
    boosting_->LoadModelFromString(model_str, len);
731
732
  }

733
  std::string SaveModelToString(int start_iteration, int num_iteration,
734
                                int feature_importance_type) const {
735
736
    return boosting_->SaveModelToString(start_iteration,
                                        num_iteration, feature_importance_type);
737
738
  }

739
  std::string DumpModel(int start_iteration, int num_iteration,
740
                        int feature_importance_type) const {
741
742
    return boosting_->DumpModel(start_iteration, num_iteration,
                                feature_importance_type);
wxchan's avatar
wxchan committed
743
  }
744

745
  std::vector<double> FeatureImportance(int num_iteration, int importance_type) const {
746
747
748
    return boosting_->FeatureImportance(num_iteration, importance_type);
  }

749
  double UpperBoundValue() const {
750
    SHARED_LOCK(mutex_)
751
752
753
754
    return boosting_->GetUpperBoundValue();
  }

  double LowerBoundValue() const {
755
    SHARED_LOCK(mutex_)
756
757
758
    return boosting_->GetLowerBoundValue();
  }

Guolin Ke's avatar
Guolin Ke committed
759
  double GetLeafValue(int tree_idx, int leaf_idx) const {
760
    SHARED_LOCK(mutex_)
Guolin Ke's avatar
Guolin Ke committed
761
    return dynamic_cast<GBDTBase*>(boosting_.get())->GetLeafValue(tree_idx, leaf_idx);
Guolin Ke's avatar
Guolin Ke committed
762
763
764
  }

  void SetLeafValue(int tree_idx, int leaf_idx, double val) {
765
    UNIQUE_LOCK(mutex_)
Guolin Ke's avatar
Guolin Ke committed
766
    dynamic_cast<GBDTBase*>(boosting_.get())->SetLeafValue(tree_idx, leaf_idx, val);
Guolin Ke's avatar
Guolin Ke committed
767
768
  }

769
  void ShuffleModels(int start_iter, int end_iter) {
770
    UNIQUE_LOCK(mutex_)
771
    boosting_->ShuffleModels(start_iter, end_iter);
772
773
  }

wxchan's avatar
wxchan committed
774
  int GetEvalCounts() const {
775
    SHARED_LOCK(mutex_)
wxchan's avatar
wxchan committed
776
777
778
779
780
781
    int ret = 0;
    for (const auto& metric : train_metric_) {
      ret += static_cast<int>(metric->GetName().size());
    }
    return ret;
  }
782

783
  int GetEvalNames(char** out_strs, const int len, const size_t buffer_len, size_t *out_buffer_len) const {
784
    SHARED_LOCK(mutex_)
785
    *out_buffer_len = 0;
wxchan's avatar
wxchan committed
786
787
788
    int idx = 0;
    for (const auto& metric : train_metric_) {
      for (const auto& name : metric->GetName()) {
789
790
791
792
793
        if (idx < len) {
          std::memcpy(out_strs[idx], name.c_str(), std::min(name.size() + 1, buffer_len));
          out_strs[idx][buffer_len - 1] = '\0';
        }
        *out_buffer_len = std::max(name.size() + 1, *out_buffer_len);
wxchan's avatar
wxchan committed
794
795
796
797
798
799
        ++idx;
      }
    }
    return idx;
  }

800
  int GetFeatureNames(char** out_strs, const int len, const size_t buffer_len, size_t *out_buffer_len) const {
801
    SHARED_LOCK(mutex_)
802
    *out_buffer_len = 0;
wxchan's avatar
wxchan committed
803
804
    int idx = 0;
    for (const auto& name : boosting_->FeatureNames()) {
805
806
807
808
809
      if (idx < len) {
        std::memcpy(out_strs[idx], name.c_str(), std::min(name.size() + 1, buffer_len));
        out_strs[idx][buffer_len - 1] = '\0';
      }
      *out_buffer_len = std::max(name.size() + 1, *out_buffer_len);
wxchan's avatar
wxchan committed
810
811
812
813
814
      ++idx;
    }
    return idx;
  }

wxchan's avatar
wxchan committed
815
  const Boosting* GetBoosting() const { return boosting_.get(); }
Guolin Ke's avatar
Guolin Ke committed
816

Nikita Titov's avatar
Nikita Titov committed
817
 private:
wxchan's avatar
wxchan committed
818
  const Dataset* train_data_;
Guolin Ke's avatar
Guolin Ke committed
819
  std::unique_ptr<Boosting> boosting_;
820
  std::unique_ptr<SingleRowPredictor> single_row_predictor_[PREDICTOR_TYPES];
821

Guolin Ke's avatar
Guolin Ke committed
822
  /*! \brief All configs */
Guolin Ke's avatar
Guolin Ke committed
823
  Config config_;
Guolin Ke's avatar
Guolin Ke committed
824
  /*! \brief Metric for training data */
Guolin Ke's avatar
Guolin Ke committed
825
  std::vector<std::unique_ptr<Metric>> train_metric_;
Guolin Ke's avatar
Guolin Ke committed
826
  /*! \brief Metrics for validation data */
Guolin Ke's avatar
Guolin Ke committed
827
  std::vector<std::vector<std::unique_ptr<Metric>>> valid_metrics_;
Guolin Ke's avatar
Guolin Ke committed
828
  /*! \brief Training objective function */
Guolin Ke's avatar
Guolin Ke committed
829
  std::unique_ptr<ObjectiveFunction> objective_fun_;
wxchan's avatar
wxchan committed
830
  /*! \brief mutex for threading safe call */
831
  mutable yamc::alternate::shared_mutex mutex_;
Guolin Ke's avatar
Guolin Ke committed
832
833
};

834
}  // namespace LightGBM
Guolin Ke's avatar
Guolin Ke committed
835

836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
// explicitly declare symbols from LightGBM namespace
using LightGBM::AllgatherFunction;
using LightGBM::Booster;
using LightGBM::Common::CheckElementsIntervalClosed;
using LightGBM::Common::RemoveQuotationSymbol;
using LightGBM::Common::Vector2Ptr;
using LightGBM::Common::VectorSize;
using LightGBM::Config;
using LightGBM::data_size_t;
using LightGBM::Dataset;
using LightGBM::DatasetLoader;
using LightGBM::kZeroThreshold;
using LightGBM::LGBM_APIHandleException;
using LightGBM::Log;
using LightGBM::Network;
using LightGBM::Random;
using LightGBM::ReduceScatterFunction;
Guolin Ke's avatar
Guolin Ke committed
853

Guolin Ke's avatar
Guolin Ke committed
854
855
856
857
858
859
860
861
// some help functions used to convert data

std::function<std::vector<double>(int row_idx)>
RowFunctionFromDenseMatric(const void* data, int num_row, int num_col, int data_type, int is_row_major);

std::function<std::vector<std::pair<int, double>>(int row_idx)>
RowPairFunctionFromDenseMatric(const void* data, int num_row, int num_col, int data_type, int is_row_major);

862
863
864
std::function<std::vector<std::pair<int, double>>(int row_idx)>
RowPairFunctionFromDenseRows(const void** data, int num_col, int data_type);

865
866
template<typename T>
std::function<std::vector<std::pair<int, double>>(T idx)>
Guolin Ke's avatar
Guolin Ke committed
867
RowFunctionFromCSR(const void* indptr, int indptr_type, const int32_t* indices,
868
                   const void* data, int data_type, int64_t nindptr, int64_t nelem);
Guolin Ke's avatar
Guolin Ke committed
869
870
871

// Row iterator of on column for CSC matrix
class CSC_RowIterator {
Nikita Titov's avatar
Nikita Titov committed
872
 public:
Guolin Ke's avatar
Guolin Ke committed
873
  CSC_RowIterator(const void* col_ptr, int col_ptr_type, const int32_t* indices,
874
                  const void* data, int data_type, int64_t ncol_ptr, int64_t nelem, int col_idx);
Guolin Ke's avatar
Guolin Ke committed
875
876
877
878
879
  ~CSC_RowIterator() {}
  // return value at idx, only can access by ascent order
  double Get(int idx);
  // return next non-zero pair, if index < 0, means no more data
  std::pair<int, double> NextNonZero();
Nikita Titov's avatar
Nikita Titov committed
880
881

 private:
Guolin Ke's avatar
Guolin Ke committed
882
883
884
885
886
887
888
889
890
  int nonzero_idx_ = 0;
  int cur_idx_ = -1;
  double cur_val_ = 0.0f;
  bool is_end_ = false;
  std::function<std::pair<int, double>(int idx)> iter_fun_;
};

// start of c_api functions

Guolin Ke's avatar
Guolin Ke committed
891
const char* LGBM_GetLastError() {
wxchan's avatar
wxchan committed
892
  return LastErrorMsg();
Guolin Ke's avatar
Guolin Ke committed
893
894
}

895
896
897
898
899
900
int LGBM_RegisterLogCallback(void (*callback)(const char*)) {
  API_BEGIN();
  Log::ResetCallBack(callback);
  API_END();
}

901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
static inline int SampleCount(int32_t total_nrow, const Config& config) {
  return static_cast<int>(total_nrow < config.bin_construct_sample_cnt ? total_nrow : config.bin_construct_sample_cnt);
}

static inline std::vector<int32_t> CreateSampleIndices(int32_t total_nrow, const Config& config) {
  Random rand(config.data_random_seed);
  int sample_cnt = SampleCount(total_nrow, config);
  return rand.Sample(total_nrow, sample_cnt);
}

int LGBM_GetSampleCount(int32_t num_total_row,
                        const char* parameters,
                        int* out) {
  API_BEGIN();
  if (out == nullptr) {
    Log::Fatal("LGBM_GetSampleCount output is nullptr");
  }
  auto param = Config::Str2Map(parameters);
  Config config;
  config.Set(param);

  *out = SampleCount(num_total_row, config);
  API_END();
}

int LGBM_SampleIndices(int32_t num_total_row,
                       const char* parameters,
                       void* out,
                       int32_t* out_len) {
  // This API is to keep python binding's behavior the same with C++ implementation.
  // Sample count, random seed etc. should be provided in parameters.
  API_BEGIN();
  if (out == nullptr) {
    Log::Fatal("LGBM_SampleIndices output is nullptr");
  }
  auto param = Config::Str2Map(parameters);
  Config config;
  config.Set(param);

  auto sample_indices = CreateSampleIndices(num_total_row, config);
  memcpy(out, sample_indices.data(), sizeof(int32_t) * sample_indices.size());
  *out_len = static_cast<int32_t>(sample_indices.size());
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
946
int LGBM_DatasetCreateFromFile(const char* filename,
947
948
949
                               const char* parameters,
                               const DatasetHandle reference,
                               DatasetHandle* out) {
950
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
951
952
  auto param = Config::Str2Map(parameters);
  Config config;
953
954
955
956
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
957
  DatasetLoader loader(config, nullptr, 1, filename);
Guolin Ke's avatar
Guolin Ke committed
958
  if (reference == nullptr) {
959
    if (Network::num_machines() == 1) {
960
      *out = loader.LoadFromFile(filename);
961
    } else {
962
      *out = loader.LoadFromFile(filename, Network::rank(), Network::num_machines());
963
    }
Guolin Ke's avatar
Guolin Ke committed
964
  } else {
965
    *out = loader.LoadFromFileAlignWithOtherDataset(filename,
966
                                                    reinterpret_cast<const Dataset*>(reference));
Guolin Ke's avatar
Guolin Ke committed
967
  }
968
  API_END();
Guolin Ke's avatar
Guolin Ke committed
969
970
}

971

Guolin Ke's avatar
Guolin Ke committed
972
int LGBM_DatasetCreateFromSampledColumn(double** sample_data,
973
974
975
976
977
978
979
                                        int** sample_indices,
                                        int32_t ncol,
                                        const int* num_per_col,
                                        int32_t num_sample_row,
                                        int32_t num_total_row,
                                        const char* parameters,
                                        DatasetHandle* out) {
980
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
981
982
  auto param = Config::Str2Map(parameters);
  Config config;
983
984
985
986
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
Guolin Ke's avatar
Guolin Ke committed
987
  DatasetLoader loader(config, nullptr, 1, nullptr);
988
989
990
  *out = loader.ConstructFromSampleData(sample_data, sample_indices, ncol, num_per_col,
                                        num_sample_row,
                                        static_cast<data_size_t>(num_total_row));
991
  API_END();
Guolin Ke's avatar
Guolin Ke committed
992
993
}

994

Guolin Ke's avatar
Guolin Ke committed
995
int LGBM_DatasetCreateByReference(const DatasetHandle reference,
996
997
                                  int64_t num_total_row,
                                  DatasetHandle* out) {
Guolin Ke's avatar
Guolin Ke committed
998
999
1000
1001
1002
1003
1004
1005
  API_BEGIN();
  std::unique_ptr<Dataset> ret;
  ret.reset(new Dataset(static_cast<data_size_t>(num_total_row)));
  ret->CreateValid(reinterpret_cast<const Dataset*>(reference));
  *out = ret.release();
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1006
int LGBM_DatasetPushRows(DatasetHandle dataset,
1007
1008
1009
1010
1011
                         const void* data,
                         int data_type,
                         int32_t nrow,
                         int32_t ncol,
                         int32_t start_row) {
Guolin Ke's avatar
Guolin Ke committed
1012
1013
1014
  API_BEGIN();
  auto p_dataset = reinterpret_cast<Dataset*>(dataset);
  auto get_row_fun = RowFunctionFromDenseMatric(data, nrow, ncol, data_type, 1);
1015
1016
1017
  if (p_dataset->has_raw()) {
    p_dataset->ResizeRaw(p_dataset->num_numeric_features() + nrow);
  }
1018
  OMP_INIT_EX();
Guolin Ke's avatar
Guolin Ke committed
1019
  #pragma omp parallel for schedule(static)
Guolin Ke's avatar
Guolin Ke committed
1020
  for (int i = 0; i < nrow; ++i) {
1021
    OMP_LOOP_EX_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1022
1023
1024
    const int tid = omp_get_thread_num();
    auto one_row = get_row_fun(i);
    p_dataset->PushOneRow(tid, start_row + i, one_row);
1025
    OMP_LOOP_EX_END();
Guolin Ke's avatar
Guolin Ke committed
1026
  }
1027
  OMP_THROW_EX();
Guolin Ke's avatar
Guolin Ke committed
1028
1029
1030
1031
1032
1033
  if (start_row + nrow == p_dataset->num_data()) {
    p_dataset->FinishLoad();
  }
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1034
int LGBM_DatasetPushRowsByCSR(DatasetHandle dataset,
1035
1036
1037
1038
1039
1040
1041
1042
1043
                              const void* indptr,
                              int indptr_type,
                              const int32_t* indices,
                              const void* data,
                              int data_type,
                              int64_t nindptr,
                              int64_t nelem,
                              int64_t,
                              int64_t start_row) {
Guolin Ke's avatar
Guolin Ke committed
1044
1045
  API_BEGIN();
  auto p_dataset = reinterpret_cast<Dataset*>(dataset);
1046
  auto get_row_fun = RowFunctionFromCSR<int>(indptr, indptr_type, indices, data, data_type, nindptr, nelem);
Guolin Ke's avatar
Guolin Ke committed
1047
  int32_t nrow = static_cast<int32_t>(nindptr - 1);
1048
1049
1050
  if (p_dataset->has_raw()) {
    p_dataset->ResizeRaw(p_dataset->num_numeric_features() + nrow);
  }
1051
  OMP_INIT_EX();
Guolin Ke's avatar
Guolin Ke committed
1052
  #pragma omp parallel for schedule(static)
Guolin Ke's avatar
Guolin Ke committed
1053
  for (int i = 0; i < nrow; ++i) {
1054
    OMP_LOOP_EX_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1055
1056
    const int tid = omp_get_thread_num();
    auto one_row = get_row_fun(i);
1057
    p_dataset->PushOneRow(tid, static_cast<data_size_t>(start_row + i), one_row);
1058
    OMP_LOOP_EX_END();
Guolin Ke's avatar
Guolin Ke committed
1059
  }
1060
  OMP_THROW_EX();
Guolin Ke's avatar
Guolin Ke committed
1061
1062
1063
1064
1065
1066
  if (start_row + nrow == static_cast<int64_t>(p_dataset->num_data())) {
    p_dataset->FinishLoad();
  }
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1067
int LGBM_DatasetCreateFromMat(const void* data,
1068
1069
1070
1071
1072
1073
1074
                              int data_type,
                              int32_t nrow,
                              int32_t ncol,
                              int is_row_major,
                              const char* parameters,
                              const DatasetHandle reference,
                              DatasetHandle* out) {
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
  return LGBM_DatasetCreateFromMats(1,
                                    &data,
                                    data_type,
                                    &nrow,
                                    ncol,
                                    is_row_major,
                                    parameters,
                                    reference,
                                    out);
}

int LGBM_DatasetCreateFromMats(int32_t nmat,
                               const void** data,
                               int data_type,
                               int32_t* nrow,
                               int32_t ncol,
                               int is_row_major,
                               const char* parameters,
                               const DatasetHandle reference,
                               DatasetHandle* out) {
1095
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1096
1097
  auto param = Config::Str2Map(parameters);
  Config config;
1098
1099
1100
1101
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
Guolin Ke's avatar
Guolin Ke committed
1102
  std::unique_ptr<Dataset> ret;
1103
1104
1105
1106
1107
1108
1109
1110
1111
  int32_t total_nrow = 0;
  for (int j = 0; j < nmat; ++j) {
    total_nrow += nrow[j];
  }

  std::vector<std::function<std::vector<double>(int row_idx)>> get_row_fun;
  for (int j = 0; j < nmat; ++j) {
    get_row_fun.push_back(RowFunctionFromDenseMatric(data[j], nrow[j], ncol, data_type, is_row_major));
  }
1112

Guolin Ke's avatar
Guolin Ke committed
1113
1114
  if (reference == nullptr) {
    // sample data first
1115
1116
    auto sample_indices = CreateSampleIndices(total_nrow, config);
    int sample_cnt = static_cast<int>(sample_indices.size());
1117
    std::vector<std::vector<double>> sample_values(ncol);
Guolin Ke's avatar
Guolin Ke committed
1118
    std::vector<std::vector<int>> sample_idx(ncol);
1119
1120
1121

    int offset = 0;
    int j = 0;
Guolin Ke's avatar
Guolin Ke committed
1122
    for (size_t i = 0; i < sample_indices.size(); ++i) {
Guolin Ke's avatar
Guolin Ke committed
1123
      auto idx = sample_indices[i];
1124
1125
1126
1127
      while ((idx - offset) >= nrow[j]) {
        offset += nrow[j];
        ++j;
      }
1128

1129
1130
1131
1132
1133
      auto row = get_row_fun[j](static_cast<int>(idx - offset));
      for (size_t k = 0; k < row.size(); ++k) {
        if (std::fabs(row[k]) > kZeroThreshold || std::isnan(row[k])) {
          sample_values[k].emplace_back(row[k]);
          sample_idx[k].emplace_back(static_cast<int>(i));
Guolin Ke's avatar
Guolin Ke committed
1134
        }
Guolin Ke's avatar
Guolin Ke committed
1135
1136
      }
    }
Guolin Ke's avatar
Guolin Ke committed
1137
    DatasetLoader loader(config, nullptr, 1, nullptr);
1138
1139
1140
1141
1142
    ret.reset(loader.ConstructFromSampleData(Vector2Ptr<double>(&sample_values).data(),
                                             Vector2Ptr<int>(&sample_idx).data(),
                                             ncol,
                                             VectorSize<double>(sample_values).data(),
                                             sample_cnt, total_nrow));
Guolin Ke's avatar
Guolin Ke committed
1143
  } else {
1144
    ret.reset(new Dataset(total_nrow));
Guolin Ke's avatar
Guolin Ke committed
1145
    ret->CreateValid(
1146
      reinterpret_cast<const Dataset*>(reference));
1147
1148
1149
    if (ret->has_raw()) {
      ret->ResizeRaw(total_nrow);
    }
Guolin Ke's avatar
Guolin Ke committed
1150
  }
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
  int32_t start_row = 0;
  for (int j = 0; j < nmat; ++j) {
    OMP_INIT_EX();
    #pragma omp parallel for schedule(static)
    for (int i = 0; i < nrow[j]; ++i) {
      OMP_LOOP_EX_BEGIN();
      const int tid = omp_get_thread_num();
      auto one_row = get_row_fun[j](i);
      ret->PushOneRow(tid, start_row + i, one_row);
      OMP_LOOP_EX_END();
    }
    OMP_THROW_EX();

    start_row += nrow[j];
Guolin Ke's avatar
Guolin Ke committed
1165
1166
  }
  ret->FinishLoad();
Guolin Ke's avatar
Guolin Ke committed
1167
  *out = ret.release();
1168
  API_END();
1169
1170
}

Guolin Ke's avatar
Guolin Ke committed
1171
int LGBM_DatasetCreateFromCSR(const void* indptr,
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
                              int indptr_type,
                              const int32_t* indices,
                              const void* data,
                              int data_type,
                              int64_t nindptr,
                              int64_t nelem,
                              int64_t num_col,
                              const char* parameters,
                              const DatasetHandle reference,
                              DatasetHandle* out) {
1182
  API_BEGIN();
1183
1184
1185
1186
1187
  if (num_col <= 0) {
    Log::Fatal("The number of columns should be greater than zero.");
  } else if (num_col >= INT32_MAX) {
    Log::Fatal("The number of columns should be smaller than INT32_MAX.");
  }
Guolin Ke's avatar
Guolin Ke committed
1188
1189
  auto param = Config::Str2Map(parameters);
  Config config;
1190
1191
1192
1193
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
Guolin Ke's avatar
Guolin Ke committed
1194
  std::unique_ptr<Dataset> ret;
1195
  auto get_row_fun = RowFunctionFromCSR<int>(indptr, indptr_type, indices, data, data_type, nindptr, nelem);
1196
1197
1198
  int32_t nrow = static_cast<int32_t>(nindptr - 1);
  if (reference == nullptr) {
    // sample data first
1199
1200
    auto sample_indices = CreateSampleIndices(nrow, config);
    int sample_cnt = static_cast<int>(sample_indices.size());
Guolin Ke's avatar
Guolin Ke committed
1201
1202
    std::vector<std::vector<double>> sample_values(num_col);
    std::vector<std::vector<int>> sample_idx(num_col);
1203
1204
1205
1206
    for (size_t i = 0; i < sample_indices.size(); ++i) {
      auto idx = sample_indices[i];
      auto row = get_row_fun(static_cast<int>(idx));
      for (std::pair<int, double>& inner_data : row) {
Nikita Titov's avatar
Nikita Titov committed
1207
        CHECK_LT(inner_data.first, num_col);
Guolin Ke's avatar
Guolin Ke committed
1208
        if (std::fabs(inner_data.second) > kZeroThreshold || std::isnan(inner_data.second)) {
Guolin Ke's avatar
Guolin Ke committed
1209
1210
          sample_values[inner_data.first].emplace_back(inner_data.second);
          sample_idx[inner_data.first].emplace_back(static_cast<int>(i));
1211
1212
1213
        }
      }
    }
Guolin Ke's avatar
Guolin Ke committed
1214
    DatasetLoader loader(config, nullptr, 1, nullptr);
1215
1216
1217
1218
1219
    ret.reset(loader.ConstructFromSampleData(Vector2Ptr<double>(&sample_values).data(),
                                             Vector2Ptr<int>(&sample_idx).data(),
                                             static_cast<int>(num_col),
                                             VectorSize<double>(sample_values).data(),
                                             sample_cnt, nrow));
1220
  } else {
1221
    ret.reset(new Dataset(nrow));
Guolin Ke's avatar
Guolin Ke committed
1222
    ret->CreateValid(
1223
      reinterpret_cast<const Dataset*>(reference));
1224
1225
1226
    if (ret->has_raw()) {
      ret->ResizeRaw(nrow);
    }
1227
  }
1228
  OMP_INIT_EX();
Guolin Ke's avatar
Guolin Ke committed
1229
  #pragma omp parallel for schedule(static)
1230
  for (int i = 0; i < nindptr - 1; ++i) {
1231
    OMP_LOOP_EX_BEGIN();
1232
1233
1234
    const int tid = omp_get_thread_num();
    auto one_row = get_row_fun(i);
    ret->PushOneRow(tid, i, one_row);
1235
    OMP_LOOP_EX_END();
1236
  }
1237
  OMP_THROW_EX();
1238
  ret->FinishLoad();
Guolin Ke's avatar
Guolin Ke committed
1239
  *out = ret.release();
1240
  API_END();
1241
1242
}

1243
int LGBM_DatasetCreateFromCSRFunc(void* get_row_funptr,
1244
1245
1246
1247
1248
                                  int num_rows,
                                  int64_t num_col,
                                  const char* parameters,
                                  const DatasetHandle reference,
                                  DatasetHandle* out) {
1249
  API_BEGIN();
1250
1251
1252
1253
1254
  if (num_col <= 0) {
    Log::Fatal("The number of columns should be greater than zero.");
  } else if (num_col >= INT32_MAX) {
    Log::Fatal("The number of columns should be smaller than INT32_MAX.");
  }
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
  auto get_row_fun = *static_cast<std::function<void(int idx, std::vector<std::pair<int, double>>&)>*>(get_row_funptr);
  auto param = Config::Str2Map(parameters);
  Config config;
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
  std::unique_ptr<Dataset> ret;
  int32_t nrow = num_rows;
  if (reference == nullptr) {
    // sample data first
1266
1267
    auto sample_indices = CreateSampleIndices(nrow, config);
    int sample_cnt = static_cast<int>(sample_indices.size());
1268
1269
1270
1271
1272
1273
1274
1275
    std::vector<std::vector<double>> sample_values(num_col);
    std::vector<std::vector<int>> sample_idx(num_col);
    // local buffer to re-use memory
    std::vector<std::pair<int, double>> buffer;
    for (size_t i = 0; i < sample_indices.size(); ++i) {
      auto idx = sample_indices[i];
      get_row_fun(static_cast<int>(idx), buffer);
      for (std::pair<int, double>& inner_data : buffer) {
Nikita Titov's avatar
Nikita Titov committed
1276
        CHECK_LT(inner_data.first, num_col);
1277
1278
1279
1280
1281
1282
1283
        if (std::fabs(inner_data.second) > kZeroThreshold || std::isnan(inner_data.second)) {
          sample_values[inner_data.first].emplace_back(inner_data.second);
          sample_idx[inner_data.first].emplace_back(static_cast<int>(i));
        }
      }
    }
    DatasetLoader loader(config, nullptr, 1, nullptr);
1284
1285
1286
1287
1288
    ret.reset(loader.ConstructFromSampleData(Vector2Ptr<double>(&sample_values).data(),
                                             Vector2Ptr<int>(&sample_idx).data(),
                                             static_cast<int>(num_col),
                                             VectorSize<double>(sample_values).data(),
                                             sample_cnt, nrow));
1289
1290
1291
1292
  } else {
    ret.reset(new Dataset(nrow));
    ret->CreateValid(
      reinterpret_cast<const Dataset*>(reference));
1293
1294
1295
    if (ret->has_raw()) {
      ret->ResizeRaw(nrow);
    }
1296
  }
1297

1298
  OMP_INIT_EX();
Guolin Ke's avatar
Guolin Ke committed
1299
1300
  std::vector<std::pair<int, double>> thread_buffer;
  #pragma omp parallel for schedule(static) private(thread_buffer)
1301
1302
1303
  for (int i = 0; i < num_rows; ++i) {
    OMP_LOOP_EX_BEGIN();
    {
1304
      const int tid = omp_get_thread_num();
Guolin Ke's avatar
Guolin Ke committed
1305
1306
      get_row_fun(i, thread_buffer);
      ret->PushOneRow(tid, i, thread_buffer);
1307
1308
1309
1310
1311
1312
1313
1314
1315
    }
    OMP_LOOP_EX_END();
  }
  OMP_THROW_EX();
  ret->FinishLoad();
  *out = ret.release();
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1316
int LGBM_DatasetCreateFromCSC(const void* col_ptr,
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
                              int col_ptr_type,
                              const int32_t* indices,
                              const void* data,
                              int data_type,
                              int64_t ncol_ptr,
                              int64_t nelem,
                              int64_t num_row,
                              const char* parameters,
                              const DatasetHandle reference,
                              DatasetHandle* out) {
1327
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1328
1329
  auto param = Config::Str2Map(parameters);
  Config config;
1330
1331
1332
1333
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
Guolin Ke's avatar
Guolin Ke committed
1334
  std::unique_ptr<Dataset> ret;
Guolin Ke's avatar
Guolin Ke committed
1335
1336
1337
  int32_t nrow = static_cast<int32_t>(num_row);
  if (reference == nullptr) {
    // sample data first
1338
1339
    auto sample_indices = CreateSampleIndices(nrow, config);
    int sample_cnt = static_cast<int>(sample_indices.size());
Guolin Ke's avatar
Guolin Ke committed
1340
    std::vector<std::vector<double>> sample_values(ncol_ptr - 1);
Guolin Ke's avatar
Guolin Ke committed
1341
    std::vector<std::vector<int>> sample_idx(ncol_ptr - 1);
1342
    OMP_INIT_EX();
Guolin Ke's avatar
Guolin Ke committed
1343
    #pragma omp parallel for schedule(static)
Guolin Ke's avatar
Guolin Ke committed
1344
    for (int i = 0; i < static_cast<int>(sample_values.size()); ++i) {
1345
      OMP_LOOP_EX_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1346
1347
1348
      CSC_RowIterator col_it(col_ptr, col_ptr_type, indices, data, data_type, ncol_ptr, nelem, i);
      for (int j = 0; j < sample_cnt; j++) {
        auto val = col_it.Get(sample_indices[j]);
Guolin Ke's avatar
Guolin Ke committed
1349
        if (std::fabs(val) > kZeroThreshold || std::isnan(val)) {
Guolin Ke's avatar
Guolin Ke committed
1350
1351
          sample_values[i].emplace_back(val);
          sample_idx[i].emplace_back(j);
Guolin Ke's avatar
Guolin Ke committed
1352
1353
        }
      }
1354
      OMP_LOOP_EX_END();
Guolin Ke's avatar
Guolin Ke committed
1355
    }
1356
    OMP_THROW_EX();
Guolin Ke's avatar
Guolin Ke committed
1357
    DatasetLoader loader(config, nullptr, 1, nullptr);
1358
1359
1360
1361
1362
    ret.reset(loader.ConstructFromSampleData(Vector2Ptr<double>(&sample_values).data(),
                                             Vector2Ptr<int>(&sample_idx).data(),
                                             static_cast<int>(sample_values.size()),
                                             VectorSize<double>(sample_values).data(),
                                             sample_cnt, nrow));
Guolin Ke's avatar
Guolin Ke committed
1363
  } else {
1364
    ret.reset(new Dataset(nrow));
Guolin Ke's avatar
Guolin Ke committed
1365
    ret->CreateValid(
1366
      reinterpret_cast<const Dataset*>(reference));
Guolin Ke's avatar
Guolin Ke committed
1367
  }
1368
  OMP_INIT_EX();
Guolin Ke's avatar
Guolin Ke committed
1369
  #pragma omp parallel for schedule(static)
Guolin Ke's avatar
Guolin Ke committed
1370
  for (int i = 0; i < ncol_ptr - 1; ++i) {
1371
    OMP_LOOP_EX_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1372
    const int tid = omp_get_thread_num();
Guolin Ke's avatar
Guolin Ke committed
1373
    int feature_idx = ret->InnerFeatureIndex(i);
Guolin Ke's avatar
Guolin Ke committed
1374
    if (feature_idx < 0) { continue; }
Guolin Ke's avatar
Guolin Ke committed
1375
1376
    int group = ret->Feature2Group(feature_idx);
    int sub_feature = ret->Feture2SubFeature(feature_idx);
Guolin Ke's avatar
Guolin Ke committed
1377
    CSC_RowIterator col_it(col_ptr, col_ptr_type, indices, data, data_type, ncol_ptr, nelem, i);
Guolin Ke's avatar
Guolin Ke committed
1378
1379
1380
1381
1382
1383
1384
1385
    auto bin_mapper = ret->FeatureBinMapper(feature_idx);
    if (bin_mapper->GetDefaultBin() == bin_mapper->GetMostFreqBin()) {
      int row_idx = 0;
      while (row_idx < nrow) {
        auto pair = col_it.NextNonZero();
        row_idx = pair.first;
        // no more data
        if (row_idx < 0) { break; }
1386
        ret->PushOneData(tid, row_idx, group, feature_idx, sub_feature, pair.second);
Guolin Ke's avatar
Guolin Ke committed
1387
1388
1389
1390
      }
    } else {
      for (int row_idx = 0; row_idx < nrow; ++row_idx) {
        auto val = col_it.Get(row_idx);
1391
        ret->PushOneData(tid, row_idx, group, feature_idx, sub_feature, val);
Guolin Ke's avatar
Guolin Ke committed
1392
      }
Guolin Ke's avatar
Guolin Ke committed
1393
    }
1394
    OMP_LOOP_EX_END();
Guolin Ke's avatar
Guolin Ke committed
1395
  }
1396
  OMP_THROW_EX();
Guolin Ke's avatar
Guolin Ke committed
1397
  ret->FinishLoad();
Guolin Ke's avatar
Guolin Ke committed
1398
  *out = ret.release();
1399
  API_END();
Guolin Ke's avatar
Guolin Ke committed
1400
1401
}

Guolin Ke's avatar
Guolin Ke committed
1402
int LGBM_DatasetGetSubset(
1403
  const DatasetHandle handle,
wxchan's avatar
wxchan committed
1404
1405
1406
  const int32_t* used_row_indices,
  int32_t num_used_row_indices,
  const char* parameters,
Guolin Ke's avatar
typo  
Guolin Ke committed
1407
  DatasetHandle* out) {
wxchan's avatar
wxchan committed
1408
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1409
1410
  auto param = Config::Str2Map(parameters);
  Config config;
1411
1412
1413
1414
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
1415
  auto full_dataset = reinterpret_cast<const Dataset*>(handle);
1416
  CHECK_GT(num_used_row_indices, 0);
1417
1418
  const int32_t lower = 0;
  const int32_t upper = full_dataset->num_data() - 1;
1419
  CheckElementsIntervalClosed(used_row_indices, lower, upper, num_used_row_indices, "Used indices of subset");
1420
1421
1422
  if (!std::is_sorted(used_row_indices, used_row_indices + num_used_row_indices)) {
    Log::Fatal("used_row_indices should be sorted in Subset");
  }
Guolin Ke's avatar
Guolin Ke committed
1423
  auto ret = std::unique_ptr<Dataset>(new Dataset(num_used_row_indices));
1424
  ret->CopyFeatureMapperFrom(full_dataset);
1425
  ret->CopySubrow(full_dataset, used_row_indices, num_used_row_indices, true);
wxchan's avatar
wxchan committed
1426
1427
1428
1429
  *out = ret.release();
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1430
int LGBM_DatasetSetFeatureNames(
Guolin Ke's avatar
typo  
Guolin Ke committed
1431
  DatasetHandle handle,
Guolin Ke's avatar
Guolin Ke committed
1432
  const char** feature_names,
Guolin Ke's avatar
Guolin Ke committed
1433
  int num_feature_names) {
Guolin Ke's avatar
Guolin Ke committed
1434
1435
1436
  API_BEGIN();
  auto dataset = reinterpret_cast<Dataset*>(handle);
  std::vector<std::string> feature_names_str;
Guolin Ke's avatar
Guolin Ke committed
1437
  for (int i = 0; i < num_feature_names; ++i) {
Guolin Ke's avatar
Guolin Ke committed
1438
1439
1440
1441
1442
1443
    feature_names_str.emplace_back(feature_names[i]);
  }
  dataset->set_feature_names(feature_names_str);
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1444
int LGBM_DatasetGetFeatureNames(
1445
1446
1447
1448
1449
1450
    DatasetHandle handle,
    const int len,
    int* num_feature_names,
    const size_t buffer_len,
    size_t* out_buffer_len,
    char** feature_names) {
1451
  API_BEGIN();
1452
  *out_buffer_len = 0;
1453
1454
  auto dataset = reinterpret_cast<Dataset*>(handle);
  auto inside_feature_name = dataset->feature_names();
Guolin Ke's avatar
Guolin Ke committed
1455
1456
  *num_feature_names = static_cast<int>(inside_feature_name.size());
  for (int i = 0; i < *num_feature_names; ++i) {
1457
1458
1459
1460
1461
    if (i < len) {
      std::memcpy(feature_names[i], inside_feature_name[i].c_str(), std::min(inside_feature_name[i].size() + 1, buffer_len));
      feature_names[i][buffer_len - 1] = '\0';
    }
    *out_buffer_len = std::max(inside_feature_name[i].size() + 1, *out_buffer_len);
1462
1463
1464
1465
  }
  API_END();
}

1466
1467
1468
#ifdef _MSC_VER
  #pragma warning(disable : 4702)
#endif
Guolin Ke's avatar
Guolin Ke committed
1469
int LGBM_DatasetFree(DatasetHandle handle) {
1470
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1471
  delete reinterpret_cast<Dataset*>(handle);
1472
  API_END();
1473
1474
}

Guolin Ke's avatar
Guolin Ke committed
1475
int LGBM_DatasetSaveBinary(DatasetHandle handle,
1476
                           const char* filename) {
1477
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1478
1479
  auto dataset = reinterpret_cast<Dataset*>(handle);
  dataset->SaveBinaryFile(filename);
1480
  API_END();
1481
1482
}

1483
1484
1485
1486
1487
1488
1489
1490
int LGBM_DatasetDumpText(DatasetHandle handle,
                         const char* filename) {
  API_BEGIN();
  auto dataset = reinterpret_cast<Dataset*>(handle);
  dataset->DumpTextFile(filename);
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1491
int LGBM_DatasetSetField(DatasetHandle handle,
1492
1493
1494
1495
                         const char* field_name,
                         const void* field_data,
                         int num_element,
                         int type) {
1496
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1497
  auto dataset = reinterpret_cast<Dataset*>(handle);
1498
  bool is_success = false;
Guolin Ke's avatar
Guolin Ke committed
1499
  if (type == C_API_DTYPE_FLOAT32) {
Guolin Ke's avatar
Guolin Ke committed
1500
    is_success = dataset->SetFloatField(field_name, reinterpret_cast<const float*>(field_data), static_cast<int32_t>(num_element));
Guolin Ke's avatar
Guolin Ke committed
1501
  } else if (type == C_API_DTYPE_INT32) {
Guolin Ke's avatar
Guolin Ke committed
1502
    is_success = dataset->SetIntField(field_name, reinterpret_cast<const int*>(field_data), static_cast<int32_t>(num_element));
Guolin Ke's avatar
Guolin Ke committed
1503
1504
  } else if (type == C_API_DTYPE_FLOAT64) {
    is_success = dataset->SetDoubleField(field_name, reinterpret_cast<const double*>(field_data), static_cast<int32_t>(num_element));
1505
  }
1506
  if (!is_success) { Log::Fatal("Input data type error or field not found"); }
1507
  API_END();
1508
1509
}

Guolin Ke's avatar
Guolin Ke committed
1510
int LGBM_DatasetGetField(DatasetHandle handle,
1511
1512
1513
1514
                         const char* field_name,
                         int* out_len,
                         const void** out_ptr,
                         int* out_type) {
1515
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1516
  auto dataset = reinterpret_cast<Dataset*>(handle);
1517
  bool is_success = false;
Guolin Ke's avatar
Guolin Ke committed
1518
  if (dataset->GetFloatField(field_name, out_len, reinterpret_cast<const float**>(out_ptr))) {
Guolin Ke's avatar
Guolin Ke committed
1519
    *out_type = C_API_DTYPE_FLOAT32;
1520
    is_success = true;
Guolin Ke's avatar
Guolin Ke committed
1521
  } else if (dataset->GetIntField(field_name, out_len, reinterpret_cast<const int**>(out_ptr))) {
Guolin Ke's avatar
Guolin Ke committed
1522
    *out_type = C_API_DTYPE_INT32;
1523
    is_success = true;
Guolin Ke's avatar
Guolin Ke committed
1524
1525
1526
  } else if (dataset->GetDoubleField(field_name, out_len, reinterpret_cast<const double**>(out_ptr))) {
    *out_type = C_API_DTYPE_FLOAT64;
    is_success = true;
Nikita Titov's avatar
Nikita Titov committed
1527
  }
1528
  if (!is_success) { Log::Fatal("Field not found"); }
wxchan's avatar
wxchan committed
1529
  if (*out_ptr == nullptr) { *out_len = 0; }
1530
  API_END();
1531
1532
}

1533
int LGBM_DatasetUpdateParamChecking(const char* old_parameters, const char* new_parameters) {
1534
  API_BEGIN();
1535
1536
1537
1538
1539
  auto old_param = Config::Str2Map(old_parameters);
  Config old_config;
  old_config.Set(old_param);
  auto new_param = Config::Str2Map(new_parameters);
  Booster::CheckDatasetResetConfig(old_config, new_param);
1540
1541
1542
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1543
int LGBM_DatasetGetNumData(DatasetHandle handle,
1544
                           int* out) {
1545
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1546
1547
  auto dataset = reinterpret_cast<Dataset*>(handle);
  *out = dataset->num_data();
1548
  API_END();
1549
1550
}

Guolin Ke's avatar
Guolin Ke committed
1551
int LGBM_DatasetGetNumFeature(DatasetHandle handle,
1552
                              int* out) {
1553
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1554
1555
  auto dataset = reinterpret_cast<Dataset*>(handle);
  *out = dataset->num_total_features();
1556
  API_END();
Guolin Ke's avatar
Guolin Ke committed
1557
}
1558

1559
1560
1561
1562
1563
int LGBM_DatasetAddFeaturesFrom(DatasetHandle target,
                                DatasetHandle source) {
  API_BEGIN();
  auto target_d = reinterpret_cast<Dataset*>(target);
  auto source_d = reinterpret_cast<Dataset*>(source);
1564
  target_d->AddFeaturesFrom(source_d);
1565
1566
1567
  API_END();
}

1568
1569
// ---- start of booster

Guolin Ke's avatar
Guolin Ke committed
1570
int LGBM_BoosterCreate(const DatasetHandle train_data,
1571
1572
                       const char* parameters,
                       BoosterHandle* out) {
1573
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1574
  const Dataset* p_train_data = reinterpret_cast<const Dataset*>(train_data);
wxchan's avatar
wxchan committed
1575
1576
  auto ret = std::unique_ptr<Booster>(new Booster(p_train_data, parameters));
  *out = ret.release();
1577
  API_END();
1578
1579
}

Guolin Ke's avatar
Guolin Ke committed
1580
int LGBM_BoosterCreateFromModelfile(
1581
  const char* filename,
Guolin Ke's avatar
Guolin Ke committed
1582
  int* out_num_iterations,
1583
  BoosterHandle* out) {
1584
  API_BEGIN();
wxchan's avatar
wxchan committed
1585
  auto ret = std::unique_ptr<Booster>(new Booster(filename));
Guolin Ke's avatar
Guolin Ke committed
1586
  *out_num_iterations = ret->GetBoosting()->GetCurrentIteration();
wxchan's avatar
wxchan committed
1587
  *out = ret.release();
1588
  API_END();
1589
1590
}

Guolin Ke's avatar
Guolin Ke committed
1591
int LGBM_BoosterLoadModelFromString(
1592
1593
1594
1595
  const char* model_str,
  int* out_num_iterations,
  BoosterHandle* out) {
  API_BEGIN();
wxchan's avatar
wxchan committed
1596
  auto ret = std::unique_ptr<Booster>(new Booster(nullptr));
1597
1598
1599
1600
1601
1602
  ret->LoadModelFromString(model_str);
  *out_num_iterations = ret->GetBoosting()->GetCurrentIteration();
  *out = ret.release();
  API_END();
}

1603
1604
1605
#ifdef _MSC_VER
  #pragma warning(disable : 4702)
#endif
Guolin Ke's avatar
Guolin Ke committed
1606
int LGBM_BoosterFree(BoosterHandle handle) {
1607
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1608
  delete reinterpret_cast<Booster*>(handle);
1609
  API_END();
1610
1611
}

1612
int LGBM_BoosterShuffleModels(BoosterHandle handle, int start_iter, int end_iter) {
1613
1614
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
1615
  ref_booster->ShuffleModels(start_iter, end_iter);
1616
1617
1618
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1619
int LGBM_BoosterMerge(BoosterHandle handle,
1620
                      BoosterHandle other_handle) {
wxchan's avatar
wxchan committed
1621
1622
1623
1624
1625
1626
1627
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  Booster* ref_other_booster = reinterpret_cast<Booster*>(other_handle);
  ref_booster->MergeFrom(ref_other_booster);
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1628
int LGBM_BoosterAddValidData(BoosterHandle handle,
1629
                             const DatasetHandle valid_data) {
wxchan's avatar
wxchan committed
1630
1631
1632
1633
1634
1635
1636
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  const Dataset* p_dataset = reinterpret_cast<const Dataset*>(valid_data);
  ref_booster->AddValidData(p_dataset);
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1637
int LGBM_BoosterResetTrainingData(BoosterHandle handle,
1638
                                  const DatasetHandle train_data) {
wxchan's avatar
wxchan committed
1639
1640
1641
1642
1643
1644
1645
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  const Dataset* p_dataset = reinterpret_cast<const Dataset*>(train_data);
  ref_booster->ResetTrainingData(p_dataset);
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1646
int LGBM_BoosterResetParameter(BoosterHandle handle, const char* parameters) {
wxchan's avatar
wxchan committed
1647
1648
1649
1650
1651
1652
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  ref_booster->ResetConfig(parameters);
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1653
int LGBM_BoosterGetNumClasses(BoosterHandle handle, int* out_len) {
wxchan's avatar
wxchan committed
1654
1655
1656
1657
1658
1659
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  *out_len = ref_booster->GetBoosting()->NumberOfClasses();
  API_END();
}

1660
1661
1662
1663
1664
1665
1666
int LGBM_BoosterGetLinear(BoosterHandle handle, bool* out) {
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  *out = ref_booster->GetBoosting()->IsLinear();
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1667
1668
1669
1670
1671
1672
1673
int LGBM_BoosterRefit(BoosterHandle handle, const int32_t* leaf_preds, int32_t nrow, int32_t ncol) {
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  ref_booster->Refit(leaf_preds, nrow, ncol);
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1674
int LGBM_BoosterUpdateOneIter(BoosterHandle handle, int* is_finished) {
1675
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1676
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
1677
1678
1679
1680
1681
  if (ref_booster->TrainOneIter()) {
    *is_finished = 1;
  } else {
    *is_finished = 0;
  }
1682
  API_END();
1683
1684
}

Guolin Ke's avatar
Guolin Ke committed
1685
int LGBM_BoosterUpdateOneIterCustom(BoosterHandle handle,
1686
1687
1688
                                    const float* grad,
                                    const float* hess,
                                    int* is_finished) {
1689
  API_BEGIN();
1690
  #ifdef SCORE_T_USE_DOUBLE
1691
1692
1693
1694
  (void) handle;       // UNUSED VARIABLE
  (void) grad;         // UNUSED VARIABLE
  (void) hess;         // UNUSED VARIABLE
  (void) is_finished;  // UNUSED VARIABLE
1695
  Log::Fatal("Don't support custom loss function when SCORE_T_USE_DOUBLE is enabled");
1696
  #else
1697
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
1698
1699
1700
1701
1702
  if (ref_booster->TrainOneIter(grad, hess)) {
    *is_finished = 1;
  } else {
    *is_finished = 0;
  }
1703
  #endif
1704
  API_END();
1705
1706
}

Guolin Ke's avatar
Guolin Ke committed
1707
int LGBM_BoosterRollbackOneIter(BoosterHandle handle) {
wxchan's avatar
wxchan committed
1708
1709
1710
1711
1712
1713
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  ref_booster->RollbackOneIter();
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1714
int LGBM_BoosterGetCurrentIteration(BoosterHandle handle, int* out_iteration) {
wxchan's avatar
wxchan committed
1715
1716
1717
1718
1719
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  *out_iteration = ref_booster->GetBoosting()->GetCurrentIteration();
  API_END();
}
Guolin Ke's avatar
Guolin Ke committed
1720

1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
int LGBM_BoosterNumModelPerIteration(BoosterHandle handle, int* out_tree_per_iteration) {
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  *out_tree_per_iteration = ref_booster->GetBoosting()->NumModelPerIteration();
  API_END();
}

int LGBM_BoosterNumberOfTotalModel(BoosterHandle handle, int* out_models) {
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  *out_models = ref_booster->GetBoosting()->NumberOfTotalModel();
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1735
int LGBM_BoosterGetEvalCounts(BoosterHandle handle, int* out_len) {
wxchan's avatar
wxchan committed
1736
1737
1738
1739
1740
1741
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  *out_len = ref_booster->GetEvalCounts();
  API_END();
}

1742
1743
1744
1745
1746
1747
int LGBM_BoosterGetEvalNames(BoosterHandle handle,
                             const int len,
                             int* out_len,
                             const size_t buffer_len,
                             size_t* out_buffer_len,
                             char** out_strs) {
wxchan's avatar
wxchan committed
1748
1749
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
1750
  *out_len = ref_booster->GetEvalNames(out_strs, len, buffer_len, out_buffer_len);
wxchan's avatar
wxchan committed
1751
1752
1753
  API_END();
}

1754
1755
1756
1757
1758
1759
int LGBM_BoosterGetFeatureNames(BoosterHandle handle,
                                const int len,
                                int* out_len,
                                const size_t buffer_len,
                                size_t* out_buffer_len,
                                char** out_strs) {
wxchan's avatar
wxchan committed
1760
1761
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
1762
  *out_len = ref_booster->GetFeatureNames(out_strs, len, buffer_len, out_buffer_len);
wxchan's avatar
wxchan committed
1763
1764
1765
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1766
int LGBM_BoosterGetNumFeature(BoosterHandle handle, int* out_len) {
wxchan's avatar
wxchan committed
1767
1768
1769
1770
1771
1772
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  *out_len = ref_booster->GetBoosting()->MaxFeatureIdx() + 1;
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1773
int LGBM_BoosterGetEval(BoosterHandle handle,
1774
1775
1776
                        int data_idx,
                        int* out_len,
                        double* out_results) {
1777
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1778
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
1779
  auto boosting = ref_booster->GetBoosting();
wxchan's avatar
wxchan committed
1780
  auto result_buf = boosting->GetEvalAt(data_idx);
Guolin Ke's avatar
Guolin Ke committed
1781
  *out_len = static_cast<int>(result_buf.size());
1782
  for (size_t i = 0; i < result_buf.size(); ++i) {
Guolin Ke's avatar
Guolin Ke committed
1783
    (out_results)[i] = static_cast<double>(result_buf[i]);
1784
  }
1785
  API_END();
1786
1787
}

Guolin Ke's avatar
Guolin Ke committed
1788
int LGBM_BoosterGetNumPredict(BoosterHandle handle,
1789
1790
                              int data_idx,
                              int64_t* out_len) {
Guolin Ke's avatar
Guolin Ke committed
1791
1792
1793
1794
1795
1796
  API_BEGIN();
  auto boosting = reinterpret_cast<Booster*>(handle)->GetBoosting();
  *out_len = boosting->GetNumPredictAt(data_idx);
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1797
int LGBM_BoosterGetPredict(BoosterHandle handle,
1798
1799
1800
                           int data_idx,
                           int64_t* out_len,
                           double* out_result) {
1801
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1802
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
1803
  ref_booster->GetPredictAt(data_idx, out_result, out_len);
1804
  API_END();
Guolin Ke's avatar
Guolin Ke committed
1805
1806
}

Guolin Ke's avatar
Guolin Ke committed
1807
int LGBM_BoosterPredictForFile(BoosterHandle handle,
1808
1809
1810
                               const char* data_filename,
                               int data_has_header,
                               int predict_type,
1811
                               int start_iteration,
1812
                               int num_iteration,
1813
                               const char* parameter,
1814
                               const char* result_filename) {
1815
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1816
1817
  auto param = Config::Str2Map(parameter);
  Config config;
Guolin Ke's avatar
Guolin Ke committed
1818
1819
1820
1821
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
Guolin Ke's avatar
Guolin Ke committed
1822
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
1823
  ref_booster->Predict(start_iteration, num_iteration, predict_type, data_filename, data_has_header,
Guolin Ke's avatar
Guolin Ke committed
1824
                       config, result_filename);
1825
  API_END();
1826
1827
}

Guolin Ke's avatar
Guolin Ke committed
1828
int LGBM_BoosterCalcNumPredict(BoosterHandle handle,
1829
1830
                               int num_row,
                               int predict_type,
1831
                               int start_iteration,
1832
1833
                               int num_iteration,
                               int64_t* out_len) {
Guolin Ke's avatar
Guolin Ke committed
1834
1835
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
1836
  *out_len = static_cast<int64_t>(num_row) * ref_booster->GetBoosting()->NumPredictOneRow(start_iteration,
1837
    num_iteration, predict_type == C_API_PREDICT_LEAF_INDEX, predict_type == C_API_PREDICT_CONTRIB);
Guolin Ke's avatar
Guolin Ke committed
1838
1839
1840
  API_END();
}

1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
/*!
 * \brief Object to store resources meant for single-row Fast Predict methods.
 *
 * Meant to be used as a basic struct by the *Fast* predict methods only.
 * It stores the configuration resources for reuse during prediction.
 *
 * Even the row function is stored. We score the instance at the same memory
 * address all the time. One just replaces the feature values at that address
 * and scores again with the *Fast* methods.
 */
struct FastConfig {
  FastConfig(Booster *const booster_ptr,
             const char *parameter,
1854
             const int predict_type_,
1855
             const int data_type_,
1856
             const int32_t num_cols) : booster(booster_ptr), predict_type(predict_type_), data_type(data_type_), ncol(num_cols) {
1857
1858
1859
1860
1861
    config.Set(Config::Str2Map(parameter));
  }

  Booster* const booster;
  Config config;
1862
  const int predict_type;
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
  const int data_type;
  const int32_t ncol;
};

int LGBM_FastConfigFree(FastConfigHandle fastConfig) {
  API_BEGIN();
  delete reinterpret_cast<FastConfig*>(fastConfig);
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1873
int LGBM_BoosterPredictForCSR(BoosterHandle handle,
1874
1875
1876
1877
1878
1879
1880
                              const void* indptr,
                              int indptr_type,
                              const int32_t* indices,
                              const void* data,
                              int data_type,
                              int64_t nindptr,
                              int64_t nelem,
1881
                              int64_t num_col,
1882
                              int predict_type,
1883
                              int start_iteration,
1884
                              int num_iteration,
1885
                              const char* parameter,
1886
1887
                              int64_t* out_len,
                              double* out_result) {
1888
  API_BEGIN();
1889
1890
1891
1892
1893
  if (num_col <= 0) {
    Log::Fatal("The number of columns should be greater than zero.");
  } else if (num_col >= INT32_MAX) {
    Log::Fatal("The number of columns should be smaller than INT32_MAX.");
  }
Guolin Ke's avatar
Guolin Ke committed
1894
1895
  auto param = Config::Str2Map(parameter);
  Config config;
Guolin Ke's avatar
Guolin Ke committed
1896
1897
1898
1899
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
Guolin Ke's avatar
Guolin Ke committed
1900
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
1901
  auto get_row_fun = RowFunctionFromCSR<int>(indptr, indptr_type, indices, data, data_type, nindptr, nelem);
Guolin Ke's avatar
Guolin Ke committed
1902
  int nrow = static_cast<int>(nindptr - 1);
1903
  ref_booster->Predict(start_iteration, num_iteration, predict_type, nrow, static_cast<int>(num_col), get_row_fun,
Guolin Ke's avatar
Guolin Ke committed
1904
                       config, out_result, out_len);
1905
  API_END();
Guolin Ke's avatar
Guolin Ke committed
1906
}
1907

1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
int LGBM_BoosterPredictSparseOutput(BoosterHandle handle,
                                    const void* indptr,
                                    int indptr_type,
                                    const int32_t* indices,
                                    const void* data,
                                    int data_type,
                                    int64_t nindptr,
                                    int64_t nelem,
                                    int64_t num_col_or_row,
                                    int predict_type,
1918
                                    int start_iteration,
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
                                    int num_iteration,
                                    const char* parameter,
                                    int matrix_type,
                                    int64_t* out_len,
                                    void** out_indptr,
                                    int32_t** out_indices,
                                    void** out_data) {
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  auto param = Config::Str2Map(parameter);
  Config config;
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
  if (matrix_type == C_API_MATRIX_TYPE_CSR) {
    if (num_col_or_row <= 0) {
      Log::Fatal("The number of columns should be greater than zero.");
    } else if (num_col_or_row >= INT32_MAX) {
      Log::Fatal("The number of columns should be smaller than INT32_MAX.");
    }
    auto get_row_fun = RowFunctionFromCSR<int64_t>(indptr, indptr_type, indices, data, data_type, nindptr, nelem);
    int64_t nrow = nindptr - 1;
1942
    ref_booster->PredictSparseCSR(start_iteration, num_iteration, predict_type, nrow, static_cast<int>(num_col_or_row), get_row_fun,
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
                                  config, out_len, out_indptr, indptr_type, out_indices, out_data, data_type);
  } else if (matrix_type == C_API_MATRIX_TYPE_CSC) {
    int num_threads = OMP_NUM_THREADS();
    int ncol = static_cast<int>(nindptr - 1);
    std::vector<std::vector<CSC_RowIterator>> iterators(num_threads, std::vector<CSC_RowIterator>());
    for (int i = 0; i < num_threads; ++i) {
      for (int j = 0; j < ncol; ++j) {
        iterators[i].emplace_back(indptr, indptr_type, indices, data, data_type, nindptr, nelem, j);
      }
    }
    std::function<std::vector<std::pair<int, double>>(int64_t row_idx)> get_row_fun =
      [&iterators, ncol](int64_t i) {
      std::vector<std::pair<int, double>> one_row;
      one_row.reserve(ncol);
      const int tid = omp_get_thread_num();
      for (int j = 0; j < ncol; ++j) {
        auto val = iterators[tid][j].Get(static_cast<int>(i));
        if (std::fabs(val) > kZeroThreshold || std::isnan(val)) {
          one_row.emplace_back(j, val);
        }
      }
      return one_row;
    };
1966
    ref_booster->PredictSparseCSC(start_iteration, num_iteration, predict_type, num_col_or_row, ncol, get_row_fun, config,
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
                                  out_len, out_indptr, indptr_type, out_indices, out_data, data_type);
  } else {
    Log::Fatal("Unknown matrix type in LGBM_BoosterPredictSparseOutput");
  }
  API_END();
}

int LGBM_BoosterFreePredictSparse(void* indptr, int32_t* indices, void* data, int indptr_type, int data_type) {
  API_BEGIN();
  if (indptr_type == C_API_DTYPE_INT32) {
    delete reinterpret_cast<int32_t*>(indptr);
  } else if (indptr_type == C_API_DTYPE_INT64) {
    delete reinterpret_cast<int64_t*>(indptr);
  } else {
    Log::Fatal("Unknown indptr type in LGBM_BoosterFreePredictSparse");
  }
  delete indices;
  if (data_type == C_API_DTYPE_FLOAT32) {
    delete reinterpret_cast<float*>(data);
  } else if (data_type == C_API_DTYPE_FLOAT64) {
    delete reinterpret_cast<double*>(data);
  } else {
    Log::Fatal("Unknown data type in LGBM_BoosterFreePredictSparse");
  }
  API_END();
}

1994
int LGBM_BoosterPredictForCSRSingleRow(BoosterHandle handle,
1995
1996
1997
1998
1999
2000
2001
                                       const void* indptr,
                                       int indptr_type,
                                       const int32_t* indices,
                                       const void* data,
                                       int data_type,
                                       int64_t nindptr,
                                       int64_t nelem,
2002
                                       int64_t num_col,
2003
                                       int predict_type,
2004
                                       int start_iteration,
2005
2006
2007
2008
                                       int num_iteration,
                                       const char* parameter,
                                       int64_t* out_len,
                                       double* out_result) {
2009
  API_BEGIN();
2010
2011
2012
2013
2014
  if (num_col <= 0) {
    Log::Fatal("The number of columns should be greater than zero.");
  } else if (num_col >= INT32_MAX) {
    Log::Fatal("The number of columns should be smaller than INT32_MAX.");
  }
2015
2016
2017
2018
2019
2020
2021
  auto param = Config::Str2Map(parameter);
  Config config;
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
2022
  auto get_row_fun = RowFunctionFromCSR<int>(indptr, indptr_type, indices, data, data_type, nindptr, nelem);
2023
  ref_booster->SetSingleRowPredictor(start_iteration, num_iteration, predict_type, config);
2024
  ref_booster->PredictSingleRow(predict_type, static_cast<int32_t>(num_col), get_row_fun, config, out_result, out_len);
2025
2026
2027
  API_END();
}

2028
int LGBM_BoosterPredictForCSRSingleRowFastInit(BoosterHandle handle,
2029
                                               const int predict_type,
2030
                                               const int start_iteration,
2031
                                               const int num_iteration,
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
                                               const int data_type,
                                               const int64_t num_col,
                                               const char* parameter,
                                               FastConfigHandle *out_fastConfig) {
  API_BEGIN();
  if (num_col <= 0) {
    Log::Fatal("The number of columns should be greater than zero.");
  } else if (num_col >= INT32_MAX) {
    Log::Fatal("The number of columns should be smaller than INT32_MAX.");
  }

  auto fastConfig_ptr = std::unique_ptr<FastConfig>(new FastConfig(
    reinterpret_cast<Booster*>(handle),
    parameter,
2046
    predict_type,
2047
2048
2049
2050
2051
2052
2053
    data_type,
    static_cast<int32_t>(num_col)));

  if (fastConfig_ptr->config.num_threads > 0) {
    omp_set_num_threads(fastConfig_ptr->config.num_threads);
  }

2054
  fastConfig_ptr->booster->SetSingleRowPredictor(start_iteration, num_iteration, predict_type, fastConfig_ptr->config);
2055

2056
2057
2058
2059
2060
2061
  *out_fastConfig = fastConfig_ptr.release();
  API_END();
}

int LGBM_BoosterPredictForCSRSingleRowFast(FastConfigHandle fastConfig_handle,
                                           const void* indptr,
2062
                                           const int indptr_type,
2063
2064
                                           const int32_t* indices,
                                           const void* data,
2065
2066
                                           const int64_t nindptr,
                                           const int64_t nelem,
2067
2068
2069
2070
2071
                                           int64_t* out_len,
                                           double* out_result) {
  API_BEGIN();
  FastConfig *fastConfig = reinterpret_cast<FastConfig*>(fastConfig_handle);
  auto get_row_fun = RowFunctionFromCSR<int>(indptr, indptr_type, indices, data, fastConfig->data_type, nindptr, nelem);
2072
  fastConfig->booster->PredictSingleRow(fastConfig->predict_type, fastConfig->ncol,
2073
2074
2075
2076
                                        get_row_fun, fastConfig->config, out_result, out_len);
  API_END();
}

2077

Guolin Ke's avatar
Guolin Ke committed
2078
int LGBM_BoosterPredictForCSC(BoosterHandle handle,
2079
2080
2081
2082
2083
2084
2085
2086
2087
                              const void* col_ptr,
                              int col_ptr_type,
                              const int32_t* indices,
                              const void* data,
                              int data_type,
                              int64_t ncol_ptr,
                              int64_t nelem,
                              int64_t num_row,
                              int predict_type,
2088
                              int start_iteration,
2089
                              int num_iteration,
2090
                              const char* parameter,
2091
2092
                              int64_t* out_len,
                              double* out_result) {
Guolin Ke's avatar
Guolin Ke committed
2093
2094
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
Guolin Ke's avatar
Guolin Ke committed
2095
2096
  auto param = Config::Str2Map(parameter);
  Config config;
Guolin Ke's avatar
Guolin Ke committed
2097
2098
2099
2100
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
2101
  int num_threads = OMP_NUM_THREADS();
Guolin Ke's avatar
Guolin Ke committed
2102
  int ncol = static_cast<int>(ncol_ptr - 1);
Guolin Ke's avatar
Guolin Ke committed
2103
2104
2105
2106
2107
  std::vector<std::vector<CSC_RowIterator>> iterators(num_threads, std::vector<CSC_RowIterator>());
  for (int i = 0; i < num_threads; ++i) {
    for (int j = 0; j < ncol; ++j) {
      iterators[i].emplace_back(col_ptr, col_ptr_type, indices, data, data_type, ncol_ptr, nelem, j);
    }
Guolin Ke's avatar
Guolin Ke committed
2108
2109
  }
  std::function<std::vector<std::pair<int, double>>(int row_idx)> get_row_fun =
Guolin Ke's avatar
Guolin Ke committed
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
      [&iterators, ncol](int i) {
        std::vector<std::pair<int, double>> one_row;
        one_row.reserve(ncol);
        const int tid = omp_get_thread_num();
        for (int j = 0; j < ncol; ++j) {
          auto val = iterators[tid][j].Get(i);
          if (std::fabs(val) > kZeroThreshold || std::isnan(val)) {
            one_row.emplace_back(j, val);
          }
        }
        return one_row;
      };
2122
  ref_booster->Predict(start_iteration, num_iteration, predict_type, static_cast<int>(num_row), ncol, get_row_fun, config,
cbecker's avatar
cbecker committed
2123
                       out_result, out_len);
Guolin Ke's avatar
Guolin Ke committed
2124
2125
2126
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
2127
int LGBM_BoosterPredictForMat(BoosterHandle handle,
2128
2129
2130
2131
2132
2133
                              const void* data,
                              int data_type,
                              int32_t nrow,
                              int32_t ncol,
                              int is_row_major,
                              int predict_type,
2134
                              int start_iteration,
2135
                              int num_iteration,
2136
                              const char* parameter,
2137
2138
                              int64_t* out_len,
                              double* out_result) {
2139
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
2140
2141
  auto param = Config::Str2Map(parameter);
  Config config;
Guolin Ke's avatar
Guolin Ke committed
2142
2143
2144
2145
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
Guolin Ke's avatar
Guolin Ke committed
2146
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
2147
  auto get_row_fun = RowPairFunctionFromDenseMatric(data, nrow, ncol, data_type, is_row_major);
2148
  ref_booster->Predict(start_iteration, num_iteration, predict_type, nrow, ncol, get_row_fun,
Guolin Ke's avatar
Guolin Ke committed
2149
                       config, out_result, out_len);
2150
  API_END();
Guolin Ke's avatar
Guolin Ke committed
2151
}
2152

2153
int LGBM_BoosterPredictForMatSingleRow(BoosterHandle handle,
2154
2155
2156
2157
2158
                                       const void* data,
                                       int data_type,
                                       int32_t ncol,
                                       int is_row_major,
                                       int predict_type,
2159
                                       int start_iteration,
2160
2161
2162
2163
                                       int num_iteration,
                                       const char* parameter,
                                       int64_t* out_len,
                                       double* out_result) {
2164
2165
2166
2167
2168
2169
2170
2171
2172
  API_BEGIN();
  auto param = Config::Str2Map(parameter);
  Config config;
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  auto get_row_fun = RowPairFunctionFromDenseMatric(data, 1, ncol, data_type, is_row_major);
2173
  ref_booster->SetSingleRowPredictor(start_iteration, num_iteration, predict_type, config);
2174
  ref_booster->PredictSingleRow(predict_type, ncol, get_row_fun, config, out_result, out_len);
2175
2176
2177
  API_END();
}

2178
int LGBM_BoosterPredictForMatSingleRowFastInit(BoosterHandle handle,
2179
                                               const int predict_type,
2180
                                               const int start_iteration,
2181
                                               const int num_iteration,
2182
2183
2184
2185
2186
2187
2188
2189
                                               const int data_type,
                                               const int32_t ncol,
                                               const char* parameter,
                                               FastConfigHandle *out_fastConfig) {
  API_BEGIN();
  auto fastConfig_ptr = std::unique_ptr<FastConfig>(new FastConfig(
    reinterpret_cast<Booster*>(handle),
    parameter,
2190
    predict_type,
2191
2192
2193
2194
2195
2196
2197
    data_type,
    ncol));

  if (fastConfig_ptr->config.num_threads > 0) {
    omp_set_num_threads(fastConfig_ptr->config.num_threads);
  }

2198
  fastConfig_ptr->booster->SetSingleRowPredictor(start_iteration, num_iteration, predict_type, fastConfig_ptr->config);
2199

2200
2201
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
  *out_fastConfig = fastConfig_ptr.release();
  API_END();
}

int LGBM_BoosterPredictForMatSingleRowFast(FastConfigHandle fastConfig_handle,
                                           const void* data,
                                           int64_t* out_len,
                                           double* out_result) {
  API_BEGIN();
  FastConfig *fastConfig = reinterpret_cast<FastConfig*>(fastConfig_handle);
  // Single row in row-major format:
  auto get_row_fun = RowPairFunctionFromDenseMatric(data, 1, fastConfig->ncol, fastConfig->data_type, 1);
2212
  fastConfig->booster->PredictSingleRow(fastConfig->predict_type, fastConfig->ncol,
2213
2214
2215
2216
2217
                                        get_row_fun, fastConfig->config,
                                        out_result, out_len);
  API_END();
}

2218

2219
2220
2221
2222
2223
2224
int LGBM_BoosterPredictForMats(BoosterHandle handle,
                               const void** data,
                               int data_type,
                               int32_t nrow,
                               int32_t ncol,
                               int predict_type,
2225
                               int start_iteration,
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
2238
                               int num_iteration,
                               const char* parameter,
                               int64_t* out_len,
                               double* out_result) {
  API_BEGIN();
  auto param = Config::Str2Map(parameter);
  Config config;
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  auto get_row_fun = RowPairFunctionFromDenseRows(data, ncol, data_type);
2239
  ref_booster->Predict(start_iteration, num_iteration, predict_type, nrow, ncol, get_row_fun, config, out_result, out_len);
2240
2241
2242
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
2243
int LGBM_BoosterSaveModel(BoosterHandle handle,
2244
                          int start_iteration,
2245
                          int num_iteration,
2246
                          int feature_importance_type,
2247
                          const char* filename) {
2248
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
2249
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
2250
2251
  ref_booster->SaveModelToFile(start_iteration, num_iteration,
                               feature_importance_type, filename);
wxchan's avatar
wxchan committed
2252
2253
2254
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
2255
int LGBM_BoosterSaveModelToString(BoosterHandle handle,
2256
                                  int start_iteration,
2257
                                  int num_iteration,
2258
                                  int feature_importance_type,
2259
                                  int64_t buffer_len,
2260
                                  int64_t* out_len,
2261
                                  char* out_str) {
2262
2263
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
2264
2265
  std::string model = ref_booster->SaveModelToString(
      start_iteration, num_iteration, feature_importance_type);
2266
  *out_len = static_cast<int64_t>(model.size()) + 1;
2267
  if (*out_len <= buffer_len) {
Guolin Ke's avatar
Guolin Ke committed
2268
    std::memcpy(out_str, model.c_str(), *out_len);
2269
2270
2271
2272
  }
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
2273
int LGBM_BoosterDumpModel(BoosterHandle handle,
2274
                          int start_iteration,
2275
                          int num_iteration,
2276
                          int feature_importance_type,
2277
2278
                          int64_t buffer_len,
                          int64_t* out_len,
2279
                          char* out_str) {
wxchan's avatar
wxchan committed
2280
2281
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
2282
2283
  std::string model = ref_booster->DumpModel(start_iteration, num_iteration,
                                             feature_importance_type);
2284
  *out_len = static_cast<int64_t>(model.size()) + 1;
wxchan's avatar
wxchan committed
2285
  if (*out_len <= buffer_len) {
Guolin Ke's avatar
Guolin Ke committed
2286
    std::memcpy(out_str, model.c_str(), *out_len);
wxchan's avatar
wxchan committed
2287
  }
2288
  API_END();
Guolin Ke's avatar
Guolin Ke committed
2289
}
2290

Guolin Ke's avatar
Guolin Ke committed
2291
int LGBM_BoosterGetLeafValue(BoosterHandle handle,
2292
2293
2294
                             int tree_idx,
                             int leaf_idx,
                             double* out_val) {
Guolin Ke's avatar
Guolin Ke committed
2295
2296
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
Guolin Ke's avatar
Guolin Ke committed
2297
  *out_val = static_cast<double>(ref_booster->GetLeafValue(tree_idx, leaf_idx));
Guolin Ke's avatar
Guolin Ke committed
2298
2299
2300
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
2301
int LGBM_BoosterSetLeafValue(BoosterHandle handle,
2302
2303
2304
                             int tree_idx,
                             int leaf_idx,
                             double val) {
Guolin Ke's avatar
Guolin Ke committed
2305
2306
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
Guolin Ke's avatar
Guolin Ke committed
2307
  ref_booster->SetLeafValue(tree_idx, leaf_idx, val);
Guolin Ke's avatar
Guolin Ke committed
2308
2309
2310
  API_END();
}

2311
2312
2313
2314
2315
2316
2317
2318
2319
2320
2321
2322
2323
int LGBM_BoosterFeatureImportance(BoosterHandle handle,
                                  int num_iteration,
                                  int importance_type,
                                  double* out_results) {
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  std::vector<double> feature_importances = ref_booster->FeatureImportance(num_iteration, importance_type);
  for (size_t i = 0; i < feature_importances.size(); ++i) {
    (out_results)[i] = feature_importances[i];
  }
  API_END();
}

2324
2325
2326
2327
2328
2329
2330
2331
2332
2333
2334
2335
2336
2337
2338
2339
2340
2341
int LGBM_BoosterGetUpperBoundValue(BoosterHandle handle,
                                   double* out_results) {
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  double max_value = ref_booster->UpperBoundValue();
  *out_results = max_value;
  API_END();
}

int LGBM_BoosterGetLowerBoundValue(BoosterHandle handle,
                                   double* out_results) {
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  double min_value = ref_booster->LowerBoundValue();
  *out_results = min_value;
  API_END();
}

2342
2343
2344
2345
2346
int LGBM_NetworkInit(const char* machines,
                     int local_listen_port,
                     int listen_time_out,
                     int num_machines) {
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
2347
  Config config;
2348
  config.machines = RemoveQuotationSymbol(std::string(machines));
2349
2350
2351
2352
2353
2354
2355
2356
2357
2358
2359
2360
2361
2362
2363
  config.local_listen_port = local_listen_port;
  config.num_machines = num_machines;
  config.time_out = listen_time_out;
  if (num_machines > 1) {
    Network::Init(config);
  }
  API_END();
}

int LGBM_NetworkFree() {
  API_BEGIN();
  Network::Dispose();
  API_END();
}

2364
2365
2366
int LGBM_NetworkInitWithFunctions(int num_machines, int rank,
                                  void* reduce_scatter_ext_fun,
                                  void* allgather_ext_fun) {
ww's avatar
ww committed
2367
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
2368
  if (num_machines > 1) {
2369
    Network::Init(num_machines, rank, (ReduceScatterFunction)reduce_scatter_ext_fun, (AllgatherFunction)allgather_ext_fun);
ww's avatar
ww committed
2370
2371
2372
  }
  API_END();
}
Guolin Ke's avatar
Guolin Ke committed
2373

Guolin Ke's avatar
Guolin Ke committed
2374
// ---- start of some help functions
2375

2376
2377
2378
2379
2380
2381
2382
2383
2384
2385
2386
2387
2388
2389
2390
2391
2392
2393
2394
2395
2396
2397
2398
2399
2400

template<typename T>
std::function<std::vector<double>(int row_idx)>
RowFunctionFromDenseMatric_helper(const void* data, int num_row, int num_col, int is_row_major) {
  const T* data_ptr = reinterpret_cast<const T*>(data);
  if (is_row_major) {
    return [=] (int row_idx) {
      std::vector<double> ret(num_col);
      auto tmp_ptr = data_ptr + static_cast<size_t>(num_col) * row_idx;
      for (int i = 0; i < num_col; ++i) {
        ret[i] = static_cast<double>(*(tmp_ptr + i));
      }
      return ret;
    };
  } else {
    return [=] (int row_idx) {
      std::vector<double> ret(num_col);
      for (int i = 0; i < num_col; ++i) {
        ret[i] = static_cast<double>(*(data_ptr + static_cast<size_t>(num_row) * i + row_idx));
      }
      return ret;
    };
  }
}

2401
2402
std::function<std::vector<double>(int row_idx)>
RowFunctionFromDenseMatric(const void* data, int num_row, int num_col, int data_type, int is_row_major) {
Guolin Ke's avatar
Guolin Ke committed
2403
  if (data_type == C_API_DTYPE_FLOAT32) {
2404
    return RowFunctionFromDenseMatric_helper<float>(data, num_row, num_col, is_row_major);
Guolin Ke's avatar
Guolin Ke committed
2405
  } else if (data_type == C_API_DTYPE_FLOAT64) {
2406
    return RowFunctionFromDenseMatric_helper<double>(data, num_row, num_col, is_row_major);
2407
  }
2408
  Log::Fatal("Unknown data type in RowFunctionFromDenseMatric");
2409
  return nullptr;
2410
2411
2412
2413
}

std::function<std::vector<std::pair<int, double>>(int row_idx)>
RowPairFunctionFromDenseMatric(const void* data, int num_row, int num_col, int data_type, int is_row_major) {
Guolin Ke's avatar
Guolin Ke committed
2414
2415
  auto inner_function = RowFunctionFromDenseMatric(data, num_row, num_col, data_type, is_row_major);
  if (inner_function != nullptr) {
2416
    return [inner_function] (int row_idx) {
Guolin Ke's avatar
Guolin Ke committed
2417
2418
      auto raw_values = inner_function(row_idx);
      std::vector<std::pair<int, double>> ret;
Guolin Ke's avatar
Guolin Ke committed
2419
      ret.reserve(raw_values.size());
Guolin Ke's avatar
Guolin Ke committed
2420
      for (int i = 0; i < static_cast<int>(raw_values.size()); ++i) {
Guolin Ke's avatar
Guolin Ke committed
2421
        if (std::fabs(raw_values[i]) > kZeroThreshold || std::isnan(raw_values[i])) {
Guolin Ke's avatar
Guolin Ke committed
2422
          ret.emplace_back(i, raw_values[i]);
2423
        }
Guolin Ke's avatar
Guolin Ke committed
2424
2425
2426
      }
      return ret;
    };
2427
  }
Guolin Ke's avatar
Guolin Ke committed
2428
  return nullptr;
2429
2430
}

2431
2432
2433
2434
2435
2436
2437
// data is array of pointers to individual rows
std::function<std::vector<std::pair<int, double>>(int row_idx)>
RowPairFunctionFromDenseRows(const void** data, int num_col, int data_type) {
  return [=](int row_idx) {
    auto inner_function = RowFunctionFromDenseMatric(data[row_idx], 1, num_col, data_type, /* is_row_major */ true);
    auto raw_values = inner_function(0);
    std::vector<std::pair<int, double>> ret;
Guolin Ke's avatar
Guolin Ke committed
2438
    ret.reserve(raw_values.size());
2439
2440
2441
2442
2443
2444
2445
2446
2447
    for (int i = 0; i < static_cast<int>(raw_values.size()); ++i) {
      if (std::fabs(raw_values[i]) > kZeroThreshold || std::isnan(raw_values[i])) {
        ret.emplace_back(i, raw_values[i]);
      }
    }
    return ret;
  };
}

2448
2449
2450
2451
2452
2453
2454
2455
2456
2457
2458
2459
2460
2461
2462
2463
2464
2465
2466
template<typename T, typename T1, typename T2>
std::function<std::vector<std::pair<int, double>>(T idx)>
RowFunctionFromCSR_helper(const void* indptr, const int32_t* indices, const void* data) {
  const T1* data_ptr = reinterpret_cast<const T1*>(data);
  const T2* ptr_indptr = reinterpret_cast<const T2*>(indptr);
  return [=] (T idx) {
    std::vector<std::pair<int, double>> ret;
    int64_t start = ptr_indptr[idx];
    int64_t end = ptr_indptr[idx + 1];
    if (end - start > 0)  {
      ret.reserve(end - start);
    }
    for (int64_t i = start; i < end; ++i) {
      ret.emplace_back(indices[i], data_ptr[i]);
    }
    return ret;
  };
}

2467
2468
template<typename T>
std::function<std::vector<std::pair<int, double>>(T idx)>
2469
RowFunctionFromCSR(const void* indptr, int indptr_type, const int32_t* indices, const void* data, int data_type, int64_t , int64_t ) {
Guolin Ke's avatar
Guolin Ke committed
2470
2471
  if (data_type == C_API_DTYPE_FLOAT32) {
    if (indptr_type == C_API_DTYPE_INT32) {
2472
     return RowFunctionFromCSR_helper<T, float, int32_t>(indptr, indices, data);
Guolin Ke's avatar
Guolin Ke committed
2473
    } else if (indptr_type == C_API_DTYPE_INT64) {
2474
     return RowFunctionFromCSR_helper<T, float, int64_t>(indptr, indices, data);
2475
    }
Guolin Ke's avatar
Guolin Ke committed
2476
2477
  } else if (data_type == C_API_DTYPE_FLOAT64) {
    if (indptr_type == C_API_DTYPE_INT32) {
2478
     return RowFunctionFromCSR_helper<T, double, int32_t>(indptr, indices, data);
Guolin Ke's avatar
Guolin Ke committed
2479
    } else if (indptr_type == C_API_DTYPE_INT64) {
2480
     return RowFunctionFromCSR_helper<T, double, int64_t>(indptr, indices, data);
Guolin Ke's avatar
Guolin Ke committed
2481
2482
    }
  }
2483
  Log::Fatal("Unknown data type in RowFunctionFromCSR");
2484
  return nullptr;
2485
2486
}

2487
2488
2489
2490
2491
2492
2493
2494
2495
2496
2497
2498
2499
2500
2501
2502
2503
2504
2505


template <typename T1, typename T2>
std::function<std::pair<int, double>(int idx)> IterateFunctionFromCSC_helper(const void* col_ptr, const int32_t* indices, const void* data, int col_idx) {
  const T1* data_ptr = reinterpret_cast<const T1*>(data);
  const T2* ptr_col_ptr = reinterpret_cast<const T2*>(col_ptr);
  int64_t start = ptr_col_ptr[col_idx];
  int64_t end = ptr_col_ptr[col_idx + 1];
  return [=] (int offset) {
    int64_t i = static_cast<int64_t>(start + offset);
    if (i >= end) {
      return std::make_pair(-1, 0.0);
    }
    int idx = static_cast<int>(indices[i]);
    double val = static_cast<double>(data_ptr[i]);
    return std::make_pair(idx, val);
  };
}

Guolin Ke's avatar
Guolin Ke committed
2506
std::function<std::pair<int, double>(int idx)>
2507
IterateFunctionFromCSC(const void* col_ptr, int col_ptr_type, const int32_t* indices, const void* data, int data_type, int64_t ncol_ptr, int64_t , int col_idx) {
Guolin Ke's avatar
Guolin Ke committed
2508
  CHECK(col_idx < ncol_ptr && col_idx >= 0);
Guolin Ke's avatar
Guolin Ke committed
2509
2510
  if (data_type == C_API_DTYPE_FLOAT32) {
    if (col_ptr_type == C_API_DTYPE_INT32) {
2511
      return IterateFunctionFromCSC_helper<float, int32_t>(col_ptr, indices, data, col_idx);
Guolin Ke's avatar
Guolin Ke committed
2512
    } else if (col_ptr_type == C_API_DTYPE_INT64) {
2513
      return IterateFunctionFromCSC_helper<float, int64_t>(col_ptr, indices, data, col_idx);
Guolin Ke's avatar
Guolin Ke committed
2514
    }
Guolin Ke's avatar
Guolin Ke committed
2515
2516
  } else if (data_type == C_API_DTYPE_FLOAT64) {
    if (col_ptr_type == C_API_DTYPE_INT32) {
2517
      return IterateFunctionFromCSC_helper<double, int32_t>(col_ptr, indices, data, col_idx);
Guolin Ke's avatar
Guolin Ke committed
2518
    } else if (col_ptr_type == C_API_DTYPE_INT64) {
2519
      return IterateFunctionFromCSC_helper<double, int64_t>(col_ptr, indices, data, col_idx);
Guolin Ke's avatar
Guolin Ke committed
2520
2521
    }
  }
2522
  Log::Fatal("Unknown data type in CSC matrix");
2523
  return nullptr;
2524
2525
}

Guolin Ke's avatar
Guolin Ke committed
2526
CSC_RowIterator::CSC_RowIterator(const void* col_ptr, int col_ptr_type, const int32_t* indices,
2527
                                 const void* data, int data_type, int64_t ncol_ptr, int64_t nelem, int col_idx) {
Guolin Ke's avatar
Guolin Ke committed
2528
2529
2530
2531
2532
2533
2534
2535
2536
  iter_fun_ = IterateFunctionFromCSC(col_ptr, col_ptr_type, indices, data, data_type, ncol_ptr, nelem, col_idx);
}

double CSC_RowIterator::Get(int idx) {
  while (idx > cur_idx_ && !is_end_) {
    auto ret = iter_fun_(nonzero_idx_);
    if (ret.first < 0) {
      is_end_ = true;
      break;
2537
    }
Guolin Ke's avatar
Guolin Ke committed
2538
2539
2540
2541
2542
2543
2544
2545
2546
2547
2548
2549
2550
2551
2552
2553
2554
    cur_idx_ = ret.first;
    cur_val_ = ret.second;
    ++nonzero_idx_;
  }
  if (idx == cur_idx_) {
    return cur_val_;
  } else {
    return 0.0f;
  }
}

std::pair<int, double> CSC_RowIterator::NextNonZero() {
  if (!is_end_) {
    auto ret = iter_fun_(nonzero_idx_);
    ++nonzero_idx_;
    if (ret.first < 0) {
      is_end_ = true;
2555
    }
Guolin Ke's avatar
Guolin Ke committed
2556
2557
2558
    return ret;
  } else {
    return std::make_pair(-1, 0.0);
2559
  }
Guolin Ke's avatar
Guolin Ke committed
2560
}