"...git@developer.sourcefind.cn:tianlh/lightgbm-dcu.git" did not exist on "8d9c0ce9c1754962f368d774d806d613224e78ae"
c_api.cpp 110 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

7
#include <LightGBM/arrow.h>
Guolin Ke's avatar
Guolin Ke committed
8
9
#include <LightGBM/boosting.h>
#include <LightGBM/config.h>
10
11
12
#include <LightGBM/dataset.h>
#include <LightGBM/dataset_loader.h>
#include <LightGBM/metric.h>
13
#include <LightGBM/network.h>
14
15
#include <LightGBM/objective_function.h>
#include <LightGBM/prediction_early_stop.h>
16
#include <LightGBM/utils/byte_buffer.h>
17
18
19
20
21
#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
22

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

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

Guolin Ke's avatar
Guolin Ke committed
35
36
namespace LightGBM {

Guolin Ke's avatar
Guolin Ke committed
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
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;

53
54
55
56
57
58
#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);

59
60
61
62
63
64
65
66
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;

67
  SingleRowPredictor(int predict_type, Boosting* boosting, const Config& config, int start_iter, int num_iter) {
68
69
70
71
72
73
74
75
76
77
78
79
80
    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;
81
82
    iter_ = num_iter;
    predictor_.reset(new Predictor(boosting, start_iter, iter_, is_raw_score, is_predict_leaf, predict_contrib,
83
                                   early_stop_, early_stop_freq_, early_stop_margin_));
84
    num_pred_in_one_row = boosting->NumPredictOneRow(start_iter, iter_, is_predict_leaf, predict_contrib);
85
    predict_function = predictor_->GetPredictFunction();
Guolin Ke's avatar
Guolin Ke committed
86
    num_total_model_ = boosting->NumberOfTotalModel();
87
  }
88

89
  ~SingleRowPredictor() {}
90

Guolin Ke's avatar
Guolin Ke committed
91
  bool IsPredictorEqual(const Config& config, int iter, Boosting* boosting) {
92
93
94
95
96
    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();
97
  }
Guolin Ke's avatar
Guolin Ke committed
98

99
100
101
102
103
104
105
106
107
 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
108
class Booster {
Nikita Titov's avatar
Nikita Titov committed
109
 public:
Guolin Ke's avatar
Guolin Ke committed
110
  explicit Booster(const char* filename) {
111
    boosting_.reset(Boosting::CreateBoosting("gbdt", filename));
112
113
  }

Guolin Ke's avatar
Guolin Ke committed
114
  Booster(const Dataset* train_data,
115
          const char* parameters) {
Guolin Ke's avatar
Guolin Ke committed
116
    auto param = Config::Str2Map(parameters);
wxchan's avatar
wxchan committed
117
    config_.Set(param);
118
    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
    if (objective_fun_ == nullptr) {
154
      Log::Info("Using self-defined objective function");
Guolin Ke's avatar
Guolin Ke committed
155
156
157
158
159
160
161
162
    }
    // 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
    OMP_SET_NUM_THREADS(config_.num_threads);
Guolin Ke's avatar
Guolin Ke committed
318
319
320

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

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

  void AddValidData(const Dataset* valid_data) {
338
    UNIQUE_LOCK(mutex_)
wxchan's avatar
wxchan committed
339
    valid_metrics_.emplace_back();
Guolin Ke's avatar
Guolin Ke committed
340
341
    for (auto metric_type : config_.metric) {
      auto metric = std::unique_ptr<Metric>(Metric::CreateMetric(metric_type, config_));
wxchan's avatar
wxchan committed
342
343
344
345
346
347
      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,
348
                               Common::ConstPtrInVectorWrapper<Metric>(valid_metrics_.back()));
wxchan's avatar
wxchan committed
349
  }
Guolin Ke's avatar
Guolin Ke committed
350

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

Guolin Ke's avatar
Guolin Ke committed
356
  void Refit(const int32_t* leaf_preds, int32_t nrow, int32_t ncol) {
357
    UNIQUE_LOCK(mutex_)
Guolin Ke's avatar
Guolin Ke committed
358
359
360
    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) {
361
        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
362
363
364
365
366
      }
    }
    boosting_->RefitTree(v_leaf_preds);
  }

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

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

377
  void SetSingleRowPredictor(int start_iteration, int num_iteration, int predict_type, const Config& config) {
378
379
380
381
      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(),
382
                                                                         config, start_iteration, num_iteration));
383
384
385
386
      }
  }

  void PredictSingleRow(int predict_type, int ncol,
387
388
               std::function<std::vector<std::pair<int, double>>(int row_idx)> get_row_fun,
               const Config& config,
389
               double* out_result, int64_t* out_len) const {
390
391
392
    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);
393
    }
394
    UNIQUE_LOCK(mutex_)
395
    const auto& single_row_predictor = single_row_predictor_[predict_type];
396
397
    auto one_row = get_row_fun(0);
    auto pred_wrt_ptr = out_result;
398
    single_row_predictor->predict_function(one_row, pred_wrt_ptr);
399

400
    *out_len = single_row_predictor->num_pred_in_one_row;
401
402
  }

403
  Predictor CreatePredictor(int start_iteration, int num_iteration, int predict_type, int ncol, const Config& config) const {
404
405
406
    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);
407
    }
Guolin Ke's avatar
Guolin Ke committed
408
409
    bool is_predict_leaf = false;
    bool is_raw_score = false;
Guolin Ke's avatar
Guolin Ke committed
410
    bool predict_contrib = false;
Guolin Ke's avatar
Guolin Ke committed
411
    if (predict_type == C_API_PREDICT_LEAF_INDEX) {
Guolin Ke's avatar
Guolin Ke committed
412
      is_predict_leaf = true;
Guolin Ke's avatar
Guolin Ke committed
413
    } else if (predict_type == C_API_PREDICT_RAW_SCORE) {
Guolin Ke's avatar
Guolin Ke committed
414
      is_raw_score = true;
415
    } else if (predict_type == C_API_PREDICT_CONTRIB) {
Guolin Ke's avatar
Guolin Ke committed
416
      predict_contrib = true;
Guolin Ke's avatar
Guolin Ke committed
417
418
    } else {
      is_raw_score = false;
Guolin Ke's avatar
Guolin Ke committed
419
    }
Guolin Ke's avatar
Guolin Ke committed
420

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

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

453
  void PredictSparse(int start_iteration, int num_iteration, int predict_type, int64_t nrow, int ncol,
454
455
456
457
                     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,
458
                     bool* is_data_float32_ptr, int num_matrices) const {
459
    auto predictor = CreatePredictor(start_iteration, num_iteration, predict_type, ncol, config);
460
461
462
    auto pred_sparse_fun = predictor.GetPredictSparseFunction();
    std::vector<std::vector<std::unordered_map<int, double>>>& agg = *agg_ptr;
    OMP_INIT_EX();
463
    #pragma omp parallel for num_threads(OMP_NUM_THREADS()) schedule(static)
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
    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];
  }

495
  void PredictSparseCSR(int start_iteration, int num_iteration, int predict_type, int64_t nrow, int ncol,
496
497
498
                        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,
499
500
                        int32_t** out_indices, void** out_data, int data_type) const {
    SHARED_LOCK(mutex_);
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
    // 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;
518
    PredictSparse(start_iteration, num_iteration, predict_type, nrow, ncol, get_row_fun, config, &elements_size, &agg,
519
520
521
                  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);
522
    std::vector<int64_t> matrix_offsets(num_matrices);
523
524
525
526
527
528
529
530
531
532
533
534
535
536
    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++;
      }
537
538
539
540
541
542
      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]);
      }
543
544
545
546
547
548
549
550
551
552
553
554
    }
    // 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();
555
      #pragma omp parallel for num_threads(OMP_NUM_THREADS()) schedule(static)
556
557
558
559
      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;
560
        int64_t element_index = row_matrix_offsets[row_start_index] + matrix_offsets[m];
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
        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;
  }

586
  void PredictSparseCSC(int start_iteration, int num_iteration, int predict_type, int64_t nrow, int ncol,
587
588
589
                        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,
590
591
                        int32_t** out_indices, void** out_data, int data_type) const {
    SHARED_LOCK(mutex_);
592
593
    // Get the number of trees per iteration (for multiclass scenario we output multiple sparse matrices)
    int num_matrices = boosting_->NumModelPerIteration();
594
    auto predictor = CreatePredictor(start_iteration, num_iteration, predict_type, ncol, config);
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
    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;
612
    PredictSparse(start_iteration, num_iteration, predict_type, nrow, ncol, get_row_fun, config, &elements_size, &agg,
613
614
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
                  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;
      }
660
661
      if (m + 1 < num_matrices) {
        matrix_start_indices[m + 1] = matrix_start_indices[m] + last_column_start_index + last_column_size;
662
      }
663
      col_ptr_index++;
664
    }
665
666
    // Note: we parallelize across matrices instead of rows because of the column_counts[m][col_idx] increment inside the loop
    OMP_INIT_EX();
667
    #pragma omp parallel for num_threads(OMP_NUM_THREADS()) schedule(static)
668
    for (int m = 0; m < num_matrices; ++m) {
669
      OMP_LOOP_EX_BEGIN();
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
      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;
          }
        }
      }
688
      OMP_LOOP_EX_END();
689
    }
690
    OMP_THROW_EX();
691
692
693
694
    out_len[0] = elements_size;
    out_len[1] = col_ptr_size;
  }

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

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

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

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

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

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

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

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

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

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

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

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

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

781
  int GetEvalNames(char** out_strs, const int len, const size_t buffer_len, size_t *out_buffer_len) const {
782
    SHARED_LOCK(mutex_)
783
    *out_buffer_len = 0;
wxchan's avatar
wxchan committed
784
785
786
    int idx = 0;
    for (const auto& metric : train_metric_) {
      for (const auto& name : metric->GetName()) {
787
788
789
790
791
        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
792
793
794
795
796
797
        ++idx;
      }
    }
    return idx;
  }

798
  int GetFeatureNames(char** out_strs, const int len, const size_t buffer_len, size_t *out_buffer_len) const {
799
    SHARED_LOCK(mutex_)
800
    *out_buffer_len = 0;
wxchan's avatar
wxchan committed
801
802
    int idx = 0;
    for (const auto& name : boosting_->FeatureNames()) {
803
804
805
806
807
      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
808
809
810
811
812
      ++idx;
    }
    return idx;
  }

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

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

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

832
}  // namespace LightGBM
Guolin Ke's avatar
Guolin Ke committed
833

834
835
// explicitly declare symbols from LightGBM namespace
using LightGBM::AllgatherFunction;
836
using LightGBM::ArrowTable;
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
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
852

Guolin Ke's avatar
Guolin Ke committed
853
854
855
856
857
858
859
860
// 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);

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

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

// Row iterator of on column for CSC matrix
class CSC_RowIterator {
Nikita Titov's avatar
Nikita Titov committed
871
 public:
Guolin Ke's avatar
Guolin Ke committed
872
  CSC_RowIterator(const void* col_ptr, int col_ptr_type, const int32_t* indices,
873
                  const void* data, int data_type, int64_t ncol_ptr, int64_t nelem, int col_idx);
Guolin Ke's avatar
Guolin Ke committed
874
875
876
877
878
  ~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
879
880

 private:
Guolin Ke's avatar
Guolin Ke committed
881
882
883
884
885
886
887
888
889
  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
890
const char* LGBM_GetLastError() {
wxchan's avatar
wxchan committed
891
  return LastErrorMsg();
Guolin Ke's avatar
Guolin Ke committed
892
893
}

894
895
896
897
898
899
900
901
902
903
904
905
int LGBM_DumpParamAliases(int64_t buffer_len,
                          int64_t* out_len,
                          char* out_str) {
  API_BEGIN();
  std::string aliases = Config::DumpAliases();
  *out_len = static_cast<int64_t>(aliases.size()) + 1;
  if (*out_len <= buffer_len) {
    std::memcpy(out_str, aliases.c_str(), *out_len);
  }
  API_END();
}

906
907
908
909
910
911
int LGBM_RegisterLogCallback(void (*callback)(const char*)) {
  API_BEGIN();
  Log::ResetCallBack(callback);
  API_END();
}

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
946
947
948
949
950
951
952
953
954
955
956
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();
}

957
958
959
960
961
962
963
964
965
966
967
968
969
int LGBM_ByteBufferGetAt(ByteBufferHandle handle, int32_t index, uint8_t* out_val) {
  API_BEGIN();
  LightGBM::ByteBuffer* byteBuffer = reinterpret_cast<LightGBM::ByteBuffer*>(handle);
  *out_val = byteBuffer->GetAt(index);
  API_END();
}

int LGBM_ByteBufferFree(ByteBufferHandle handle) {
  API_BEGIN();
  delete reinterpret_cast<LightGBM::ByteBuffer*>(handle);
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
970
int LGBM_DatasetCreateFromFile(const char* filename,
971
972
973
                               const char* parameters,
                               const DatasetHandle reference,
                               DatasetHandle* out) {
974
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
975
976
  auto param = Config::Str2Map(parameters);
  Config config;
977
  config.Set(param);
978
  OMP_SET_NUM_THREADS(config.num_threads);
979
  DatasetLoader loader(config, nullptr, 1, filename);
Guolin Ke's avatar
Guolin Ke committed
980
  if (reference == nullptr) {
981
    if (Network::num_machines() == 1) {
982
      *out = loader.LoadFromFile(filename);
983
    } else {
984
      *out = loader.LoadFromFile(filename, Network::rank(), Network::num_machines());
985
    }
Guolin Ke's avatar
Guolin Ke committed
986
  } else {
987
    *out = loader.LoadFromFileAlignWithOtherDataset(filename,
988
                                                    reinterpret_cast<const Dataset*>(reference));
Guolin Ke's avatar
Guolin Ke committed
989
  }
990
  API_END();
Guolin Ke's avatar
Guolin Ke committed
991
992
}

Guolin Ke's avatar
Guolin Ke committed
993
int LGBM_DatasetCreateFromSampledColumn(double** sample_data,
994
995
996
997
                                        int** sample_indices,
                                        int32_t ncol,
                                        const int* num_per_col,
                                        int32_t num_sample_row,
998
999
                                        int32_t num_local_row,
                                        int64_t num_dist_row,
1000
1001
                                        const char* parameters,
                                        DatasetHandle* out) {
1002
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1003
1004
  auto param = Config::Str2Map(parameters);
  Config config;
1005
  config.Set(param);
1006
  OMP_SET_NUM_THREADS(config.num_threads);
Guolin Ke's avatar
Guolin Ke committed
1007
  DatasetLoader loader(config, nullptr, 1, nullptr);
1008
1009
1010
1011
  *out = loader.ConstructFromSampleData(sample_data,
                                        sample_indices,
                                        ncol,
                                        num_per_col,
1012
                                        num_sample_row,
1013
1014
                                        static_cast<data_size_t>(num_local_row),
                                        num_dist_row);
1015
  API_END();
Guolin Ke's avatar
Guolin Ke committed
1016
1017
}

Guolin Ke's avatar
Guolin Ke committed
1018
int LGBM_DatasetCreateByReference(const DatasetHandle reference,
1019
1020
                                  int64_t num_total_row,
                                  DatasetHandle* out) {
Guolin Ke's avatar
Guolin Ke committed
1021
1022
  API_BEGIN();
  std::unique_ptr<Dataset> ret;
1023
1024
1025
1026
1027
  data_size_t nrows = static_cast<data_size_t>(num_total_row);
  ret.reset(new Dataset(nrows));
  const Dataset* reference_dataset = reinterpret_cast<const Dataset*>(reference);
  ret->CreateValid(reference_dataset);
  ret->InitByReference(nrows, reference_dataset);
Guolin Ke's avatar
Guolin Ke committed
1028
1029
1030
1031
  *out = ret.release();
  API_END();
}

1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
int LGBM_DatasetCreateFromSerializedReference(const void* ref_buffer,
                                              int32_t ref_buffer_size,
                                              int64_t num_row,
                                              int32_t num_classes,
                                              const char* parameters,
                                              DatasetHandle* out) {
  API_BEGIN();
  auto param = Config::Str2Map(parameters);
  Config config;
  config.Set(param);
  OMP_SET_NUM_THREADS(config.num_threads);
  DatasetLoader loader(config, nullptr, 1, nullptr);
  *out = loader.LoadFromSerializedReference(static_cast<const char*>(ref_buffer),
    static_cast<size_t>(ref_buffer_size),
    static_cast<data_size_t>(num_row),
    num_classes);
  API_END();
}

1051
1052
1053
1054
1055
int LGBM_DatasetInitStreaming(DatasetHandle dataset,
                              int32_t has_weights,
                              int32_t has_init_scores,
                              int32_t has_queries,
                              int32_t nclasses,
1056
1057
                              int32_t nthreads,
                              int32_t omp_max_threads) {
1058
1059
1060
  API_BEGIN();
  auto p_dataset = reinterpret_cast<Dataset*>(dataset);
  auto num_data = p_dataset->num_data();
1061
  p_dataset->InitStreaming(num_data, has_weights, has_init_scores, has_queries, nclasses, nthreads, omp_max_threads);
1062
1063
1064
1065
  p_dataset->set_wait_for_manual_finish(true);
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1066
int LGBM_DatasetPushRows(DatasetHandle dataset,
1067
1068
1069
1070
1071
                         const void* data,
                         int data_type,
                         int32_t nrow,
                         int32_t ncol,
                         int32_t start_row) {
Guolin Ke's avatar
Guolin Ke committed
1072
1073
1074
  API_BEGIN();
  auto p_dataset = reinterpret_cast<Dataset*>(dataset);
  auto get_row_fun = RowFunctionFromDenseMatric(data, nrow, ncol, data_type, 1);
1075
1076
1077
  if (p_dataset->has_raw()) {
    p_dataset->ResizeRaw(p_dataset->num_numeric_features() + nrow);
  }
1078
  OMP_INIT_EX();
1079
  #pragma omp parallel for num_threads(OMP_NUM_THREADS()) schedule(static)
Guolin Ke's avatar
Guolin Ke committed
1080
  for (int i = 0; i < nrow; ++i) {
1081
    OMP_LOOP_EX_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1082
1083
1084
    const int tid = omp_get_thread_num();
    auto one_row = get_row_fun(i);
    p_dataset->PushOneRow(tid, start_row + i, one_row);
1085
    OMP_LOOP_EX_END();
Guolin Ke's avatar
Guolin Ke committed
1086
  }
1087
  OMP_THROW_EX();
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
  if (!p_dataset->wait_for_manual_finish() && (start_row + nrow == p_dataset->num_data())) {
    p_dataset->FinishLoad();
  }
  API_END();
}

int LGBM_DatasetPushRowsWithMetadata(DatasetHandle dataset,
                                     const void* data,
                                     int data_type,
                                     int32_t nrow,
                                     int32_t ncol,
                                     int32_t start_row,
                                     const float* labels,
                                     const float* weights,
                                     const double* init_scores,
                                     const int32_t* queries,
                                     int32_t tid) {
  API_BEGIN();
#ifdef LABEL_T_USE_DOUBLE
  Log::Fatal("Don't support LABEL_T_USE_DOUBLE");
#endif
  if (!data) {
    Log::Fatal("data cannot be null.");
  }
  auto p_dataset = reinterpret_cast<Dataset*>(dataset);
  auto get_row_fun = RowFunctionFromDenseMatric(data, nrow, ncol, data_type, 1);
  if (p_dataset->has_raw()) {
    p_dataset->ResizeRaw(p_dataset->num_numeric_features() + nrow);
  }

1118
1119
  const int max_omp_threads = p_dataset->omp_max_threads() > 0 ? p_dataset->omp_max_threads() : OMP_NUM_THREADS();

1120
  OMP_INIT_EX();
1121
#pragma omp parallel for num_threads(OMP_NUM_THREADS()) schedule(static)
1122
1123
1124
  for (int i = 0; i < nrow; ++i) {
    OMP_LOOP_EX_BEGIN();
    // convert internal thread id to be unique based on external thread id
1125
    const int internal_tid = omp_get_thread_num() + (max_omp_threads * tid);
1126
1127
1128
1129
1130
1131
1132
1133
1134
    auto one_row = get_row_fun(i);
    p_dataset->PushOneRow(internal_tid, start_row + i, one_row);
    OMP_LOOP_EX_END();
  }
  OMP_THROW_EX();

  p_dataset->InsertMetadataAt(start_row, nrow, labels, weights, init_scores, queries);

  if (!p_dataset->wait_for_manual_finish() && (start_row + nrow == p_dataset->num_data())) {
Guolin Ke's avatar
Guolin Ke committed
1135
1136
1137
1138
1139
    p_dataset->FinishLoad();
  }
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1140
int LGBM_DatasetPushRowsByCSR(DatasetHandle dataset,
1141
1142
1143
1144
1145
1146
1147
1148
1149
                              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
1150
1151
  API_BEGIN();
  auto p_dataset = reinterpret_cast<Dataset*>(dataset);
1152
  auto get_row_fun = RowFunctionFromCSR<int>(indptr, indptr_type, indices, data, data_type, nindptr, nelem);
Guolin Ke's avatar
Guolin Ke committed
1153
  int32_t nrow = static_cast<int32_t>(nindptr - 1);
1154
1155
1156
  if (p_dataset->has_raw()) {
    p_dataset->ResizeRaw(p_dataset->num_numeric_features() + nrow);
  }
1157
  OMP_INIT_EX();
1158
  #pragma omp parallel for num_threads(OMP_NUM_THREADS()) schedule(static)
Guolin Ke's avatar
Guolin Ke committed
1159
  for (int i = 0; i < nrow; ++i) {
1160
    OMP_LOOP_EX_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1161
1162
    const int tid = omp_get_thread_num();
    auto one_row = get_row_fun(i);
1163
    p_dataset->PushOneRow(tid, static_cast<data_size_t>(start_row + i), one_row);
1164
    OMP_LOOP_EX_END();
Guolin Ke's avatar
Guolin Ke committed
1165
  }
1166
  OMP_THROW_EX();
1167
  if (!p_dataset->wait_for_manual_finish() && (start_row + nrow == static_cast<int64_t>(p_dataset->num_data()))) {
Guolin Ke's avatar
Guolin Ke committed
1168
1169
    p_dataset->FinishLoad();
  }
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
  API_END();
}

int LGBM_DatasetPushRowsByCSRWithMetadata(DatasetHandle dataset,
                                          const void* indptr,
                                          int indptr_type,
                                          const int32_t* indices,
                                          const void* data,
                                          int data_type,
                                          int64_t nindptr,
                                          int64_t nelem,
                                          int64_t start_row,
                                          const float* labels,
                                          const float* weights,
                                          const double* init_scores,
                                          const int32_t* queries,
                                          int32_t tid) {
  API_BEGIN();
#ifdef LABEL_T_USE_DOUBLE
  Log::Fatal("Don't support LABEL_T_USE_DOUBLE");
#endif
  if (!data) {
    Log::Fatal("data cannot be null.");
  }
  auto p_dataset = reinterpret_cast<Dataset*>(dataset);
  auto get_row_fun = RowFunctionFromCSR<int>(indptr, indptr_type, indices, data, data_type, nindptr, nelem);
  int32_t nrow = static_cast<int32_t>(nindptr - 1);
  if (p_dataset->has_raw()) {
    p_dataset->ResizeRaw(p_dataset->num_numeric_features() + nrow);
  }
1200
1201
1202

  const int max_omp_threads = p_dataset->omp_max_threads() > 0 ? p_dataset->omp_max_threads() : OMP_NUM_THREADS();

1203
  OMP_INIT_EX();
1204
#pragma omp parallel for num_threads(OMP_NUM_THREADS()) schedule(static)
1205
1206
1207
  for (int i = 0; i < nrow; ++i) {
    OMP_LOOP_EX_BEGIN();
    // convert internal thread id to be unique based on external thread id
1208
    const int internal_tid = omp_get_thread_num() + (max_omp_threads * tid);
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
    auto one_row = get_row_fun(i);
    p_dataset->PushOneRow(internal_tid, static_cast<data_size_t>(start_row + i), one_row);
    OMP_LOOP_EX_END();
  }
  OMP_THROW_EX();

  p_dataset->InsertMetadataAt(static_cast<int32_t>(start_row), nrow, labels, weights, init_scores, queries);

  if (!p_dataset->wait_for_manual_finish() && (start_row + nrow == static_cast<int64_t>(p_dataset->num_data()))) {
    p_dataset->FinishLoad();
  }
  API_END();
}

int LGBM_DatasetSetWaitForManualFinish(DatasetHandle dataset, int wait) {
  API_BEGIN();
  auto p_dataset = reinterpret_cast<Dataset*>(dataset);
  p_dataset->set_wait_for_manual_finish(wait);
  API_END();
}

int LGBM_DatasetMarkFinished(DatasetHandle dataset) {
  API_BEGIN();
  auto p_dataset = reinterpret_cast<Dataset*>(dataset);
  p_dataset->FinishLoad();
Guolin Ke's avatar
Guolin Ke committed
1234
1235
1236
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1237
int LGBM_DatasetCreateFromMat(const void* data,
1238
1239
1240
1241
1242
1243
1244
                              int data_type,
                              int32_t nrow,
                              int32_t ncol,
                              int is_row_major,
                              const char* parameters,
                              const DatasetHandle reference,
                              DatasetHandle* out) {
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
  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) {
1265
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1266
1267
  auto param = Config::Str2Map(parameters);
  Config config;
1268
  config.Set(param);
1269
  OMP_SET_NUM_THREADS(config.num_threads);
Guolin Ke's avatar
Guolin Ke committed
1270
  std::unique_ptr<Dataset> ret;
1271
1272
1273
1274
1275
1276
1277
1278
1279
  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));
  }
1280

Guolin Ke's avatar
Guolin Ke committed
1281
1282
  if (reference == nullptr) {
    // sample data first
1283
1284
    auto sample_indices = CreateSampleIndices(total_nrow, config);
    int sample_cnt = static_cast<int>(sample_indices.size());
1285
    std::vector<std::vector<double>> sample_values(ncol);
Guolin Ke's avatar
Guolin Ke committed
1286
    std::vector<std::vector<int>> sample_idx(ncol);
1287
1288
1289

    int offset = 0;
    int j = 0;
Guolin Ke's avatar
Guolin Ke committed
1290
    for (size_t i = 0; i < sample_indices.size(); ++i) {
Guolin Ke's avatar
Guolin Ke committed
1291
      auto idx = sample_indices[i];
1292
1293
1294
1295
      while ((idx - offset) >= nrow[j]) {
        offset += nrow[j];
        ++j;
      }
1296

1297
1298
1299
1300
1301
      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
1302
        }
Guolin Ke's avatar
Guolin Ke committed
1303
1304
      }
    }
Guolin Ke's avatar
Guolin Ke committed
1305
    DatasetLoader loader(config, nullptr, 1, nullptr);
1306
1307
1308
1309
    ret.reset(loader.ConstructFromSampleData(Vector2Ptr<double>(&sample_values).data(),
                                             Vector2Ptr<int>(&sample_idx).data(),
                                             ncol,
                                             VectorSize<double>(sample_values).data(),
1310
1311
1312
                                             sample_cnt,
                                             total_nrow,
                                             total_nrow));
Guolin Ke's avatar
Guolin Ke committed
1313
  } else {
1314
    ret.reset(new Dataset(total_nrow));
Guolin Ke's avatar
Guolin Ke committed
1315
    ret->CreateValid(
1316
      reinterpret_cast<const Dataset*>(reference));
1317
1318
1319
    if (ret->has_raw()) {
      ret->ResizeRaw(total_nrow);
    }
Guolin Ke's avatar
Guolin Ke committed
1320
  }
1321
1322
1323
  int32_t start_row = 0;
  for (int j = 0; j < nmat; ++j) {
    OMP_INIT_EX();
1324
    #pragma omp parallel for num_threads(OMP_NUM_THREADS()) schedule(static)
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
    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
1335
1336
  }
  ret->FinishLoad();
Guolin Ke's avatar
Guolin Ke committed
1337
  *out = ret.release();
1338
  API_END();
1339
1340
}

Guolin Ke's avatar
Guolin Ke committed
1341
int LGBM_DatasetCreateFromCSR(const void* indptr,
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
                              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) {
1352
  API_BEGIN();
1353
1354
1355
1356
1357
  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
1358
1359
  auto param = Config::Str2Map(parameters);
  Config config;
1360
  config.Set(param);
1361
  OMP_SET_NUM_THREADS(config.num_threads);
Guolin Ke's avatar
Guolin Ke committed
1362
  std::unique_ptr<Dataset> ret;
1363
  auto get_row_fun = RowFunctionFromCSR<int>(indptr, indptr_type, indices, data, data_type, nindptr, nelem);
1364
1365
1366
  int32_t nrow = static_cast<int32_t>(nindptr - 1);
  if (reference == nullptr) {
    // sample data first
1367
1368
    auto sample_indices = CreateSampleIndices(nrow, config);
    int sample_cnt = static_cast<int>(sample_indices.size());
Guolin Ke's avatar
Guolin Ke committed
1369
1370
    std::vector<std::vector<double>> sample_values(num_col);
    std::vector<std::vector<int>> sample_idx(num_col);
1371
1372
1373
1374
    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
1375
        CHECK_LT(inner_data.first, num_col);
Guolin Ke's avatar
Guolin Ke committed
1376
        if (std::fabs(inner_data.second) > kZeroThreshold || std::isnan(inner_data.second)) {
Guolin Ke's avatar
Guolin Ke committed
1377
1378
          sample_values[inner_data.first].emplace_back(inner_data.second);
          sample_idx[inner_data.first].emplace_back(static_cast<int>(i));
1379
1380
1381
        }
      }
    }
Guolin Ke's avatar
Guolin Ke committed
1382
    DatasetLoader loader(config, nullptr, 1, nullptr);
1383
1384
1385
1386
    ret.reset(loader.ConstructFromSampleData(Vector2Ptr<double>(&sample_values).data(),
                                             Vector2Ptr<int>(&sample_idx).data(),
                                             static_cast<int>(num_col),
                                             VectorSize<double>(sample_values).data(),
1387
1388
1389
                                             sample_cnt,
                                             nrow,
                                             nrow));
1390
  } else {
1391
    ret.reset(new Dataset(nrow));
Guolin Ke's avatar
Guolin Ke committed
1392
    ret->CreateValid(
1393
      reinterpret_cast<const Dataset*>(reference));
1394
1395
1396
    if (ret->has_raw()) {
      ret->ResizeRaw(nrow);
    }
1397
  }
1398
  OMP_INIT_EX();
1399
  #pragma omp parallel for num_threads(OMP_NUM_THREADS()) schedule(static)
1400
  for (int i = 0; i < nindptr - 1; ++i) {
1401
    OMP_LOOP_EX_BEGIN();
1402
1403
1404
    const int tid = omp_get_thread_num();
    auto one_row = get_row_fun(i);
    ret->PushOneRow(tid, i, one_row);
1405
    OMP_LOOP_EX_END();
1406
  }
1407
  OMP_THROW_EX();
1408
  ret->FinishLoad();
Guolin Ke's avatar
Guolin Ke committed
1409
  *out = ret.release();
1410
  API_END();
1411
1412
}

1413
int LGBM_DatasetCreateFromCSRFunc(void* get_row_funptr,
1414
1415
1416
1417
1418
                                  int num_rows,
                                  int64_t num_col,
                                  const char* parameters,
                                  const DatasetHandle reference,
                                  DatasetHandle* out) {
1419
  API_BEGIN();
1420
1421
1422
1423
1424
  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.");
  }
1425
1426
1427
1428
  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);
1429
  OMP_SET_NUM_THREADS(config.num_threads);
1430
1431
1432
1433
  std::unique_ptr<Dataset> ret;
  int32_t nrow = num_rows;
  if (reference == nullptr) {
    // sample data first
1434
1435
    auto sample_indices = CreateSampleIndices(nrow, config);
    int sample_cnt = static_cast<int>(sample_indices.size());
1436
1437
1438
1439
1440
1441
1442
1443
    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
1444
        CHECK_LT(inner_data.first, num_col);
1445
1446
1447
1448
1449
1450
1451
        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);
1452
1453
1454
1455
    ret.reset(loader.ConstructFromSampleData(Vector2Ptr<double>(&sample_values).data(),
                                             Vector2Ptr<int>(&sample_idx).data(),
                                             static_cast<int>(num_col),
                                             VectorSize<double>(sample_values).data(),
1456
1457
1458
                                             sample_cnt,
                                             nrow,
                                             nrow));
1459
1460
1461
1462
  } else {
    ret.reset(new Dataset(nrow));
    ret->CreateValid(
      reinterpret_cast<const Dataset*>(reference));
1463
1464
1465
    if (ret->has_raw()) {
      ret->ResizeRaw(nrow);
    }
1466
  }
1467

1468
  OMP_INIT_EX();
Guolin Ke's avatar
Guolin Ke committed
1469
  std::vector<std::pair<int, double>> thread_buffer;
1470
  #pragma omp parallel for num_threads(OMP_NUM_THREADS()) schedule(static) private(thread_buffer)
1471
1472
1473
  for (int i = 0; i < num_rows; ++i) {
    OMP_LOOP_EX_BEGIN();
    {
1474
      const int tid = omp_get_thread_num();
Guolin Ke's avatar
Guolin Ke committed
1475
1476
      get_row_fun(i, thread_buffer);
      ret->PushOneRow(tid, i, thread_buffer);
1477
1478
1479
1480
1481
1482
1483
1484
1485
    }
    OMP_LOOP_EX_END();
  }
  OMP_THROW_EX();
  ret->FinishLoad();
  *out = ret.release();
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1486
int LGBM_DatasetCreateFromCSC(const void* col_ptr,
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
                              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) {
1497
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1498
1499
  auto param = Config::Str2Map(parameters);
  Config config;
1500
  config.Set(param);
1501
  OMP_SET_NUM_THREADS(config.num_threads);
Guolin Ke's avatar
Guolin Ke committed
1502
  std::unique_ptr<Dataset> ret;
Guolin Ke's avatar
Guolin Ke committed
1503
1504
1505
  int32_t nrow = static_cast<int32_t>(num_row);
  if (reference == nullptr) {
    // sample data first
1506
1507
    auto sample_indices = CreateSampleIndices(nrow, config);
    int sample_cnt = static_cast<int>(sample_indices.size());
Guolin Ke's avatar
Guolin Ke committed
1508
    std::vector<std::vector<double>> sample_values(ncol_ptr - 1);
Guolin Ke's avatar
Guolin Ke committed
1509
    std::vector<std::vector<int>> sample_idx(ncol_ptr - 1);
1510
    OMP_INIT_EX();
1511
    #pragma omp parallel for num_threads(OMP_NUM_THREADS()) schedule(static)
Guolin Ke's avatar
Guolin Ke committed
1512
    for (int i = 0; i < static_cast<int>(sample_values.size()); ++i) {
1513
      OMP_LOOP_EX_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1514
1515
1516
      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
1517
        if (std::fabs(val) > kZeroThreshold || std::isnan(val)) {
Guolin Ke's avatar
Guolin Ke committed
1518
1519
          sample_values[i].emplace_back(val);
          sample_idx[i].emplace_back(j);
Guolin Ke's avatar
Guolin Ke committed
1520
1521
        }
      }
1522
      OMP_LOOP_EX_END();
Guolin Ke's avatar
Guolin Ke committed
1523
    }
1524
    OMP_THROW_EX();
Guolin Ke's avatar
Guolin Ke committed
1525
    DatasetLoader loader(config, nullptr, 1, nullptr);
1526
1527
1528
1529
    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(),
1530
1531
1532
                                             sample_cnt,
                                             nrow,
                                             nrow));
Guolin Ke's avatar
Guolin Ke committed
1533
  } else {
1534
    ret.reset(new Dataset(nrow));
Guolin Ke's avatar
Guolin Ke committed
1535
    ret->CreateValid(
1536
      reinterpret_cast<const Dataset*>(reference));
Guolin Ke's avatar
Guolin Ke committed
1537
  }
1538
  OMP_INIT_EX();
1539
  #pragma omp parallel for num_threads(OMP_NUM_THREADS()) schedule(static)
Guolin Ke's avatar
Guolin Ke committed
1540
  for (int i = 0; i < ncol_ptr - 1; ++i) {
1541
    OMP_LOOP_EX_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1542
    const int tid = omp_get_thread_num();
Guolin Ke's avatar
Guolin Ke committed
1543
    int feature_idx = ret->InnerFeatureIndex(i);
Guolin Ke's avatar
Guolin Ke committed
1544
    if (feature_idx < 0) { continue; }
Guolin Ke's avatar
Guolin Ke committed
1545
1546
    int group = ret->Feature2Group(feature_idx);
    int sub_feature = ret->Feture2SubFeature(feature_idx);
Guolin Ke's avatar
Guolin Ke committed
1547
    CSC_RowIterator col_it(col_ptr, col_ptr_type, indices, data, data_type, ncol_ptr, nelem, i);
Guolin Ke's avatar
Guolin Ke committed
1548
1549
1550
1551
1552
1553
1554
1555
    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; }
1556
        ret->PushOneData(tid, row_idx, group, feature_idx, sub_feature, pair.second);
Guolin Ke's avatar
Guolin Ke committed
1557
1558
1559
1560
      }
    } else {
      for (int row_idx = 0; row_idx < nrow; ++row_idx) {
        auto val = col_it.Get(row_idx);
1561
        ret->PushOneData(tid, row_idx, group, feature_idx, sub_feature, val);
Guolin Ke's avatar
Guolin Ke committed
1562
      }
Guolin Ke's avatar
Guolin Ke committed
1563
    }
1564
    OMP_LOOP_EX_END();
Guolin Ke's avatar
Guolin Ke committed
1565
  }
1566
  OMP_THROW_EX();
Guolin Ke's avatar
Guolin Ke committed
1567
  ret->FinishLoad();
Guolin Ke's avatar
Guolin Ke committed
1568
  *out = ret.release();
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
  API_END();
}

int LGBM_DatasetCreateFromArrow(int64_t n_chunks,
                                const ArrowArray* chunks,
                                const ArrowSchema* schema,
                                const char* parameters,
                                const DatasetHandle reference,
                                DatasetHandle *out) {
  API_BEGIN();

  auto param = Config::Str2Map(parameters);
  Config config;
  config.Set(param);
  OMP_SET_NUM_THREADS(config.num_threads);

  std::unique_ptr<Dataset> ret;

  // Prepare the Arrow data
  ArrowTable table(n_chunks, chunks, schema);

  // Initialize the dataset
  if (reference == nullptr) {
    // If there is no reference dataset, we first sample indices
    auto sample_indices = CreateSampleIndices(static_cast<int32_t>(table.get_num_rows()), config);
    auto sample_count = static_cast<int>(sample_indices.size());
    std::vector<std::vector<double>> sample_values(table.get_num_columns());
    std::vector<std::vector<int>> sample_idx(table.get_num_columns());

    // Then, we obtain sample values by parallelizing across columns
    OMP_INIT_EX();
    #pragma omp parallel for num_threads(OMP_NUM_THREADS()) schedule(static)
    for (int64_t j = 0; j < table.get_num_columns(); ++j) {
      OMP_LOOP_EX_BEGIN();

      // Values need to be copied from the record batches.
      sample_values[j].reserve(sample_indices.size());
      sample_idx[j].reserve(sample_indices.size());

      // The chunks are iterated over in the inner loop as columns can be treated independently.
      int last_idx = 0;
      int i = 0;
      auto it = table.get_column(j).begin<double>();
      for (auto idx : sample_indices) {
        std::advance(it, idx - last_idx);
        auto v = *it;
        if (std::fabs(v) > kZeroThreshold || std::isnan(v)) {
          sample_values[j].emplace_back(v);
          sample_idx[j].emplace_back(i);
        }
        last_idx = idx;
        i++;
      }
      OMP_LOOP_EX_END();
    }
    OMP_THROW_EX();

    // Finally, we initialize a loader from the sampled values
    DatasetLoader loader(config, nullptr, 1, nullptr);
    ret.reset(loader.ConstructFromSampleData(Vector2Ptr<double>(&sample_values).data(),
                                             Vector2Ptr<int>(&sample_idx).data(),
                                             table.get_num_columns(),
                                             VectorSize<double>(sample_values).data(),
                                             sample_count,
                                             table.get_num_rows(),
                                             table.get_num_rows()));
  } else {
    ret.reset(new Dataset(static_cast<data_size_t>(table.get_num_rows())));
    ret->CreateValid(reinterpret_cast<const Dataset*>(reference));
    if (ret->has_raw()) {
      ret->ResizeRaw(static_cast<int>(table.get_num_rows()));
    }
  }

  // After sampling and properly initializing all bins, we can add our data to the dataset. Here,
  // we parallelize across rows.
  OMP_INIT_EX();
  #pragma omp parallel for num_threads(OMP_NUM_THREADS()) schedule(static)
  for (int64_t j = 0; j < table.get_num_columns(); ++j) {
    OMP_LOOP_EX_BEGIN();
    const int tid = omp_get_thread_num();
    data_size_t idx = 0;
    auto column = table.get_column(j);
    for (auto it = column.begin<double>(), end = column.end<double>(); it != end; ++it) {
      ret->PushOneValue(tid, idx++, j, *it);
    }
    OMP_LOOP_EX_END();
  }
  OMP_THROW_EX();

  ret->FinishLoad();
  *out = ret.release();
1661
  API_END();
Guolin Ke's avatar
Guolin Ke committed
1662
1663
}

Guolin Ke's avatar
Guolin Ke committed
1664
int LGBM_DatasetGetSubset(
1665
  const DatasetHandle handle,
wxchan's avatar
wxchan committed
1666
1667
1668
  const int32_t* used_row_indices,
  int32_t num_used_row_indices,
  const char* parameters,
Guolin Ke's avatar
typo  
Guolin Ke committed
1669
  DatasetHandle* out) {
wxchan's avatar
wxchan committed
1670
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1671
1672
  auto param = Config::Str2Map(parameters);
  Config config;
1673
  config.Set(param);
1674
  OMP_SET_NUM_THREADS(config.num_threads);
1675
  auto full_dataset = reinterpret_cast<const Dataset*>(handle);
1676
  CHECK_GT(num_used_row_indices, 0);
1677
1678
  const int32_t lower = 0;
  const int32_t upper = full_dataset->num_data() - 1;
1679
  CheckElementsIntervalClosed(used_row_indices, lower, upper, num_used_row_indices, "Used indices of subset");
1680
1681
1682
  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
1683
  auto ret = std::unique_ptr<Dataset>(new Dataset(num_used_row_indices));
1684
  ret->CopyFeatureMapperFrom(full_dataset);
1685
  ret->CopySubrow(full_dataset, used_row_indices, num_used_row_indices, true);
wxchan's avatar
wxchan committed
1686
1687
1688
1689
  *out = ret.release();
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1690
int LGBM_DatasetSetFeatureNames(
Guolin Ke's avatar
typo  
Guolin Ke committed
1691
  DatasetHandle handle,
Guolin Ke's avatar
Guolin Ke committed
1692
  const char** feature_names,
Guolin Ke's avatar
Guolin Ke committed
1693
  int num_feature_names) {
Guolin Ke's avatar
Guolin Ke committed
1694
1695
1696
  API_BEGIN();
  auto dataset = reinterpret_cast<Dataset*>(handle);
  std::vector<std::string> feature_names_str;
Guolin Ke's avatar
Guolin Ke committed
1697
  for (int i = 0; i < num_feature_names; ++i) {
Guolin Ke's avatar
Guolin Ke committed
1698
1699
1700
1701
1702
1703
    feature_names_str.emplace_back(feature_names[i]);
  }
  dataset->set_feature_names(feature_names_str);
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1704
int LGBM_DatasetGetFeatureNames(
1705
1706
1707
1708
1709
1710
    DatasetHandle handle,
    const int len,
    int* num_feature_names,
    const size_t buffer_len,
    size_t* out_buffer_len,
    char** feature_names) {
1711
  API_BEGIN();
1712
  *out_buffer_len = 0;
1713
1714
  auto dataset = reinterpret_cast<Dataset*>(handle);
  auto inside_feature_name = dataset->feature_names();
Guolin Ke's avatar
Guolin Ke committed
1715
1716
  *num_feature_names = static_cast<int>(inside_feature_name.size());
  for (int i = 0; i < *num_feature_names; ++i) {
1717
1718
1719
1720
1721
    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);
1722
1723
1724
1725
  }
  API_END();
}

1726
1727
1728
#ifdef _MSC_VER
  #pragma warning(disable : 4702)
#endif
Guolin Ke's avatar
Guolin Ke committed
1729
int LGBM_DatasetFree(DatasetHandle handle) {
1730
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1731
  delete reinterpret_cast<Dataset*>(handle);
1732
  API_END();
1733
1734
}

Guolin Ke's avatar
Guolin Ke committed
1735
int LGBM_DatasetSaveBinary(DatasetHandle handle,
1736
                           const char* filename) {
1737
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1738
1739
  auto dataset = reinterpret_cast<Dataset*>(handle);
  dataset->SaveBinaryFile(filename);
1740
  API_END();
1741
1742
}

1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
int LGBM_DatasetSerializeReferenceToBinary(DatasetHandle handle,
                                           ByteBufferHandle* out,
                                           int32_t* out_len) {
  API_BEGIN();
  auto dataset = reinterpret_cast<Dataset*>(handle);
  std::unique_ptr<LightGBM::ByteBuffer> ret;
  ret.reset(new LightGBM::ByteBuffer());
  dataset->SerializeReference(ret.get());
  *out_len = static_cast<int32_t>(ret->GetSize());
  *out = ret.release();
  API_END();
}

1756
1757
1758
1759
1760
1761
1762
1763
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
1764
int LGBM_DatasetSetField(DatasetHandle handle,
1765
1766
1767
1768
                         const char* field_name,
                         const void* field_data,
                         int num_element,
                         int type) {
1769
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1770
  auto dataset = reinterpret_cast<Dataset*>(handle);
1771
  bool is_success = false;
Guolin Ke's avatar
Guolin Ke committed
1772
  if (type == C_API_DTYPE_FLOAT32) {
Guolin Ke's avatar
Guolin Ke committed
1773
    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
1774
  } else if (type == C_API_DTYPE_INT32) {
Guolin Ke's avatar
Guolin Ke committed
1775
    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
1776
1777
  } 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));
1778
  }
1779
  if (!is_success) { Log::Fatal("Input data type error or field not found"); }
1780
  API_END();
1781
1782
}

Guolin Ke's avatar
Guolin Ke committed
1783
int LGBM_DatasetGetField(DatasetHandle handle,
1784
1785
1786
1787
                         const char* field_name,
                         int* out_len,
                         const void** out_ptr,
                         int* out_type) {
1788
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1789
  auto dataset = reinterpret_cast<Dataset*>(handle);
1790
  bool is_success = false;
Guolin Ke's avatar
Guolin Ke committed
1791
  if (dataset->GetFloatField(field_name, out_len, reinterpret_cast<const float**>(out_ptr))) {
Guolin Ke's avatar
Guolin Ke committed
1792
    *out_type = C_API_DTYPE_FLOAT32;
1793
    is_success = true;
Guolin Ke's avatar
Guolin Ke committed
1794
  } else if (dataset->GetIntField(field_name, out_len, reinterpret_cast<const int**>(out_ptr))) {
Guolin Ke's avatar
Guolin Ke committed
1795
    *out_type = C_API_DTYPE_INT32;
1796
    is_success = true;
Guolin Ke's avatar
Guolin Ke committed
1797
1798
1799
  } 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
1800
  }
1801
  if (!is_success) { Log::Fatal("Field not found"); }
wxchan's avatar
wxchan committed
1802
  if (*out_ptr == nullptr) { *out_len = 0; }
1803
  API_END();
1804
1805
}

1806
int LGBM_DatasetUpdateParamChecking(const char* old_parameters, const char* new_parameters) {
1807
  API_BEGIN();
1808
1809
1810
1811
1812
  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);
1813
1814
1815
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1816
int LGBM_DatasetGetNumData(DatasetHandle handle,
1817
                           int* out) {
1818
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1819
1820
  auto dataset = reinterpret_cast<Dataset*>(handle);
  *out = dataset->num_data();
1821
  API_END();
1822
1823
}

Guolin Ke's avatar
Guolin Ke committed
1824
int LGBM_DatasetGetNumFeature(DatasetHandle handle,
1825
                              int* out) {
1826
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1827
1828
  auto dataset = reinterpret_cast<Dataset*>(handle);
  *out = dataset->num_total_features();
1829
  API_END();
Guolin Ke's avatar
Guolin Ke committed
1830
}
1831

1832
1833
1834
1835
1836
int LGBM_DatasetGetFeatureNumBin(DatasetHandle handle,
                                 int feature,
                                 int* out) {
  API_BEGIN();
  auto dataset = reinterpret_cast<Dataset*>(handle);
1837
1838
1839
1840
1841
  int num_features = dataset->num_total_features();
  if (feature < 0 || feature >= num_features) {
    Log::Fatal("Tried to retrieve number of bins for feature index %d, "
               "but the valid feature indices are [0, %d].", feature, num_features - 1);
  }
1842
1843
1844
1845
1846
1847
1848
1849
1850
  int inner_idx = dataset->InnerFeatureIndex(feature);
  if (inner_idx >= 0) {
    *out = dataset->FeatureNumBin(inner_idx);
  } else {
    *out = 0;
  }
  API_END();
}

1851
1852
1853
1854
1855
int LGBM_DatasetAddFeaturesFrom(DatasetHandle target,
                                DatasetHandle source) {
  API_BEGIN();
  auto target_d = reinterpret_cast<Dataset*>(target);
  auto source_d = reinterpret_cast<Dataset*>(source);
1856
  target_d->AddFeaturesFrom(source_d);
1857
1858
1859
  API_END();
}

1860
1861
// ---- start of booster

Guolin Ke's avatar
Guolin Ke committed
1862
int LGBM_BoosterCreate(const DatasetHandle train_data,
1863
1864
                       const char* parameters,
                       BoosterHandle* out) {
1865
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1866
  const Dataset* p_train_data = reinterpret_cast<const Dataset*>(train_data);
wxchan's avatar
wxchan committed
1867
1868
  auto ret = std::unique_ptr<Booster>(new Booster(p_train_data, parameters));
  *out = ret.release();
1869
  API_END();
1870
1871
}

Guolin Ke's avatar
Guolin Ke committed
1872
int LGBM_BoosterCreateFromModelfile(
1873
  const char* filename,
Guolin Ke's avatar
Guolin Ke committed
1874
  int* out_num_iterations,
1875
  BoosterHandle* out) {
1876
  API_BEGIN();
wxchan's avatar
wxchan committed
1877
  auto ret = std::unique_ptr<Booster>(new Booster(filename));
Guolin Ke's avatar
Guolin Ke committed
1878
  *out_num_iterations = ret->GetBoosting()->GetCurrentIteration();
wxchan's avatar
wxchan committed
1879
  *out = ret.release();
1880
  API_END();
1881
1882
}

Guolin Ke's avatar
Guolin Ke committed
1883
int LGBM_BoosterLoadModelFromString(
1884
1885
1886
1887
  const char* model_str,
  int* out_num_iterations,
  BoosterHandle* out) {
  API_BEGIN();
wxchan's avatar
wxchan committed
1888
  auto ret = std::unique_ptr<Booster>(new Booster(nullptr));
1889
1890
1891
1892
1893
1894
  ret->LoadModelFromString(model_str);
  *out_num_iterations = ret->GetBoosting()->GetCurrentIteration();
  *out = ret.release();
  API_END();
}

1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
int LGBM_BoosterGetLoadedParam(
  BoosterHandle handle,
  int64_t buffer_len,
  int64_t* out_len,
  char* out_str) {
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  std::string params = ref_booster->GetBoosting()->GetLoadedParam();
  *out_len = static_cast<int64_t>(params.size()) + 1;
  if (*out_len <= buffer_len) {
    std::memcpy(out_str, params.c_str(), *out_len);
  }
  API_END();
}

1910
1911
1912
#ifdef _MSC_VER
  #pragma warning(disable : 4702)
#endif
Guolin Ke's avatar
Guolin Ke committed
1913
int LGBM_BoosterFree(BoosterHandle handle) {
1914
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1915
  delete reinterpret_cast<Booster*>(handle);
1916
  API_END();
1917
1918
}

1919
int LGBM_BoosterShuffleModels(BoosterHandle handle, int start_iter, int end_iter) {
1920
1921
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
1922
  ref_booster->ShuffleModels(start_iter, end_iter);
1923
1924
1925
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1926
int LGBM_BoosterMerge(BoosterHandle handle,
1927
                      BoosterHandle other_handle) {
wxchan's avatar
wxchan committed
1928
1929
1930
1931
1932
1933
1934
  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
1935
int LGBM_BoosterAddValidData(BoosterHandle handle,
1936
                             const DatasetHandle valid_data) {
wxchan's avatar
wxchan committed
1937
1938
1939
1940
1941
1942
1943
  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
1944
int LGBM_BoosterResetTrainingData(BoosterHandle handle,
1945
                                  const DatasetHandle train_data) {
wxchan's avatar
wxchan committed
1946
1947
1948
1949
1950
1951
1952
  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
1953
int LGBM_BoosterResetParameter(BoosterHandle handle, const char* parameters) {
wxchan's avatar
wxchan committed
1954
1955
1956
1957
1958
1959
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  ref_booster->ResetConfig(parameters);
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1960
int LGBM_BoosterGetNumClasses(BoosterHandle handle, int* out_len) {
wxchan's avatar
wxchan committed
1961
1962
1963
1964
1965
1966
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  *out_len = ref_booster->GetBoosting()->NumberOfClasses();
  API_END();
}

1967
int LGBM_BoosterGetLinear(BoosterHandle handle, int* out) {
1968
1969
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
1970
1971
1972
1973
1974
  if (ref_booster->GetBoosting()->IsLinear()) {
    *out = 1;
  } else {
    *out = 0;
  }
1975
1976
1977
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1978
1979
1980
1981
1982
1983
1984
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
1985
int LGBM_BoosterUpdateOneIter(BoosterHandle handle, int* is_finished) {
1986
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1987
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
1988
1989
1990
1991
1992
  if (ref_booster->TrainOneIter()) {
    *is_finished = 1;
  } else {
    *is_finished = 0;
  }
1993
  API_END();
1994
1995
}

Guolin Ke's avatar
Guolin Ke committed
1996
int LGBM_BoosterUpdateOneIterCustom(BoosterHandle handle,
1997
1998
1999
                                    const float* grad,
                                    const float* hess,
                                    int* is_finished) {
2000
  API_BEGIN();
2001
  #ifdef SCORE_T_USE_DOUBLE
2002
2003
2004
2005
  (void) handle;       // UNUSED VARIABLE
  (void) grad;         // UNUSED VARIABLE
  (void) hess;         // UNUSED VARIABLE
  (void) is_finished;  // UNUSED VARIABLE
2006
  Log::Fatal("Don't support custom loss function when SCORE_T_USE_DOUBLE is enabled");
2007
  #else
2008
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
2009
2010
2011
2012
2013
  if (ref_booster->TrainOneIter(grad, hess)) {
    *is_finished = 1;
  } else {
    *is_finished = 0;
  }
2014
  #endif
2015
  API_END();
2016
2017
}

Guolin Ke's avatar
Guolin Ke committed
2018
int LGBM_BoosterRollbackOneIter(BoosterHandle handle) {
wxchan's avatar
wxchan committed
2019
2020
2021
2022
2023
2024
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  ref_booster->RollbackOneIter();
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
2025
int LGBM_BoosterGetCurrentIteration(BoosterHandle handle, int* out_iteration) {
wxchan's avatar
wxchan committed
2026
2027
2028
2029
2030
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  *out_iteration = ref_booster->GetBoosting()->GetCurrentIteration();
  API_END();
}
Guolin Ke's avatar
Guolin Ke committed
2031

2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
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
2046
int LGBM_BoosterGetEvalCounts(BoosterHandle handle, int* out_len) {
wxchan's avatar
wxchan committed
2047
2048
2049
2050
2051
2052
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  *out_len = ref_booster->GetEvalCounts();
  API_END();
}

2053
2054
2055
2056
2057
2058
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
2059
2060
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
2061
  *out_len = ref_booster->GetEvalNames(out_strs, len, buffer_len, out_buffer_len);
wxchan's avatar
wxchan committed
2062
2063
2064
  API_END();
}

2065
2066
2067
2068
2069
2070
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
2071
2072
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
2073
  *out_len = ref_booster->GetFeatureNames(out_strs, len, buffer_len, out_buffer_len);
wxchan's avatar
wxchan committed
2074
2075
2076
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
2077
int LGBM_BoosterGetNumFeature(BoosterHandle handle, int* out_len) {
wxchan's avatar
wxchan committed
2078
2079
2080
2081
2082
2083
  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
2084
int LGBM_BoosterGetEval(BoosterHandle handle,
2085
2086
2087
                        int data_idx,
                        int* out_len,
                        double* out_results) {
2088
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
2089
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
2090
  auto boosting = ref_booster->GetBoosting();
wxchan's avatar
wxchan committed
2091
  auto result_buf = boosting->GetEvalAt(data_idx);
Guolin Ke's avatar
Guolin Ke committed
2092
  *out_len = static_cast<int>(result_buf.size());
2093
  for (size_t i = 0; i < result_buf.size(); ++i) {
Guolin Ke's avatar
Guolin Ke committed
2094
    (out_results)[i] = static_cast<double>(result_buf[i]);
2095
  }
2096
  API_END();
2097
2098
}

Guolin Ke's avatar
Guolin Ke committed
2099
int LGBM_BoosterGetNumPredict(BoosterHandle handle,
2100
2101
                              int data_idx,
                              int64_t* out_len) {
Guolin Ke's avatar
Guolin Ke committed
2102
2103
2104
2105
2106
2107
  API_BEGIN();
  auto boosting = reinterpret_cast<Booster*>(handle)->GetBoosting();
  *out_len = boosting->GetNumPredictAt(data_idx);
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
2108
int LGBM_BoosterGetPredict(BoosterHandle handle,
2109
2110
2111
                           int data_idx,
                           int64_t* out_len,
                           double* out_result) {
2112
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
2113
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
2114
  ref_booster->GetPredictAt(data_idx, out_result, out_len);
2115
  API_END();
Guolin Ke's avatar
Guolin Ke committed
2116
2117
}

Guolin Ke's avatar
Guolin Ke committed
2118
int LGBM_BoosterPredictForFile(BoosterHandle handle,
2119
2120
2121
                               const char* data_filename,
                               int data_has_header,
                               int predict_type,
2122
                               int start_iteration,
2123
                               int num_iteration,
2124
                               const char* parameter,
2125
                               const char* result_filename) {
2126
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
2127
2128
  auto param = Config::Str2Map(parameter);
  Config config;
Guolin Ke's avatar
Guolin Ke committed
2129
  config.Set(param);
2130
  OMP_SET_NUM_THREADS(config.num_threads);
Guolin Ke's avatar
Guolin Ke committed
2131
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
2132
  ref_booster->Predict(start_iteration, num_iteration, predict_type, data_filename, data_has_header,
Guolin Ke's avatar
Guolin Ke committed
2133
                       config, result_filename);
2134
  API_END();
2135
2136
}

Guolin Ke's avatar
Guolin Ke committed
2137
int LGBM_BoosterCalcNumPredict(BoosterHandle handle,
2138
2139
                               int num_row,
                               int predict_type,
2140
                               int start_iteration,
2141
2142
                               int num_iteration,
                               int64_t* out_len) {
Guolin Ke's avatar
Guolin Ke committed
2143
2144
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
2145
  *out_len = static_cast<int64_t>(num_row) * ref_booster->GetBoosting()->NumPredictOneRow(start_iteration,
2146
    num_iteration, predict_type == C_API_PREDICT_LEAF_INDEX, predict_type == C_API_PREDICT_CONTRIB);
Guolin Ke's avatar
Guolin Ke committed
2147
2148
2149
  API_END();
}

2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
/*!
 * \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,
2163
             const int predict_type_,
2164
             const int data_type_,
2165
             const int32_t num_cols) : booster(booster_ptr), predict_type(predict_type_), data_type(data_type_), ncol(num_cols) {
2166
2167
2168
2169
2170
    config.Set(Config::Str2Map(parameter));
  }

  Booster* const booster;
  Config config;
2171
  const int predict_type;
2172
2173
2174
2175
2176
2177
2178
2179
2180
2181
  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
2182
int LGBM_BoosterPredictForCSR(BoosterHandle handle,
2183
2184
2185
2186
2187
2188
2189
                              const void* indptr,
                              int indptr_type,
                              const int32_t* indices,
                              const void* data,
                              int data_type,
                              int64_t nindptr,
                              int64_t nelem,
2190
                              int64_t num_col,
2191
                              int predict_type,
2192
                              int start_iteration,
2193
                              int num_iteration,
2194
                              const char* parameter,
2195
2196
                              int64_t* out_len,
                              double* out_result) {
2197
  API_BEGIN();
2198
2199
2200
2201
2202
  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
2203
2204
  auto param = Config::Str2Map(parameter);
  Config config;
Guolin Ke's avatar
Guolin Ke committed
2205
  config.Set(param);
2206
  OMP_SET_NUM_THREADS(config.num_threads);
Guolin Ke's avatar
Guolin Ke committed
2207
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
2208
  auto get_row_fun = RowFunctionFromCSR<int>(indptr, indptr_type, indices, data, data_type, nindptr, nelem);
Guolin Ke's avatar
Guolin Ke committed
2209
  int nrow = static_cast<int>(nindptr - 1);
2210
  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
2211
                       config, out_result, out_len);
2212
  API_END();
Guolin Ke's avatar
Guolin Ke committed
2213
}
2214

2215
2216
2217
2218
2219
2220
2221
2222
2223
2224
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,
2225
                                    int start_iteration,
2226
2227
2228
2229
2230
2231
2232
2233
2234
2235
2236
2237
                                    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);
2238
  OMP_SET_NUM_THREADS(config.num_threads);
2239
2240
2241
2242
2243
2244
2245
2246
  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;
2247
    ref_booster->PredictSparseCSR(start_iteration, num_iteration, predict_type, nrow, static_cast<int>(num_col_or_row), get_row_fun,
2248
2249
2250
2251
2252
2253
2254
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267
2268
2269
2270
                                  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;
    };
2271
    ref_booster->PredictSparseCSC(start_iteration, num_iteration, predict_type, num_col_or_row, ncol, get_row_fun, config,
2272
2273
2274
2275
2276
2277
2278
2279
2280
2281
                                  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) {
2282
    delete[] reinterpret_cast<int32_t*>(indptr);
2283
  } else if (indptr_type == C_API_DTYPE_INT64) {
2284
    delete[] reinterpret_cast<int64_t*>(indptr);
2285
2286
2287
  } else {
    Log::Fatal("Unknown indptr type in LGBM_BoosterFreePredictSparse");
  }
2288
  delete[] indices;
2289
  if (data_type == C_API_DTYPE_FLOAT32) {
2290
    delete[] reinterpret_cast<float*>(data);
2291
  } else if (data_type == C_API_DTYPE_FLOAT64) {
2292
    delete[] reinterpret_cast<double*>(data);
2293
2294
2295
2296
2297
2298
  } else {
    Log::Fatal("Unknown data type in LGBM_BoosterFreePredictSparse");
  }
  API_END();
}

2299
int LGBM_BoosterPredictForCSRSingleRow(BoosterHandle handle,
2300
2301
2302
2303
2304
2305
2306
                                       const void* indptr,
                                       int indptr_type,
                                       const int32_t* indices,
                                       const void* data,
                                       int data_type,
                                       int64_t nindptr,
                                       int64_t nelem,
2307
                                       int64_t num_col,
2308
                                       int predict_type,
2309
                                       int start_iteration,
2310
2311
2312
2313
                                       int num_iteration,
                                       const char* parameter,
                                       int64_t* out_len,
                                       double* out_result) {
2314
  API_BEGIN();
2315
2316
2317
2318
2319
  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.");
  }
2320
2321
2322
  auto param = Config::Str2Map(parameter);
  Config config;
  config.Set(param);
2323
  OMP_SET_NUM_THREADS(config.num_threads);
2324
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
2325
  auto get_row_fun = RowFunctionFromCSR<int>(indptr, indptr_type, indices, data, data_type, nindptr, nelem);
2326
  ref_booster->SetSingleRowPredictor(start_iteration, num_iteration, predict_type, config);
2327
  ref_booster->PredictSingleRow(predict_type, static_cast<int32_t>(num_col), get_row_fun, config, out_result, out_len);
2328
2329
2330
  API_END();
}

2331
int LGBM_BoosterPredictForCSRSingleRowFastInit(BoosterHandle handle,
2332
                                               const int predict_type,
2333
                                               const int start_iteration,
2334
                                               const int num_iteration,
2335
2336
2337
2338
2339
2340
2341
2342
2343
2344
2345
2346
2347
2348
                                               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,
2349
    predict_type,
2350
2351
2352
    data_type,
    static_cast<int32_t>(num_col)));

2353
  OMP_SET_NUM_THREADS(fastConfig_ptr->config.num_threads);
2354

2355
  fastConfig_ptr->booster->SetSingleRowPredictor(start_iteration, num_iteration, predict_type, fastConfig_ptr->config);
2356

2357
2358
2359
2360
2361
2362
  *out_fastConfig = fastConfig_ptr.release();
  API_END();
}

int LGBM_BoosterPredictForCSRSingleRowFast(FastConfigHandle fastConfig_handle,
                                           const void* indptr,
2363
                                           const int indptr_type,
2364
2365
                                           const int32_t* indices,
                                           const void* data,
2366
2367
                                           const int64_t nindptr,
                                           const int64_t nelem,
2368
2369
2370
2371
2372
                                           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);
2373
  fastConfig->booster->PredictSingleRow(fastConfig->predict_type, fastConfig->ncol,
2374
2375
2376
2377
                                        get_row_fun, fastConfig->config, out_result, out_len);
  API_END();
}

2378

Guolin Ke's avatar
Guolin Ke committed
2379
int LGBM_BoosterPredictForCSC(BoosterHandle handle,
2380
2381
2382
2383
2384
2385
2386
2387
2388
                              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,
2389
                              int start_iteration,
2390
                              int num_iteration,
2391
                              const char* parameter,
2392
2393
                              int64_t* out_len,
                              double* out_result) {
Guolin Ke's avatar
Guolin Ke committed
2394
2395
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
Guolin Ke's avatar
Guolin Ke committed
2396
2397
  auto param = Config::Str2Map(parameter);
  Config config;
Guolin Ke's avatar
Guolin Ke committed
2398
  config.Set(param);
2399
  OMP_SET_NUM_THREADS(config.num_threads);
2400
  int num_threads = OMP_NUM_THREADS();
Guolin Ke's avatar
Guolin Ke committed
2401
  int ncol = static_cast<int>(ncol_ptr - 1);
Guolin Ke's avatar
Guolin Ke committed
2402
2403
2404
2405
2406
  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
2407
2408
  }
  std::function<std::vector<std::pair<int, double>>(int row_idx)> get_row_fun =
Guolin Ke's avatar
Guolin Ke committed
2409
2410
2411
2412
2413
2414
2415
2416
2417
2418
2419
2420
      [&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;
      };
2421
  ref_booster->Predict(start_iteration, num_iteration, predict_type, static_cast<int>(num_row), ncol, get_row_fun, config,
cbecker's avatar
cbecker committed
2422
                       out_result, out_len);
Guolin Ke's avatar
Guolin Ke committed
2423
2424
2425
  API_END();
}

2426
2427
2428
2429
2430
2431
2432
2433
2434
2435
2436
2437
2438
2439
2440
2441
2442
2443
2444
2445
2446
int LGBM_BoosterValidateFeatureNames(BoosterHandle handle,
                                     const char** data_names,
                                     int data_num_features) {
  API_BEGIN();
  int booster_num_features;
  size_t out_buffer_len;
  LGBM_BoosterGetFeatureNames(handle, 0, &booster_num_features, 0, &out_buffer_len, nullptr);
  if (booster_num_features != data_num_features) {
    Log::Fatal("Model was trained on %d features, but got %d input features to predict.", booster_num_features, data_num_features);
  }
  std::vector<std::vector<char>> tmp_names(booster_num_features, std::vector<char>(out_buffer_len));
  std::vector<char*> booster_names = Vector2Ptr(&tmp_names);
  LGBM_BoosterGetFeatureNames(handle, data_num_features, &booster_num_features, out_buffer_len, &out_buffer_len, booster_names.data());
  for (int i = 0; i < booster_num_features; ++i) {
    if (strcmp(data_names[i], booster_names[i]) != 0) {
      Log::Fatal("Expected '%s' at position %d but found '%s'", booster_names[i], i, data_names[i]);
    }
  }
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
2447
int LGBM_BoosterPredictForMat(BoosterHandle handle,
2448
2449
2450
2451
2452
2453
                              const void* data,
                              int data_type,
                              int32_t nrow,
                              int32_t ncol,
                              int is_row_major,
                              int predict_type,
2454
                              int start_iteration,
2455
                              int num_iteration,
2456
                              const char* parameter,
2457
2458
                              int64_t* out_len,
                              double* out_result) {
2459
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
2460
2461
  auto param = Config::Str2Map(parameter);
  Config config;
Guolin Ke's avatar
Guolin Ke committed
2462
  config.Set(param);
2463
  OMP_SET_NUM_THREADS(config.num_threads);
Guolin Ke's avatar
Guolin Ke committed
2464
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
2465
  auto get_row_fun = RowPairFunctionFromDenseMatric(data, nrow, ncol, data_type, is_row_major);
2466
  ref_booster->Predict(start_iteration, num_iteration, predict_type, nrow, ncol, get_row_fun,
Guolin Ke's avatar
Guolin Ke committed
2467
                       config, out_result, out_len);
2468
  API_END();
Guolin Ke's avatar
Guolin Ke committed
2469
}
2470

2471
int LGBM_BoosterPredictForMatSingleRow(BoosterHandle handle,
2472
2473
2474
2475
2476
                                       const void* data,
                                       int data_type,
                                       int32_t ncol,
                                       int is_row_major,
                                       int predict_type,
2477
                                       int start_iteration,
2478
2479
2480
2481
                                       int num_iteration,
                                       const char* parameter,
                                       int64_t* out_len,
                                       double* out_result) {
2482
2483
2484
2485
  API_BEGIN();
  auto param = Config::Str2Map(parameter);
  Config config;
  config.Set(param);
2486
  OMP_SET_NUM_THREADS(config.num_threads);
2487
2488
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  auto get_row_fun = RowPairFunctionFromDenseMatric(data, 1, ncol, data_type, is_row_major);
2489
  ref_booster->SetSingleRowPredictor(start_iteration, num_iteration, predict_type, config);
2490
  ref_booster->PredictSingleRow(predict_type, ncol, get_row_fun, config, out_result, out_len);
2491
2492
2493
  API_END();
}

2494
int LGBM_BoosterPredictForMatSingleRowFastInit(BoosterHandle handle,
2495
                                               const int predict_type,
2496
                                               const int start_iteration,
2497
                                               const int num_iteration,
2498
2499
2500
2501
2502
2503
2504
2505
                                               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,
2506
    predict_type,
2507
2508
2509
    data_type,
    ncol));

2510
  OMP_SET_NUM_THREADS(fastConfig_ptr->config.num_threads);
2511

2512
  fastConfig_ptr->booster->SetSingleRowPredictor(start_iteration, num_iteration, predict_type, fastConfig_ptr->config);
2513

2514
2515
2516
2517
2518
2519
2520
2521
2522
2523
2524
2525
  *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);
2526
  fastConfig->booster->PredictSingleRow(fastConfig->predict_type, fastConfig->ncol,
2527
2528
2529
2530
2531
                                        get_row_fun, fastConfig->config,
                                        out_result, out_len);
  API_END();
}

2532

2533
2534
2535
2536
2537
2538
int LGBM_BoosterPredictForMats(BoosterHandle handle,
                               const void** data,
                               int data_type,
                               int32_t nrow,
                               int32_t ncol,
                               int predict_type,
2539
                               int start_iteration,
2540
2541
2542
2543
2544
2545
2546
2547
                               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);
2548
  OMP_SET_NUM_THREADS(config.num_threads);
2549
2550
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  auto get_row_fun = RowPairFunctionFromDenseRows(data, ncol, data_type);
2551
  ref_booster->Predict(start_iteration, num_iteration, predict_type, nrow, ncol, get_row_fun, config, out_result, out_len);
2552
2553
2554
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
2555
int LGBM_BoosterSaveModel(BoosterHandle handle,
2556
                          int start_iteration,
2557
                          int num_iteration,
2558
                          int feature_importance_type,
2559
                          const char* filename) {
2560
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
2561
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
2562
2563
  ref_booster->SaveModelToFile(start_iteration, num_iteration,
                               feature_importance_type, filename);
wxchan's avatar
wxchan committed
2564
2565
2566
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
2567
int LGBM_BoosterSaveModelToString(BoosterHandle handle,
2568
                                  int start_iteration,
2569
                                  int num_iteration,
2570
                                  int feature_importance_type,
2571
                                  int64_t buffer_len,
2572
                                  int64_t* out_len,
2573
                                  char* out_str) {
2574
2575
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
2576
2577
  std::string model = ref_booster->SaveModelToString(
      start_iteration, num_iteration, feature_importance_type);
2578
  *out_len = static_cast<int64_t>(model.size()) + 1;
2579
  if (*out_len <= buffer_len) {
Guolin Ke's avatar
Guolin Ke committed
2580
    std::memcpy(out_str, model.c_str(), *out_len);
2581
2582
2583
2584
  }
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
2585
int LGBM_BoosterDumpModel(BoosterHandle handle,
2586
                          int start_iteration,
2587
                          int num_iteration,
2588
                          int feature_importance_type,
2589
2590
                          int64_t buffer_len,
                          int64_t* out_len,
2591
                          char* out_str) {
wxchan's avatar
wxchan committed
2592
2593
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
2594
2595
  std::string model = ref_booster->DumpModel(start_iteration, num_iteration,
                                             feature_importance_type);
2596
  *out_len = static_cast<int64_t>(model.size()) + 1;
wxchan's avatar
wxchan committed
2597
  if (*out_len <= buffer_len) {
Guolin Ke's avatar
Guolin Ke committed
2598
    std::memcpy(out_str, model.c_str(), *out_len);
wxchan's avatar
wxchan committed
2599
  }
2600
  API_END();
Guolin Ke's avatar
Guolin Ke committed
2601
}
2602

Guolin Ke's avatar
Guolin Ke committed
2603
int LGBM_BoosterGetLeafValue(BoosterHandle handle,
2604
2605
2606
                             int tree_idx,
                             int leaf_idx,
                             double* out_val) {
Guolin Ke's avatar
Guolin Ke committed
2607
2608
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
Guolin Ke's avatar
Guolin Ke committed
2609
  *out_val = static_cast<double>(ref_booster->GetLeafValue(tree_idx, leaf_idx));
Guolin Ke's avatar
Guolin Ke committed
2610
2611
2612
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
2613
int LGBM_BoosterSetLeafValue(BoosterHandle handle,
2614
2615
2616
                             int tree_idx,
                             int leaf_idx,
                             double val) {
Guolin Ke's avatar
Guolin Ke committed
2617
2618
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
Guolin Ke's avatar
Guolin Ke committed
2619
  ref_booster->SetLeafValue(tree_idx, leaf_idx, val);
Guolin Ke's avatar
Guolin Ke committed
2620
2621
2622
  API_END();
}

2623
2624
2625
2626
2627
2628
2629
2630
2631
2632
2633
2634
2635
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();
}

2636
2637
2638
2639
2640
2641
2642
2643
2644
2645
2646
2647
2648
2649
2650
2651
2652
2653
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();
}

2654
2655
2656
2657
2658
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
2659
  Config config;
2660
  config.machines = RemoveQuotationSymbol(std::string(machines));
2661
2662
2663
2664
2665
2666
2667
2668
2669
2670
2671
2672
2673
2674
2675
  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();
}

2676
2677
2678
int LGBM_NetworkInitWithFunctions(int num_machines, int rank,
                                  void* reduce_scatter_ext_fun,
                                  void* allgather_ext_fun) {
ww's avatar
ww committed
2679
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
2680
  if (num_machines > 1) {
2681
    Network::Init(num_machines, rank, (ReduceScatterFunction)reduce_scatter_ext_fun, (AllgatherFunction)allgather_ext_fun);
ww's avatar
ww committed
2682
2683
2684
  }
  API_END();
}
Guolin Ke's avatar
Guolin Ke committed
2685

Guolin Ke's avatar
Guolin Ke committed
2686
// ---- start of some help functions
2687

2688
2689
2690
2691
2692
2693
2694
2695
2696
2697
2698
2699
2700
2701
2702
2703
2704
2705
2706
2707
2708
2709
2710
2711
2712

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;
    };
  }
}

2713
2714
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
2715
  if (data_type == C_API_DTYPE_FLOAT32) {
2716
    return RowFunctionFromDenseMatric_helper<float>(data, num_row, num_col, is_row_major);
Guolin Ke's avatar
Guolin Ke committed
2717
  } else if (data_type == C_API_DTYPE_FLOAT64) {
2718
    return RowFunctionFromDenseMatric_helper<double>(data, num_row, num_col, is_row_major);
2719
  }
2720
  Log::Fatal("Unknown data type in RowFunctionFromDenseMatric");
2721
  return nullptr;
2722
2723
2724
2725
}

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
2726
2727
  auto inner_function = RowFunctionFromDenseMatric(data, num_row, num_col, data_type, is_row_major);
  if (inner_function != nullptr) {
2728
    return [inner_function] (int row_idx) {
Guolin Ke's avatar
Guolin Ke committed
2729
2730
      auto raw_values = inner_function(row_idx);
      std::vector<std::pair<int, double>> ret;
Guolin Ke's avatar
Guolin Ke committed
2731
      ret.reserve(raw_values.size());
Guolin Ke's avatar
Guolin Ke committed
2732
      for (int i = 0; i < static_cast<int>(raw_values.size()); ++i) {
Guolin Ke's avatar
Guolin Ke committed
2733
        if (std::fabs(raw_values[i]) > kZeroThreshold || std::isnan(raw_values[i])) {
Guolin Ke's avatar
Guolin Ke committed
2734
          ret.emplace_back(i, raw_values[i]);
2735
        }
Guolin Ke's avatar
Guolin Ke committed
2736
2737
2738
      }
      return ret;
    };
2739
  }
Guolin Ke's avatar
Guolin Ke committed
2740
  return nullptr;
2741
2742
}

2743
2744
2745
2746
2747
2748
2749
// 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
2750
    ret.reserve(raw_values.size());
2751
2752
2753
2754
2755
2756
2757
2758
2759
    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;
  };
}

2760
2761
2762
2763
2764
2765
2766
2767
2768
2769
2770
2771
2772
2773
2774
2775
2776
2777
2778
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;
  };
}

2779
2780
template<typename T>
std::function<std::vector<std::pair<int, double>>(T idx)>
2781
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
2782
2783
  if (data_type == C_API_DTYPE_FLOAT32) {
    if (indptr_type == C_API_DTYPE_INT32) {
2784
     return RowFunctionFromCSR_helper<T, float, int32_t>(indptr, indices, data);
Guolin Ke's avatar
Guolin Ke committed
2785
    } else if (indptr_type == C_API_DTYPE_INT64) {
2786
     return RowFunctionFromCSR_helper<T, float, int64_t>(indptr, indices, data);
2787
    }
Guolin Ke's avatar
Guolin Ke committed
2788
2789
  } else if (data_type == C_API_DTYPE_FLOAT64) {
    if (indptr_type == C_API_DTYPE_INT32) {
2790
     return RowFunctionFromCSR_helper<T, double, int32_t>(indptr, indices, data);
Guolin Ke's avatar
Guolin Ke committed
2791
    } else if (indptr_type == C_API_DTYPE_INT64) {
2792
     return RowFunctionFromCSR_helper<T, double, int64_t>(indptr, indices, data);
Guolin Ke's avatar
Guolin Ke committed
2793
2794
    }
  }
2795
  Log::Fatal("Unknown data type in RowFunctionFromCSR");
2796
  return nullptr;
2797
2798
}

2799
2800
2801
2802
2803
2804
2805
2806
2807
2808
2809
2810
2811
2812
2813
2814
2815
2816
2817


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
2818
std::function<std::pair<int, double>(int idx)>
2819
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
2820
  CHECK(col_idx < ncol_ptr && col_idx >= 0);
Guolin Ke's avatar
Guolin Ke committed
2821
2822
  if (data_type == C_API_DTYPE_FLOAT32) {
    if (col_ptr_type == C_API_DTYPE_INT32) {
2823
      return IterateFunctionFromCSC_helper<float, int32_t>(col_ptr, indices, data, col_idx);
Guolin Ke's avatar
Guolin Ke committed
2824
    } else if (col_ptr_type == C_API_DTYPE_INT64) {
2825
      return IterateFunctionFromCSC_helper<float, int64_t>(col_ptr, indices, data, col_idx);
Guolin Ke's avatar
Guolin Ke committed
2826
    }
Guolin Ke's avatar
Guolin Ke committed
2827
2828
  } else if (data_type == C_API_DTYPE_FLOAT64) {
    if (col_ptr_type == C_API_DTYPE_INT32) {
2829
      return IterateFunctionFromCSC_helper<double, int32_t>(col_ptr, indices, data, col_idx);
Guolin Ke's avatar
Guolin Ke committed
2830
    } else if (col_ptr_type == C_API_DTYPE_INT64) {
2831
      return IterateFunctionFromCSC_helper<double, int64_t>(col_ptr, indices, data, col_idx);
Guolin Ke's avatar
Guolin Ke committed
2832
2833
    }
  }
2834
  Log::Fatal("Unknown data type in CSC matrix");
2835
  return nullptr;
2836
2837
}

Guolin Ke's avatar
Guolin Ke committed
2838
CSC_RowIterator::CSC_RowIterator(const void* col_ptr, int col_ptr_type, const int32_t* indices,
2839
                                 const void* data, int data_type, int64_t ncol_ptr, int64_t nelem, int col_idx) {
Guolin Ke's avatar
Guolin Ke committed
2840
2841
2842
2843
2844
2845
2846
2847
2848
  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;
2849
    }
Guolin Ke's avatar
Guolin Ke committed
2850
2851
2852
2853
2854
2855
2856
2857
2858
2859
2860
2861
2862
2863
2864
2865
2866
    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;
2867
    }
Guolin Ke's avatar
Guolin Ke committed
2868
2869
2870
    return ret;
  } else {
    return std::make_pair(-1, 0.0);
2871
  }
Guolin Ke's avatar
Guolin Ke committed
2872
}