c_api.cpp 50.7 KB
Newer Older
1
#include <LightGBM/utils/openmp_wrapper.h>
Guolin Ke's avatar
Guolin Ke committed
2
3
4

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

#include <cstdio>
#include <vector>
#include <string>
#include <cstring>
Guolin Ke's avatar
Guolin Ke committed
19
#include <memory>
Guolin Ke's avatar
Guolin Ke committed
20
#include <stdexcept>
wxchan's avatar
wxchan committed
21
#include <mutex>
Guolin Ke's avatar
Guolin Ke committed
22
#include <functional>
Guolin Ke's avatar
Guolin Ke committed
23

Guolin Ke's avatar
Guolin Ke committed
24
25
#include "./application/predictor.hpp"

Guolin Ke's avatar
Guolin Ke committed
26
27
28
29
namespace LightGBM {

class Booster {
public:
Guolin Ke's avatar
Guolin Ke committed
30
31
  explicit Booster(const char* filename) {
    boosting_.reset(Boosting::CreateBoosting(filename));
Guolin Ke's avatar
Guolin Ke committed
32
33
  }

34
35
36
37
  Booster() {
    boosting_.reset(Boosting::CreateBoosting("gbdt", nullptr));
  }

Guolin Ke's avatar
Guolin Ke committed
38
  Booster(const Dataset* train_data,
39
          const char* parameters) {
Guolin Ke's avatar
Guolin Ke committed
40
    CHECK(train_data->num_features() > 0);
wxchan's avatar
wxchan committed
41
42
    auto param = ConfigBase::Str2Map(parameters);
    config_.Set(param);
43
44
45
    if (config_.num_threads > 0) {
      omp_set_num_threads(config_.num_threads);
    }
Guolin Ke's avatar
Guolin Ke committed
46
47
    // create boosting
    if (config_.io_config.input_model.size() > 0) {
Guolin Ke's avatar
Guolin Ke committed
48
      Log::Warning("continued train from model is not support for c_api, \
Guolin Ke's avatar
Guolin Ke committed
49
50
        please use continued train with input score");
    }
Guolin Ke's avatar
Guolin Ke committed
51

wxchan's avatar
wxchan committed
52
    boosting_.reset(Boosting::CreateBoosting(config_.boosting_type, nullptr));
Guolin Ke's avatar
Guolin Ke committed
53

54
55
    train_data_ = train_data;
    CreateObjectiveAndMetrics();
Guolin Ke's avatar
Guolin Ke committed
56
    // initialize the boosting
57
    boosting_->Init(&config_.boosting_config, train_data_, objective_fun_.get(),
58
                    Common::ConstPtrInVectorWrapper<Metric>(train_metric_));
Guolin Ke's avatar
Guolin Ke committed
59

wxchan's avatar
wxchan committed
60
61
62
63
64
  }

  void MergeFrom(const Booster* other) {
    std::lock_guard<std::mutex> lock(mutex_);
    boosting_->MergeFrom(other->boosting_.get());
Guolin Ke's avatar
Guolin Ke committed
65
66
67
  }

  ~Booster() {
Guolin Ke's avatar
Guolin Ke committed
68

Guolin Ke's avatar
Guolin Ke committed
69
  }
70

71
  void CreateObjectiveAndMetrics() {
Guolin Ke's avatar
Guolin Ke committed
72
73
    // create objective function
    objective_fun_.reset(ObjectiveFunction::CreateObjectiveFunction(config_.objective_type,
74
                                                                    config_.objective_config));
Guolin Ke's avatar
Guolin Ke committed
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
    if (objective_fun_ == nullptr) {
      Log::Warning("Using self-defined objective function");
    }
    // initialize the objective function
    if (objective_fun_ != nullptr) {
      objective_fun_->Init(train_data_->metadata(), train_data_->num_data());
    }

    // create training metric
    train_metric_.clear();
    for (auto metric_type : config_.metric_types) {
      auto metric = std::unique_ptr<Metric>(
        Metric::CreateMetric(metric_type, config_.metric_config));
      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();
93
94
95
96
  }

  void ResetTrainingData(const Dataset* train_data) {
    if (train_data != train_data_) {
Guolin Ke's avatar
Guolin Ke committed
97
      CHECK(train_data->num_features() > 0);
98
99
100
101
102
103
104
      std::lock_guard<std::mutex> lock(mutex_);
      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
105
106
107
  }

  void ResetConfig(const char* parameters) {
Guolin Ke's avatar
Guolin Ke committed
108
    std::lock_guard<std::mutex> lock(mutex_);
wxchan's avatar
wxchan committed
109
110
111
112
113
114
115
    auto param = ConfigBase::Str2Map(parameters);
    if (param.count("num_class")) {
      Log::Fatal("cannot change num class during training");
    }
    if (param.count("boosting_type")) {
      Log::Fatal("cannot change boosting_type during training");
    }
Guolin Ke's avatar
Guolin Ke committed
116
117
118
    if (param.count("metric")) {
      Log::Fatal("cannot change metric during training");
    }
Guolin Ke's avatar
Guolin Ke committed
119
120

    config_.Set(param);
121
122
123
    if (config_.num_threads > 0) {
      omp_set_num_threads(config_.num_threads);
    }
Guolin Ke's avatar
Guolin Ke committed
124
125
126
127

    if (param.count("objective")) {
      // create objective function
      objective_fun_.reset(ObjectiveFunction::CreateObjectiveFunction(config_.objective_type,
128
                                                                      config_.objective_config));
Guolin Ke's avatar
Guolin Ke committed
129
130
131
132
133
134
135
      if (objective_fun_ == nullptr) {
        Log::Warning("Using self-defined objective function");
      }
      // initialize the objective function
      if (objective_fun_ != nullptr) {
        objective_fun_->Init(train_data_->metadata(), train_data_->num_data());
      }
136
137
      boosting_->ResetTrainingData(train_data_,
                                   objective_fun_.get(), Common::ConstPtrInVectorWrapper<Metric>(train_metric_));
wxchan's avatar
wxchan committed
138
    }
Guolin Ke's avatar
Guolin Ke committed
139

140
    boosting_->ResetConfig(&config_.boosting_config);
Guolin Ke's avatar
Guolin Ke committed
141

wxchan's avatar
wxchan committed
142
143
144
145
146
147
148
149
150
151
152
153
154
  }

  void AddValidData(const Dataset* valid_data) {
    std::lock_guard<std::mutex> lock(mutex_);
    valid_metrics_.emplace_back();
    for (auto metric_type : config_.metric_types) {
      auto metric = std::unique_ptr<Metric>(Metric::CreateMetric(metric_type, config_.metric_config));
      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,
155
                               Common::ConstPtrInVectorWrapper<Metric>(valid_metrics_.back()));
wxchan's avatar
wxchan committed
156
  }
Guolin Ke's avatar
Guolin Ke committed
157

158
  bool TrainOneIter() {
wxchan's avatar
wxchan committed
159
    std::lock_guard<std::mutex> lock(mutex_);
Guolin Ke's avatar
Guolin Ke committed
160
    return boosting_->TrainOneIter(nullptr, nullptr);
161
162
163
  }

  bool TrainOneIter(const float* gradients, const float* hessians) {
wxchan's avatar
wxchan committed
164
    std::lock_guard<std::mutex> lock(mutex_);
Guolin Ke's avatar
Guolin Ke committed
165
    return boosting_->TrainOneIter(gradients, hessians);
166
167
  }

wxchan's avatar
wxchan committed
168
169
170
171
172
  void RollbackOneIter() {
    std::lock_guard<std::mutex> lock(mutex_);
    boosting_->RollbackOneIter();
  }

Guolin Ke's avatar
Guolin Ke committed
173
174
  void Predict(int num_iteration, int predict_type, int nrow,
               std::function<std::vector<std::pair<int, double>>(int row_idx)> get_row_fun,
Guolin Ke's avatar
Guolin Ke committed
175
               const IOConfig& config,
Guolin Ke's avatar
Guolin Ke committed
176
               double* out_result, int64_t* out_len) {
wxchan's avatar
wxchan committed
177
    std::lock_guard<std::mutex> lock(mutex_);
Guolin Ke's avatar
Guolin Ke committed
178
179
    bool is_predict_leaf = false;
    bool is_raw_score = false;
180
    bool is_predict_contrib = false;
Guolin Ke's avatar
Guolin Ke committed
181
    if (predict_type == C_API_PREDICT_LEAF_INDEX) {
Guolin Ke's avatar
Guolin Ke committed
182
      is_predict_leaf = true;
Guolin Ke's avatar
Guolin Ke committed
183
    } else if (predict_type == C_API_PREDICT_RAW_SCORE) {
Guolin Ke's avatar
Guolin Ke committed
184
      is_raw_score = true;
185
186
    } else if (predict_type == C_API_PREDICT_CONTRIB) {
      is_predict_contrib = true;
Guolin Ke's avatar
Guolin Ke committed
187
188
    } else {
      is_raw_score = false;
Guolin Ke's avatar
Guolin Ke committed
189
    }
Guolin Ke's avatar
Guolin Ke committed
190

191
    Predictor predictor(boosting_.get(), num_iteration, is_raw_score, is_predict_leaf, is_predict_contrib,
192
                        config.pred_early_stop, config.pred_early_stop_freq, config.pred_early_stop_margin);
193
    int64_t num_preb_in_one_row = boosting_->NumPredictOneRow(num_iteration, is_predict_leaf, is_predict_contrib);
Guolin Ke's avatar
Guolin Ke committed
194
    auto pred_fun = predictor.GetPredictFunction();
195
196
    OMP_INIT_EX();
    #pragma omp parallel for schedule(static)
Guolin Ke's avatar
Guolin Ke committed
197
    for (int i = 0; i < nrow; ++i) {
198
      OMP_LOOP_EX_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
199
      auto one_row = get_row_fun(i);
200
      auto pred_wrt_ptr = out_result + static_cast<size_t>(num_preb_in_one_row) * i;
Guolin Ke's avatar
Guolin Ke committed
201
      pred_fun(one_row, pred_wrt_ptr);
202
      OMP_LOOP_EX_END();
Guolin Ke's avatar
Guolin Ke committed
203
    }
204
    OMP_THROW_EX();
Guolin Ke's avatar
Guolin Ke committed
205
206
207
208
    *out_len = nrow * num_preb_in_one_row;
  }

  void Predict(int num_iteration, int predict_type, const char* data_filename,
Guolin Ke's avatar
Guolin Ke committed
209
               int data_has_header, const IOConfig& config,
cbecker's avatar
cbecker committed
210
               const char* result_filename) {
Guolin Ke's avatar
Guolin Ke committed
211
212
213
    std::lock_guard<std::mutex> lock(mutex_);
    bool is_predict_leaf = false;
    bool is_raw_score = false;
214
    bool is_predict_contrib = false;
Guolin Ke's avatar
Guolin Ke committed
215
216
217
218
    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;
219
220
    } else if (predict_type == C_API_PREDICT_CONTRIB) {
      is_predict_contrib = true;
Guolin Ke's avatar
Guolin Ke committed
221
222
223
    } else {
      is_raw_score = false;
    }
224
    Predictor predictor(boosting_.get(), num_iteration, is_raw_score, is_predict_leaf, is_predict_contrib,
225
                        config.pred_early_stop, config.pred_early_stop_freq, config.pred_early_stop_margin);
Guolin Ke's avatar
Guolin Ke committed
226
227
    bool bool_data_has_header = data_has_header > 0 ? true : false;
    predictor.Predict(data_filename, result_filename, bool_data_has_header);
Guolin Ke's avatar
Guolin Ke committed
228
229
  }

Guolin Ke's avatar
Guolin Ke committed
230
  void GetPredictAt(int data_idx, double* out_result, int64_t* out_len) {
wxchan's avatar
wxchan committed
231
232
233
234
235
    boosting_->GetPredictAt(data_idx, out_result, out_len);
  }

  void SaveModelToFile(int num_iteration, const char* filename) {
    boosting_->SaveModelToFile(num_iteration, filename);
Guolin Ke's avatar
Guolin Ke committed
236
  }
237

238
239
240
241
242
243
244
245
  void LoadModelFromString(const char* model_str) {
    boosting_->LoadModelFromString(model_str);
  }

  std::string SaveModelToString(int num_iteration) {
    return boosting_->SaveModelToString(num_iteration);
  }

246
247
  std::string DumpModel(int num_iteration) {
    return boosting_->DumpModel(num_iteration);
wxchan's avatar
wxchan committed
248
  }
249

250
251
252
253
  std::vector<double> FeatureImportance(int num_iteration, int importance_type) {
    return boosting_->FeatureImportance(num_iteration, importance_type);
  }

Guolin Ke's avatar
Guolin Ke committed
254
  double GetLeafValue(int tree_idx, int leaf_idx) const {
Guolin Ke's avatar
Guolin Ke committed
255
    return dynamic_cast<GBDTBase*>(boosting_.get())->GetLeafValue(tree_idx, leaf_idx);
Guolin Ke's avatar
Guolin Ke committed
256
257
258
259
  }

  void SetLeafValue(int tree_idx, int leaf_idx, double val) {
    std::lock_guard<std::mutex> lock(mutex_);
Guolin Ke's avatar
Guolin Ke committed
260
    dynamic_cast<GBDTBase*>(boosting_.get())->SetLeafValue(tree_idx, leaf_idx, val);
Guolin Ke's avatar
Guolin Ke committed
261
262
  }

wxchan's avatar
wxchan committed
263
264
265
266
267
268
269
  int GetEvalCounts() const {
    int ret = 0;
    for (const auto& metric : train_metric_) {
      ret += static_cast<int>(metric->GetName().size());
    }
    return ret;
  }
270

271
  #pragma warning(disable : 4996)
wxchan's avatar
wxchan committed
272
273
274
275
276
277
278
279
280
281
282
  int GetEvalNames(char** out_strs) const {
    int idx = 0;
    for (const auto& metric : train_metric_) {
      for (const auto& name : metric->GetName()) {
        std::strcpy(out_strs[idx], name.c_str());
        ++idx;
      }
    }
    return idx;
  }

283
  #pragma warning(disable : 4996)
wxchan's avatar
wxchan committed
284
285
286
287
288
289
290
291
292
  int GetFeatureNames(char** out_strs) const {
    int idx = 0;
    for (const auto& name : boosting_->FeatureNames()) {
      std::strcpy(out_strs[idx], name.c_str());
      ++idx;
    }
    return idx;
  }

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

Guolin Ke's avatar
Guolin Ke committed
295
private:
296

wxchan's avatar
wxchan committed
297
  const Dataset* train_data_;
Guolin Ke's avatar
Guolin Ke committed
298
  std::unique_ptr<Boosting> boosting_;
Guolin Ke's avatar
Guolin Ke committed
299
300
301
  /*! \brief All configs */
  OverallConfig config_;
  /*! \brief Metric for training data */
Guolin Ke's avatar
Guolin Ke committed
302
  std::vector<std::unique_ptr<Metric>> train_metric_;
Guolin Ke's avatar
Guolin Ke committed
303
  /*! \brief Metrics for validation data */
Guolin Ke's avatar
Guolin Ke committed
304
  std::vector<std::vector<std::unique_ptr<Metric>>> valid_metrics_;
Guolin Ke's avatar
Guolin Ke committed
305
  /*! \brief Training objective function */
Guolin Ke's avatar
Guolin Ke committed
306
  std::unique_ptr<ObjectiveFunction> objective_fun_;
wxchan's avatar
wxchan committed
307
308
  /*! \brief mutex for threading safe call */
  std::mutex mutex_;
Guolin Ke's avatar
Guolin Ke committed
309
310
311
};

}
Guolin Ke's avatar
Guolin Ke committed
312
313
314

using namespace LightGBM;

Guolin Ke's avatar
Guolin Ke committed
315
316
317
318
319
320
321
322
323
324
// 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);

std::function<std::vector<std::pair<int, double>>(int idx)>
RowFunctionFromCSR(const void* indptr, int indptr_type, const int32_t* indices,
325
                   const void* data, int data_type, int64_t nindptr, int64_t nelem);
Guolin Ke's avatar
Guolin Ke committed
326
327
328
329
330

// Row iterator of on column for CSC matrix
class CSC_RowIterator {
public:
  CSC_RowIterator(const void* col_ptr, int col_ptr_type, const int32_t* indices,
331
                  const void* data, int data_type, int64_t ncol_ptr, int64_t nelem, int col_idx);
Guolin Ke's avatar
Guolin Ke committed
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
  ~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();
private:
  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
347
const char* LGBM_GetLastError() {
wxchan's avatar
wxchan committed
348
  return LastErrorMsg();
Guolin Ke's avatar
Guolin Ke committed
349
350
}

Guolin Ke's avatar
Guolin Ke committed
351
int LGBM_DatasetCreateFromFile(const char* filename,
352
353
354
                               const char* parameters,
                               const DatasetHandle reference,
                               DatasetHandle* out) {
355
  API_BEGIN();
wxchan's avatar
wxchan committed
356
  auto param = ConfigBase::Str2Map(parameters);
357
358
359
360
361
  OverallConfig config;
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
362
  DatasetLoader loader(config.io_config,nullptr, 1, filename);
Guolin Ke's avatar
Guolin Ke committed
363
  if (reference == nullptr) {
364
    *out = loader.LoadFromFile(filename, "");
Guolin Ke's avatar
Guolin Ke committed
365
  } else {
366
    *out = loader.LoadFromFileAlignWithOtherDataset(filename, "",
367
                                                    reinterpret_cast<const Dataset*>(reference));
Guolin Ke's avatar
Guolin Ke committed
368
  }
369
  API_END();
Guolin Ke's avatar
Guolin Ke committed
370
371
}

372

Guolin Ke's avatar
Guolin Ke committed
373
int LGBM_DatasetCreateFromSampledColumn(double** sample_data,
374
375
376
377
378
379
380
                                        int** sample_indices,
                                        int32_t ncol,
                                        const int* num_per_col,
                                        int32_t num_sample_row,
                                        int32_t num_total_row,
                                        const char* parameters,
                                        DatasetHandle* out) {
381
382
  API_BEGIN();
  auto param = ConfigBase::Str2Map(parameters);
383
384
385
386
387
388
  OverallConfig config;
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
  DatasetLoader loader(config.io_config, nullptr, 1, nullptr);
389
390
391
392
  *out = loader.CostructFromSampleData(sample_data, sample_indices, ncol, num_per_col,
                                       num_sample_row,
                                       static_cast<data_size_t>(num_total_row));
  API_END();
Guolin Ke's avatar
Guolin Ke committed
393
394
}

395

Guolin Ke's avatar
Guolin Ke committed
396
int LGBM_DatasetCreateByReference(const DatasetHandle reference,
397
398
                                  int64_t num_total_row,
                                  DatasetHandle* out) {
Guolin Ke's avatar
Guolin Ke committed
399
400
401
402
403
404
405
406
  API_BEGIN();
  std::unique_ptr<Dataset> ret;
  ret.reset(new Dataset(static_cast<data_size_t>(num_total_row)));
  ret->CreateValid(reinterpret_cast<const Dataset*>(reference));
  *out = ret.release();
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
407
int LGBM_DatasetPushRows(DatasetHandle dataset,
408
409
410
411
412
                         const void* data,
                         int data_type,
                         int32_t nrow,
                         int32_t ncol,
                         int32_t start_row) {
Guolin Ke's avatar
Guolin Ke committed
413
414
415
  API_BEGIN();
  auto p_dataset = reinterpret_cast<Dataset*>(dataset);
  auto get_row_fun = RowFunctionFromDenseMatric(data, nrow, ncol, data_type, 1);
416
  OMP_INIT_EX();
Guolin Ke's avatar
Guolin Ke committed
417
  #pragma omp parallel for schedule(static)
Guolin Ke's avatar
Guolin Ke committed
418
  for (int i = 0; i < nrow; ++i) {
419
    OMP_LOOP_EX_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
420
421
422
    const int tid = omp_get_thread_num();
    auto one_row = get_row_fun(i);
    p_dataset->PushOneRow(tid, start_row + i, one_row);
423
    OMP_LOOP_EX_END();
Guolin Ke's avatar
Guolin Ke committed
424
  }
425
  OMP_THROW_EX();
Guolin Ke's avatar
Guolin Ke committed
426
427
428
429
430
431
  if (start_row + nrow == p_dataset->num_data()) {
    p_dataset->FinishLoad();
  }
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
432
int LGBM_DatasetPushRowsByCSR(DatasetHandle dataset,
433
434
435
436
437
438
439
440
441
                              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
442
443
444
445
  API_BEGIN();
  auto p_dataset = reinterpret_cast<Dataset*>(dataset);
  auto get_row_fun = RowFunctionFromCSR(indptr, indptr_type, indices, data, data_type, nindptr, nelem);
  int32_t nrow = static_cast<int32_t>(nindptr - 1);
446
  OMP_INIT_EX();
Guolin Ke's avatar
Guolin Ke committed
447
  #pragma omp parallel for schedule(static)
Guolin Ke's avatar
Guolin Ke committed
448
  for (int i = 0; i < nrow; ++i) {
449
    OMP_LOOP_EX_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
450
451
452
    const int tid = omp_get_thread_num();
    auto one_row = get_row_fun(i);
    p_dataset->PushOneRow(tid,
453
                          static_cast<data_size_t>(start_row + i), one_row);
454
    OMP_LOOP_EX_END();
Guolin Ke's avatar
Guolin Ke committed
455
  }
456
  OMP_THROW_EX();
Guolin Ke's avatar
Guolin Ke committed
457
458
459
460
461
462
  if (start_row + nrow == static_cast<int64_t>(p_dataset->num_data())) {
    p_dataset->FinishLoad();
  }
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
463
int LGBM_DatasetCreateFromMat(const void* data,
464
465
466
467
468
469
470
                              int data_type,
                              int32_t nrow,
                              int32_t ncol,
                              int is_row_major,
                              const char* parameters,
                              const DatasetHandle reference,
                              DatasetHandle* out) {
471
  API_BEGIN();
wxchan's avatar
wxchan committed
472
  auto param = ConfigBase::Str2Map(parameters);
473
474
475
476
477
  OverallConfig config;
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
Guolin Ke's avatar
Guolin Ke committed
478
  std::unique_ptr<Dataset> ret;
479
  auto get_row_fun = RowFunctionFromDenseMatric(data, nrow, ncol, data_type, is_row_major);
Guolin Ke's avatar
Guolin Ke committed
480
481
  if (reference == nullptr) {
    // sample data first
482
483
    Random rand(config.io_config.data_random_seed);
    int sample_cnt = static_cast<int>(nrow < config.io_config.bin_construct_sample_cnt ? nrow : config.io_config.bin_construct_sample_cnt);
Guolin Ke's avatar
Guolin Ke committed
484
    auto sample_indices = rand.Sample(nrow, sample_cnt);
485
    sample_cnt = static_cast<int>(sample_indices.size());
486
    std::vector<std::vector<double>> sample_values(ncol);
Guolin Ke's avatar
Guolin Ke committed
487
    std::vector<std::vector<int>> sample_idx(ncol);
Guolin Ke's avatar
Guolin Ke committed
488
    for (size_t i = 0; i < sample_indices.size(); ++i) {
Guolin Ke's avatar
Guolin Ke committed
489
      auto idx = sample_indices[i];
490
      auto row = get_row_fun(static_cast<int>(idx));
Guolin Ke's avatar
Guolin Ke committed
491
      for (size_t j = 0; j < row.size(); ++j) {
Guolin Ke's avatar
Guolin Ke committed
492
        if (std::fabs(row[j]) > kEpsilon || std::isnan(row[j])) {
Guolin Ke's avatar
Guolin Ke committed
493
494
          sample_values[j].emplace_back(row[j]);
          sample_idx[j].emplace_back(static_cast<int>(i));
Guolin Ke's avatar
Guolin Ke committed
495
        }
Guolin Ke's avatar
Guolin Ke committed
496
497
      }
    }
498
    DatasetLoader loader(config.io_config, nullptr, 1, nullptr);
Guolin Ke's avatar
Guolin Ke committed
499
500
    ret.reset(loader.CostructFromSampleData(Common::Vector2Ptr<double>(sample_values).data(),
                                            Common::Vector2Ptr<int>(sample_idx).data(),
501
502
503
                                            static_cast<int>(sample_values.size()),
                                            Common::VectorSize<double>(sample_values).data(),
                                            sample_cnt, nrow));
Guolin Ke's avatar
Guolin Ke committed
504
  } else {
505
    ret.reset(new Dataset(nrow));
Guolin Ke's avatar
Guolin Ke committed
506
    ret->CreateValid(
507
      reinterpret_cast<const Dataset*>(reference));
Guolin Ke's avatar
Guolin Ke committed
508
  }
509
  OMP_INIT_EX();
Guolin Ke's avatar
Guolin Ke committed
510
  #pragma omp parallel for schedule(static)
Guolin Ke's avatar
Guolin Ke committed
511
  for (int i = 0; i < nrow; ++i) {
512
    OMP_LOOP_EX_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
513
    const int tid = omp_get_thread_num();
514
    auto one_row = get_row_fun(i);
Guolin Ke's avatar
Guolin Ke committed
515
    ret->PushOneRow(tid, i, one_row);
516
    OMP_LOOP_EX_END();
Guolin Ke's avatar
Guolin Ke committed
517
  }
518
  OMP_THROW_EX();
Guolin Ke's avatar
Guolin Ke committed
519
  ret->FinishLoad();
Guolin Ke's avatar
Guolin Ke committed
520
  *out = ret.release();
521
  API_END();
522
523
}

Guolin Ke's avatar
Guolin Ke committed
524
int LGBM_DatasetCreateFromCSR(const void* indptr,
525
526
527
528
529
530
531
532
533
534
                              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) {
535
  API_BEGIN();
wxchan's avatar
wxchan committed
536
  auto param = ConfigBase::Str2Map(parameters);
537
538
539
540
541
  OverallConfig config;
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
Guolin Ke's avatar
Guolin Ke committed
542
  std::unique_ptr<Dataset> ret;
543
  auto get_row_fun = RowFunctionFromCSR(indptr, indptr_type, indices, data, data_type, nindptr, nelem);
544
545
546
  int32_t nrow = static_cast<int32_t>(nindptr - 1);
  if (reference == nullptr) {
    // sample data first
547
548
    Random rand(config.io_config.data_random_seed);
    int sample_cnt = static_cast<int>(nrow < config.io_config.bin_construct_sample_cnt ? nrow : config.io_config.bin_construct_sample_cnt);
549
    auto sample_indices = rand.Sample(nrow, sample_cnt);
550
    sample_cnt = static_cast<int>(sample_indices.size());
551
    std::vector<std::vector<double>> sample_values;
Guolin Ke's avatar
Guolin Ke committed
552
    std::vector<std::vector<int>> sample_idx;
553
554
555
556
    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) {
557
        if (static_cast<size_t>(inner_data.first) >= sample_values.size()) {
Guolin Ke's avatar
Guolin Ke committed
558
559
          sample_values.resize(inner_data.first + 1);
          sample_idx.resize(inner_data.first + 1);
560
        }
Guolin Ke's avatar
Guolin Ke committed
561
        if (std::fabs(inner_data.second) > kEpsilon || std::isnan(inner_data.second)) {
Guolin Ke's avatar
Guolin Ke committed
562
563
          sample_values[inner_data.first].emplace_back(inner_data.second);
          sample_idx[inner_data.first].emplace_back(static_cast<int>(i));
564
565
566
        }
      }
    }
567
    CHECK(num_col >= static_cast<int>(sample_values.size()));
568
    DatasetLoader loader(config.io_config, nullptr, 1, nullptr);
Guolin Ke's avatar
Guolin Ke committed
569
570
    ret.reset(loader.CostructFromSampleData(Common::Vector2Ptr<double>(sample_values).data(),
                                            Common::Vector2Ptr<int>(sample_idx).data(),
571
572
573
                                            static_cast<int>(sample_values.size()),
                                            Common::VectorSize<double>(sample_values).data(),
                                            sample_cnt, nrow));
574
  } else {
575
    ret.reset(new Dataset(nrow));
Guolin Ke's avatar
Guolin Ke committed
576
    ret->CreateValid(
577
      reinterpret_cast<const Dataset*>(reference));
578
  }
579
  OMP_INIT_EX();
Guolin Ke's avatar
Guolin Ke committed
580
  #pragma omp parallel for schedule(static)
581
  for (int i = 0; i < nindptr - 1; ++i) {
582
    OMP_LOOP_EX_BEGIN();
583
584
585
    const int tid = omp_get_thread_num();
    auto one_row = get_row_fun(i);
    ret->PushOneRow(tid, i, one_row);
586
    OMP_LOOP_EX_END();
587
  }
588
  OMP_THROW_EX();
589
  ret->FinishLoad();
Guolin Ke's avatar
Guolin Ke committed
590
  *out = ret.release();
591
  API_END();
592
593
}

Guolin Ke's avatar
Guolin Ke committed
594
int LGBM_DatasetCreateFromCSC(const void* col_ptr,
595
596
597
598
599
600
601
602
603
604
                              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) {
605
  API_BEGIN();
wxchan's avatar
wxchan committed
606
  auto param = ConfigBase::Str2Map(parameters);
607
608
609
610
611
  OverallConfig config;
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
Guolin Ke's avatar
Guolin Ke committed
612
  std::unique_ptr<Dataset> ret;
Guolin Ke's avatar
Guolin Ke committed
613
614
615
  int32_t nrow = static_cast<int32_t>(num_row);
  if (reference == nullptr) {
    // sample data first
616
617
    Random rand(config.io_config.data_random_seed);
    int sample_cnt = static_cast<int>(nrow < config.io_config.bin_construct_sample_cnt ? nrow : config.io_config.bin_construct_sample_cnt);
Guolin Ke's avatar
Guolin Ke committed
618
    auto sample_indices = rand.Sample(nrow, sample_cnt);
619
    sample_cnt = static_cast<int>(sample_indices.size());
Guolin Ke's avatar
Guolin Ke committed
620
    std::vector<std::vector<double>> sample_values(ncol_ptr - 1);
Guolin Ke's avatar
Guolin Ke committed
621
    std::vector<std::vector<int>> sample_idx(ncol_ptr - 1);
622
    OMP_INIT_EX();
Guolin Ke's avatar
Guolin Ke committed
623
    #pragma omp parallel for schedule(static)
Guolin Ke's avatar
Guolin Ke committed
624
    for (int i = 0; i < static_cast<int>(sample_values.size()); ++i) {
625
      OMP_LOOP_EX_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
626
627
628
      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
629
        if (std::fabs(val) > kEpsilon || std::isnan(val)) {
Guolin Ke's avatar
Guolin Ke committed
630
631
          sample_values[i].emplace_back(val);
          sample_idx[i].emplace_back(j);
Guolin Ke's avatar
Guolin Ke committed
632
633
        }
      }
634
      OMP_LOOP_EX_END();
Guolin Ke's avatar
Guolin Ke committed
635
    }
636
    OMP_THROW_EX();
637
    DatasetLoader loader(config.io_config, nullptr, 1, nullptr);
Guolin Ke's avatar
Guolin Ke committed
638
639
    ret.reset(loader.CostructFromSampleData(Common::Vector2Ptr<double>(sample_values).data(),
                                            Common::Vector2Ptr<int>(sample_idx).data(),
640
641
642
                                            static_cast<int>(sample_values.size()),
                                            Common::VectorSize<double>(sample_values).data(),
                                            sample_cnt, nrow));
Guolin Ke's avatar
Guolin Ke committed
643
  } else {
644
    ret.reset(new Dataset(nrow));
Guolin Ke's avatar
Guolin Ke committed
645
    ret->CreateValid(
646
      reinterpret_cast<const Dataset*>(reference));
Guolin Ke's avatar
Guolin Ke committed
647
  }
648
  OMP_INIT_EX();
Guolin Ke's avatar
Guolin Ke committed
649
  #pragma omp parallel for schedule(static)
Guolin Ke's avatar
Guolin Ke committed
650
  for (int i = 0; i < ncol_ptr - 1; ++i) {
651
    OMP_LOOP_EX_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
652
    const int tid = omp_get_thread_num();
Guolin Ke's avatar
Guolin Ke committed
653
    int feature_idx = ret->InnerFeatureIndex(i);
Guolin Ke's avatar
Guolin Ke committed
654
    if (feature_idx < 0) { continue; }
Guolin Ke's avatar
Guolin Ke committed
655
656
    int group = ret->Feature2Group(feature_idx);
    int sub_feature = ret->Feture2SubFeature(feature_idx);
Guolin Ke's avatar
Guolin Ke committed
657
658
659
660
661
662
663
    CSC_RowIterator col_it(col_ptr, col_ptr_type, indices, data, data_type, ncol_ptr, nelem, i);
    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; }
Guolin Ke's avatar
Guolin Ke committed
664
      ret->PushOneData(tid, row_idx, group, sub_feature, pair.second);
Guolin Ke's avatar
Guolin Ke committed
665
    }
666
    OMP_LOOP_EX_END();
Guolin Ke's avatar
Guolin Ke committed
667
  }
668
  OMP_THROW_EX();
Guolin Ke's avatar
Guolin Ke committed
669
  ret->FinishLoad();
Guolin Ke's avatar
Guolin Ke committed
670
  *out = ret.release();
671
  API_END();
Guolin Ke's avatar
Guolin Ke committed
672
673
}

Guolin Ke's avatar
Guolin Ke committed
674
int LGBM_DatasetGetSubset(
675
  const DatasetHandle handle,
wxchan's avatar
wxchan committed
676
677
678
  const int32_t* used_row_indices,
  int32_t num_used_row_indices,
  const char* parameters,
Guolin Ke's avatar
typo  
Guolin Ke committed
679
  DatasetHandle* out) {
wxchan's avatar
wxchan committed
680
681
  API_BEGIN();
  auto param = ConfigBase::Str2Map(parameters);
682
683
684
685
686
  OverallConfig config;
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
687
  auto full_dataset = reinterpret_cast<const Dataset*>(handle);
Guolin Ke's avatar
Guolin Ke committed
688
  CHECK(num_used_row_indices > 0);
689
690
691
  const int32_t lower = 0;
  const int32_t upper = full_dataset->num_data() - 1;
  Common::CheckElementsIntervalClosed(used_row_indices, lower, upper, num_used_row_indices, "Used indices of subset");
Guolin Ke's avatar
Guolin Ke committed
692
  auto ret = std::unique_ptr<Dataset>(new Dataset(num_used_row_indices));
693
  ret->CopyFeatureMapperFrom(full_dataset);
Guolin Ke's avatar
Guolin Ke committed
694
  ret->CopySubset(full_dataset, used_row_indices, num_used_row_indices, true);
wxchan's avatar
wxchan committed
695
696
697
698
  *out = ret.release();
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
699
int LGBM_DatasetSetFeatureNames(
Guolin Ke's avatar
typo  
Guolin Ke committed
700
  DatasetHandle handle,
Guolin Ke's avatar
Guolin Ke committed
701
  const char** feature_names,
Guolin Ke's avatar
Guolin Ke committed
702
  int num_feature_names) {
Guolin Ke's avatar
Guolin Ke committed
703
704
705
  API_BEGIN();
  auto dataset = reinterpret_cast<Dataset*>(handle);
  std::vector<std::string> feature_names_str;
Guolin Ke's avatar
Guolin Ke committed
706
  for (int i = 0; i < num_feature_names; ++i) {
Guolin Ke's avatar
Guolin Ke committed
707
708
709
710
711
712
    feature_names_str.emplace_back(feature_names[i]);
  }
  dataset->set_feature_names(feature_names_str);
  API_END();
}

713
#pragma warning(disable : 4996)
Guolin Ke's avatar
Guolin Ke committed
714
int LGBM_DatasetGetFeatureNames(
715
716
  DatasetHandle handle,
  char** feature_names,
Guolin Ke's avatar
Guolin Ke committed
717
  int* num_feature_names) {
718
719
720
  API_BEGIN();
  auto dataset = reinterpret_cast<Dataset*>(handle);
  auto inside_feature_name = dataset->feature_names();
Guolin Ke's avatar
Guolin Ke committed
721
722
  *num_feature_names = static_cast<int>(inside_feature_name.size());
  for (int i = 0; i < *num_feature_names; ++i) {
723
724
725
726
727
    std::strcpy(feature_names[i], inside_feature_name[i].c_str());
  }
  API_END();
}

728
#pragma warning(disable : 4702)
Guolin Ke's avatar
Guolin Ke committed
729
int LGBM_DatasetFree(DatasetHandle handle) {
730
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
731
  delete reinterpret_cast<Dataset*>(handle);
732
  API_END();
733
734
}

Guolin Ke's avatar
Guolin Ke committed
735
int LGBM_DatasetSaveBinary(DatasetHandle handle,
736
                           const char* filename) {
737
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
738
739
  auto dataset = reinterpret_cast<Dataset*>(handle);
  dataset->SaveBinaryFile(filename);
740
  API_END();
741
742
}

Guolin Ke's avatar
Guolin Ke committed
743
int LGBM_DatasetSetField(DatasetHandle handle,
744
745
746
747
                         const char* field_name,
                         const void* field_data,
                         int num_element,
                         int type) {
748
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
749
  auto dataset = reinterpret_cast<Dataset*>(handle);
750
  bool is_success = false;
Guolin Ke's avatar
Guolin Ke committed
751
  if (type == C_API_DTYPE_FLOAT32) {
Guolin Ke's avatar
Guolin Ke committed
752
    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
753
  } else if (type == C_API_DTYPE_INT32) {
Guolin Ke's avatar
Guolin Ke committed
754
    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
755
756
  } 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));
757
  }
758
759
  if (!is_success) { throw std::runtime_error("Input data type erorr or field not found"); }
  API_END();
760
761
}

Guolin Ke's avatar
Guolin Ke committed
762
int LGBM_DatasetGetField(DatasetHandle handle,
763
764
765
766
                         const char* field_name,
                         int* out_len,
                         const void** out_ptr,
                         int* out_type) {
767
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
768
  auto dataset = reinterpret_cast<Dataset*>(handle);
769
  bool is_success = false;
Guolin Ke's avatar
Guolin Ke committed
770
  if (dataset->GetFloatField(field_name, out_len, reinterpret_cast<const float**>(out_ptr))) {
Guolin Ke's avatar
Guolin Ke committed
771
    *out_type = C_API_DTYPE_FLOAT32;
772
    is_success = true;
Guolin Ke's avatar
Guolin Ke committed
773
  } else if (dataset->GetIntField(field_name, out_len, reinterpret_cast<const int**>(out_ptr))) {
Guolin Ke's avatar
Guolin Ke committed
774
    *out_type = C_API_DTYPE_INT32;
775
    is_success = true;
Guolin Ke's avatar
Guolin Ke committed
776
777
778
  } else if (dataset->GetDoubleField(field_name, out_len, reinterpret_cast<const double**>(out_ptr))) {
    *out_type = C_API_DTYPE_FLOAT64;
    is_success = true;
779
  }
780
  if (!is_success) { throw std::runtime_error("Field not found"); }
wxchan's avatar
wxchan committed
781
  if (*out_ptr == nullptr) { *out_len = 0; }
782
  API_END();
783
784
}

Guolin Ke's avatar
Guolin Ke committed
785
int LGBM_DatasetGetNumData(DatasetHandle handle,
786
                           int* out) {
787
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
788
789
  auto dataset = reinterpret_cast<Dataset*>(handle);
  *out = dataset->num_data();
790
  API_END();
791
792
}

Guolin Ke's avatar
Guolin Ke committed
793
int LGBM_DatasetGetNumFeature(DatasetHandle handle,
794
                              int* out) {
795
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
796
797
  auto dataset = reinterpret_cast<Dataset*>(handle);
  *out = dataset->num_total_features();
798
  API_END();
Guolin Ke's avatar
Guolin Ke committed
799
}
800
801
802

// ---- start of booster

Guolin Ke's avatar
Guolin Ke committed
803
int LGBM_BoosterCreate(const DatasetHandle train_data,
804
805
                       const char* parameters,
                       BoosterHandle* out) {
806
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
807
  const Dataset* p_train_data = reinterpret_cast<const Dataset*>(train_data);
wxchan's avatar
wxchan committed
808
809
  auto ret = std::unique_ptr<Booster>(new Booster(p_train_data, parameters));
  *out = ret.release();
810
  API_END();
811
812
}

Guolin Ke's avatar
Guolin Ke committed
813
int LGBM_BoosterCreateFromModelfile(
814
  const char* filename,
Guolin Ke's avatar
Guolin Ke committed
815
  int* out_num_iterations,
816
  BoosterHandle* out) {
817
  API_BEGIN();
wxchan's avatar
wxchan committed
818
  auto ret = std::unique_ptr<Booster>(new Booster(filename));
Guolin Ke's avatar
Guolin Ke committed
819
  *out_num_iterations = ret->GetBoosting()->GetCurrentIteration();
wxchan's avatar
wxchan committed
820
  *out = ret.release();
821
  API_END();
822
823
}

Guolin Ke's avatar
Guolin Ke committed
824
int LGBM_BoosterLoadModelFromString(
825
826
827
828
829
830
831
832
833
834
835
  const char* model_str,
  int* out_num_iterations,
  BoosterHandle* out) {
  API_BEGIN();
  auto ret = std::unique_ptr<Booster>(new Booster());
  ret->LoadModelFromString(model_str);
  *out_num_iterations = ret->GetBoosting()->GetCurrentIteration();
  *out = ret.release();
  API_END();
}

836
#pragma warning(disable : 4702)
Guolin Ke's avatar
Guolin Ke committed
837
int LGBM_BoosterFree(BoosterHandle handle) {
838
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
839
  delete reinterpret_cast<Booster*>(handle);
840
  API_END();
841
842
}

Guolin Ke's avatar
Guolin Ke committed
843
int LGBM_BoosterMerge(BoosterHandle handle,
844
                      BoosterHandle other_handle) {
wxchan's avatar
wxchan committed
845
846
847
848
849
850
851
  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
852
int LGBM_BoosterAddValidData(BoosterHandle handle,
853
                             const DatasetHandle valid_data) {
wxchan's avatar
wxchan committed
854
855
856
857
858
859
860
  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
861
int LGBM_BoosterResetTrainingData(BoosterHandle handle,
862
                                  const DatasetHandle train_data) {
wxchan's avatar
wxchan committed
863
864
865
866
867
868
869
  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
870
int LGBM_BoosterResetParameter(BoosterHandle handle, const char* parameters) {
wxchan's avatar
wxchan committed
871
872
873
874
875
876
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  ref_booster->ResetConfig(parameters);
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
877
int LGBM_BoosterGetNumClasses(BoosterHandle handle, int* out_len) {
wxchan's avatar
wxchan committed
878
879
880
881
882
883
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  *out_len = ref_booster->GetBoosting()->NumberOfClasses();
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
884
int LGBM_BoosterUpdateOneIter(BoosterHandle handle, int* is_finished) {
885
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
886
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
887
888
889
890
891
  if (ref_booster->TrainOneIter()) {
    *is_finished = 1;
  } else {
    *is_finished = 0;
  }
892
  API_END();
893
894
}

Guolin Ke's avatar
Guolin Ke committed
895
int LGBM_BoosterUpdateOneIterCustom(BoosterHandle handle,
896
897
898
                                    const float* grad,
                                    const float* hess,
                                    int* is_finished) {
899
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
900
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
901
902
903
904
905
  if (ref_booster->TrainOneIter(grad, hess)) {
    *is_finished = 1;
  } else {
    *is_finished = 0;
  }
906
  API_END();
907
908
}

Guolin Ke's avatar
Guolin Ke committed
909
int LGBM_BoosterRollbackOneIter(BoosterHandle handle) {
wxchan's avatar
wxchan committed
910
911
912
913
914
915
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  ref_booster->RollbackOneIter();
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
916
int LGBM_BoosterGetCurrentIteration(BoosterHandle handle, int* out_iteration) {
wxchan's avatar
wxchan committed
917
918
919
920
921
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  *out_iteration = ref_booster->GetBoosting()->GetCurrentIteration();
  API_END();
}
Guolin Ke's avatar
Guolin Ke committed
922

Guolin Ke's avatar
Guolin Ke committed
923
int LGBM_BoosterGetEvalCounts(BoosterHandle handle, int* out_len) {
wxchan's avatar
wxchan committed
924
925
926
927
928
929
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  *out_len = ref_booster->GetEvalCounts();
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
930
int LGBM_BoosterGetEvalNames(BoosterHandle handle, int* out_len, char** out_strs) {
wxchan's avatar
wxchan committed
931
932
933
934
935
936
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  *out_len = ref_booster->GetEvalNames(out_strs);
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
937
int LGBM_BoosterGetFeatureNames(BoosterHandle handle, int* out_len, char** out_strs) {
wxchan's avatar
wxchan committed
938
939
940
941
942
943
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  *out_len = ref_booster->GetFeatureNames(out_strs);
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
944
int LGBM_BoosterGetNumFeature(BoosterHandle handle, int* out_len) {
wxchan's avatar
wxchan committed
945
946
947
948
949
950
  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
951
int LGBM_BoosterGetEval(BoosterHandle handle,
952
953
954
                        int data_idx,
                        int* out_len,
                        double* out_results) {
955
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
956
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
957
  auto boosting = ref_booster->GetBoosting();
wxchan's avatar
wxchan committed
958
  auto result_buf = boosting->GetEvalAt(data_idx);
Guolin Ke's avatar
Guolin Ke committed
959
  *out_len = static_cast<int>(result_buf.size());
960
  for (size_t i = 0; i < result_buf.size(); ++i) {
Guolin Ke's avatar
Guolin Ke committed
961
    (out_results)[i] = static_cast<double>(result_buf[i]);
962
  }
963
  API_END();
964
965
}

Guolin Ke's avatar
Guolin Ke committed
966
int LGBM_BoosterGetNumPredict(BoosterHandle handle,
967
968
                              int data_idx,
                              int64_t* out_len) {
Guolin Ke's avatar
Guolin Ke committed
969
970
971
972
973
974
  API_BEGIN();
  auto boosting = reinterpret_cast<Booster*>(handle)->GetBoosting();
  *out_len = boosting->GetNumPredictAt(data_idx);
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
975
int LGBM_BoosterGetPredict(BoosterHandle handle,
976
977
978
                           int data_idx,
                           int64_t* out_len,
                           double* out_result) {
979
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
980
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
981
  ref_booster->GetPredictAt(data_idx, out_result, out_len);
982
  API_END();
Guolin Ke's avatar
Guolin Ke committed
983
984
}

Guolin Ke's avatar
Guolin Ke committed
985
int LGBM_BoosterPredictForFile(BoosterHandle handle,
986
987
988
989
                               const char* data_filename,
                               int data_has_header,
                               int predict_type,
                               int num_iteration,
990
                               const char* parameter,
991
                               const char* result_filename) {
992
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
993
994
995
996
997
998
  auto param = ConfigBase::Str2Map(parameter);
  OverallConfig config;
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
Guolin Ke's avatar
Guolin Ke committed
999
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
cbecker's avatar
cbecker committed
1000
  ref_booster->Predict(num_iteration, predict_type, data_filename, data_has_header,
Guolin Ke's avatar
Guolin Ke committed
1001
                       config.io_config, result_filename);
1002
  API_END();
1003
1004
}

Guolin Ke's avatar
Guolin Ke committed
1005
int LGBM_BoosterCalcNumPredict(BoosterHandle handle,
1006
1007
1008
1009
                               int num_row,
                               int predict_type,
                               int num_iteration,
                               int64_t* out_len) {
Guolin Ke's avatar
Guolin Ke committed
1010
1011
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
Guolin Ke's avatar
Guolin Ke committed
1012
  *out_len = static_cast<int64_t>(num_row * ref_booster->GetBoosting()->NumPredictOneRow(
1013
    num_iteration, predict_type == C_API_PREDICT_LEAF_INDEX, predict_type == C_API_PREDICT_CONTRIB));
Guolin Ke's avatar
Guolin Ke committed
1014
1015
1016
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1017
int LGBM_BoosterPredictForCSR(BoosterHandle handle,
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
                              const void* indptr,
                              int indptr_type,
                              const int32_t* indices,
                              const void* data,
                              int data_type,
                              int64_t nindptr,
                              int64_t nelem,
                              int64_t,
                              int predict_type,
                              int num_iteration,
1028
                              const char* parameter,
1029
1030
                              int64_t* out_len,
                              double* out_result) {
1031
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1032
1033
1034
1035
1036
1037
  auto param = ConfigBase::Str2Map(parameter);
  OverallConfig config;
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
Guolin Ke's avatar
Guolin Ke committed
1038
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
1039
  auto get_row_fun = RowFunctionFromCSR(indptr, indptr_type, indices, data, data_type, nindptr, nelem);
Guolin Ke's avatar
Guolin Ke committed
1040
  int nrow = static_cast<int>(nindptr - 1);
cbecker's avatar
cbecker committed
1041
  ref_booster->Predict(num_iteration, predict_type, nrow, get_row_fun,
Guolin Ke's avatar
Guolin Ke committed
1042
                       config.io_config, out_result, out_len);
1043
  API_END();
Guolin Ke's avatar
Guolin Ke committed
1044
}
1045

Guolin Ke's avatar
Guolin Ke committed
1046
int LGBM_BoosterPredictForCSC(BoosterHandle handle,
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
                              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,
                              int num_iteration,
1057
                              const char* parameter,
1058
1059
                              int64_t* out_len,
                              double* out_result) {
Guolin Ke's avatar
Guolin Ke committed
1060
1061
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
Guolin Ke's avatar
Guolin Ke committed
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
  auto param = ConfigBase::Str2Map(parameter);
  OverallConfig config;
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
  int num_threads = 1;
  #pragma omp parallel
  #pragma omp master
  {
    num_threads = omp_get_num_threads();
  }
Guolin Ke's avatar
Guolin Ke committed
1074
  int ncol = static_cast<int>(ncol_ptr - 1);
Guolin Ke's avatar
Guolin Ke committed
1075
1076
1077
1078
1079
  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
1080
1081
  }
  std::function<std::vector<std::pair<int, double>>(int row_idx)> get_row_fun =
1082
    [&iterators, ncol] (int i) {
Guolin Ke's avatar
Guolin Ke committed
1083
    std::vector<std::pair<int, double>> one_row;
Guolin Ke's avatar
Guolin Ke committed
1084
    const int tid = omp_get_thread_num();
Guolin Ke's avatar
Guolin Ke committed
1085
    for (int j = 0; j < ncol; ++j) {
Guolin Ke's avatar
Guolin Ke committed
1086
      auto val = iterators[tid][j].Get(i);
Guolin Ke's avatar
Guolin Ke committed
1087
      if (std::fabs(val) > kEpsilon || std::isnan(val)) {
Guolin Ke's avatar
Guolin Ke committed
1088
        one_row.emplace_back(j, val);
Guolin Ke's avatar
Guolin Ke committed
1089
1090
      }
    }
Guolin Ke's avatar
Guolin Ke committed
1091
1092
    return one_row;
  };
Guolin Ke's avatar
Guolin Ke committed
1093
  ref_booster->Predict(num_iteration, predict_type, static_cast<int>(num_row), get_row_fun, config.io_config,
cbecker's avatar
cbecker committed
1094
                       out_result, out_len);
Guolin Ke's avatar
Guolin Ke committed
1095
1096
1097
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1098
int LGBM_BoosterPredictForMat(BoosterHandle handle,
1099
1100
1101
1102
1103
1104
1105
                              const void* data,
                              int data_type,
                              int32_t nrow,
                              int32_t ncol,
                              int is_row_major,
                              int predict_type,
                              int num_iteration,
1106
                              const char* parameter,
1107
1108
                              int64_t* out_len,
                              double* out_result) {
1109
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1110
1111
1112
1113
1114
1115
  auto param = ConfigBase::Str2Map(parameter);
  OverallConfig config;
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
Guolin Ke's avatar
Guolin Ke committed
1116
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
1117
  auto get_row_fun = RowPairFunctionFromDenseMatric(data, nrow, ncol, data_type, is_row_major);
cbecker's avatar
cbecker committed
1118
  ref_booster->Predict(num_iteration, predict_type, nrow, get_row_fun,
Guolin Ke's avatar
Guolin Ke committed
1119
                       config.io_config, out_result, out_len);
1120
  API_END();
Guolin Ke's avatar
Guolin Ke committed
1121
}
1122

Guolin Ke's avatar
Guolin Ke committed
1123
int LGBM_BoosterSaveModel(BoosterHandle handle,
1124
1125
                          int num_iteration,
                          const char* filename) {
1126
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1127
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
wxchan's avatar
wxchan committed
1128
1129
1130
1131
  ref_booster->SaveModelToFile(num_iteration, filename);
  API_END();
}

1132
#pragma warning(disable : 4996)
Guolin Ke's avatar
Guolin Ke committed
1133
int LGBM_BoosterSaveModelToString(BoosterHandle handle,
1134
1135
1136
1137
                                  int num_iteration,
                                  int buffer_len,
                                  int* out_len,
                                  char* out_str) {
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  std::string model = ref_booster->SaveModelToString(num_iteration);
  *out_len = static_cast<int>(model.size()) + 1;
  if (*out_len <= buffer_len) {
    std::strcpy(out_str, model.c_str());
  }
  API_END();
}

1148
#pragma warning(disable : 4996)
Guolin Ke's avatar
Guolin Ke committed
1149
int LGBM_BoosterDumpModel(BoosterHandle handle,
1150
1151
1152
1153
                          int num_iteration,
                          int buffer_len,
                          int* out_len,
                          char* out_str) {
wxchan's avatar
wxchan committed
1154
1155
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
1156
  std::string model = ref_booster->DumpModel(num_iteration);
Guolin Ke's avatar
Guolin Ke committed
1157
  *out_len = static_cast<int>(model.size()) + 1;
wxchan's avatar
wxchan committed
1158
  if (*out_len <= buffer_len) {
Guolin Ke's avatar
Guolin Ke committed
1159
    std::strcpy(out_str, model.c_str());
wxchan's avatar
wxchan committed
1160
  }
1161
  API_END();
Guolin Ke's avatar
Guolin Ke committed
1162
}
1163

Guolin Ke's avatar
Guolin Ke committed
1164
int LGBM_BoosterGetLeafValue(BoosterHandle handle,
1165
1166
1167
                             int tree_idx,
                             int leaf_idx,
                             double* out_val) {
Guolin Ke's avatar
Guolin Ke committed
1168
1169
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
Guolin Ke's avatar
Guolin Ke committed
1170
  *out_val = static_cast<double>(ref_booster->GetLeafValue(tree_idx, leaf_idx));
Guolin Ke's avatar
Guolin Ke committed
1171
1172
1173
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1174
int LGBM_BoosterSetLeafValue(BoosterHandle handle,
1175
1176
1177
                             int tree_idx,
                             int leaf_idx,
                             double val) {
Guolin Ke's avatar
Guolin Ke committed
1178
1179
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
Guolin Ke's avatar
Guolin Ke committed
1180
  ref_booster->SetLeafValue(tree_idx, leaf_idx, val);
Guolin Ke's avatar
Guolin Ke committed
1181
1182
1183
  API_END();
}

1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
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();
}

Guolin Ke's avatar
Guolin Ke committed
1197
// ---- start of some help functions
1198
1199
1200

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
1201
  if (data_type == C_API_DTYPE_FLOAT32) {
1202
1203
    const float* data_ptr = reinterpret_cast<const float*>(data);
    if (is_row_major) {
1204
      return [data_ptr, num_col, num_row] (int row_idx) {
Guolin Ke's avatar
Guolin Ke committed
1205
        std::vector<double> ret(num_col);
1206
        auto tmp_ptr = data_ptr + static_cast<size_t>(num_col) * row_idx;
1207
        for (int i = 0; i < num_col; ++i) {
Guolin Ke's avatar
Guolin Ke committed
1208
          ret[i] = static_cast<double>(*(tmp_ptr + i));
1209
1210
1211
1212
        }
        return ret;
      };
    } else {
1213
      return [data_ptr, num_col, num_row] (int row_idx) {
Guolin Ke's avatar
Guolin Ke committed
1214
        std::vector<double> ret(num_col);
1215
        for (int i = 0; i < num_col; ++i) {
1216
          ret[i] = static_cast<double>(*(data_ptr + static_cast<size_t>(num_row) * i + row_idx));
1217
1218
1219
1220
        }
        return ret;
      };
    }
Guolin Ke's avatar
Guolin Ke committed
1221
  } else if (data_type == C_API_DTYPE_FLOAT64) {
1222
1223
    const double* data_ptr = reinterpret_cast<const double*>(data);
    if (is_row_major) {
1224
      return [data_ptr, num_col, num_row] (int row_idx) {
Guolin Ke's avatar
Guolin Ke committed
1225
        std::vector<double> ret(num_col);
1226
        auto tmp_ptr = data_ptr + static_cast<size_t>(num_col) * row_idx;
1227
        for (int i = 0; i < num_col; ++i) {
Guolin Ke's avatar
Guolin Ke committed
1228
          ret[i] = static_cast<double>(*(tmp_ptr + i));
1229
1230
1231
1232
        }
        return ret;
      };
    } else {
1233
      return [data_ptr, num_col, num_row] (int row_idx) {
Guolin Ke's avatar
Guolin Ke committed
1234
        std::vector<double> ret(num_col);
1235
        for (int i = 0; i < num_col; ++i) {
1236
          ret[i] = static_cast<double>(*(data_ptr + static_cast<size_t>(num_row) * i + row_idx));
1237
1238
1239
1240
1241
        }
        return ret;
      };
    }
  }
Guolin Ke's avatar
Guolin Ke committed
1242
  throw std::runtime_error("unknown data type in RowFunctionFromDenseMatric");
1243
1244
1245
1246
}

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
1247
1248
  auto inner_function = RowFunctionFromDenseMatric(data, num_row, num_col, data_type, is_row_major);
  if (inner_function != nullptr) {
1249
    return [inner_function] (int row_idx) {
Guolin Ke's avatar
Guolin Ke committed
1250
1251
1252
      auto raw_values = inner_function(row_idx);
      std::vector<std::pair<int, double>> ret;
      for (int i = 0; i < static_cast<int>(raw_values.size()); ++i) {
Guolin Ke's avatar
Guolin Ke committed
1253
        if (std::fabs(raw_values[i]) > kEpsilon || std::isnan(raw_values[i])) {
Guolin Ke's avatar
Guolin Ke committed
1254
          ret.emplace_back(i, raw_values[i]);
1255
        }
Guolin Ke's avatar
Guolin Ke committed
1256
1257
1258
      }
      return ret;
    };
1259
  }
Guolin Ke's avatar
Guolin Ke committed
1260
  return nullptr;
1261
1262
1263
1264
}

std::function<std::vector<std::pair<int, double>>(int idx)>
RowFunctionFromCSR(const void* indptr, int indptr_type, const int32_t* indices, const void* data, int data_type, int64_t nindptr, int64_t nelem) {
Guolin Ke's avatar
Guolin Ke committed
1265
  if (data_type == C_API_DTYPE_FLOAT32) {
1266
    const float* data_ptr = reinterpret_cast<const float*>(data);
Guolin Ke's avatar
Guolin Ke committed
1267
    if (indptr_type == C_API_DTYPE_INT32) {
1268
      const int32_t* ptr_indptr = reinterpret_cast<const int32_t*>(indptr);
1269
      return [ptr_indptr, indices, data_ptr, nindptr, nelem] (int idx) {
1270
1271
1272
        std::vector<std::pair<int, double>> ret;
        int64_t start = ptr_indptr[idx];
        int64_t end = ptr_indptr[idx + 1];
Guolin Ke's avatar
Guolin Ke committed
1273
        for (int64_t i = start; i < end; ++i) {
Guolin Ke's avatar
Guolin Ke committed
1274
          ret.emplace_back(indices[i], data_ptr[i]);
1275
1276
1277
        }
        return ret;
      };
Guolin Ke's avatar
Guolin Ke committed
1278
    } else if (indptr_type == C_API_DTYPE_INT64) {
1279
      const int64_t* ptr_indptr = reinterpret_cast<const int64_t*>(indptr);
1280
      return [ptr_indptr, indices, data_ptr, nindptr, nelem] (int idx) {
1281
1282
1283
        std::vector<std::pair<int, double>> ret;
        int64_t start = ptr_indptr[idx];
        int64_t end = ptr_indptr[idx + 1];
Guolin Ke's avatar
Guolin Ke committed
1284
        for (int64_t i = start; i < end; ++i) {
Guolin Ke's avatar
Guolin Ke committed
1285
          ret.emplace_back(indices[i], data_ptr[i]);
1286
1287
1288
1289
        }
        return ret;
      };
    }
Guolin Ke's avatar
Guolin Ke committed
1290
  } else if (data_type == C_API_DTYPE_FLOAT64) {
1291
    const double* data_ptr = reinterpret_cast<const double*>(data);
Guolin Ke's avatar
Guolin Ke committed
1292
    if (indptr_type == C_API_DTYPE_INT32) {
1293
      const int32_t* ptr_indptr = reinterpret_cast<const int32_t*>(indptr);
1294
      return [ptr_indptr, indices, data_ptr, nindptr, nelem] (int idx) {
1295
1296
1297
        std::vector<std::pair<int, double>> ret;
        int64_t start = ptr_indptr[idx];
        int64_t end = ptr_indptr[idx + 1];
Guolin Ke's avatar
Guolin Ke committed
1298
        for (int64_t i = start; i < end; ++i) {
Guolin Ke's avatar
Guolin Ke committed
1299
          ret.emplace_back(indices[i], data_ptr[i]);
1300
1301
1302
        }
        return ret;
      };
Guolin Ke's avatar
Guolin Ke committed
1303
    } else if (indptr_type == C_API_DTYPE_INT64) {
1304
      const int64_t* ptr_indptr = reinterpret_cast<const int64_t*>(indptr);
1305
      return [ptr_indptr, indices, data_ptr, nindptr, nelem] (int idx) {
1306
1307
1308
        std::vector<std::pair<int, double>> ret;
        int64_t start = ptr_indptr[idx];
        int64_t end = ptr_indptr[idx + 1];
Guolin Ke's avatar
Guolin Ke committed
1309
        for (int64_t i = start; i < end; ++i) {
Guolin Ke's avatar
Guolin Ke committed
1310
          ret.emplace_back(indices[i], data_ptr[i]);
1311
1312
1313
        }
        return ret;
      };
Guolin Ke's avatar
Guolin Ke committed
1314
1315
    }
  }
Guolin Ke's avatar
Guolin Ke committed
1316
  throw std::runtime_error("unknown data type in RowFunctionFromCSR");
1317
1318
}

Guolin Ke's avatar
Guolin Ke committed
1319
1320
1321
std::function<std::pair<int, double>(int idx)>
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 nelem, int col_idx) {
  CHECK(col_idx < ncol_ptr && col_idx >= 0);
Guolin Ke's avatar
Guolin Ke committed
1322
  if (data_type == C_API_DTYPE_FLOAT32) {
1323
    const float* data_ptr = reinterpret_cast<const float*>(data);
Guolin Ke's avatar
Guolin Ke committed
1324
    if (col_ptr_type == C_API_DTYPE_INT32) {
1325
      const int32_t* ptr_col_ptr = reinterpret_cast<const int32_t*>(col_ptr);
Guolin Ke's avatar
Guolin Ke committed
1326
1327
      int64_t start = ptr_col_ptr[col_idx];
      int64_t end = ptr_col_ptr[col_idx + 1];
1328
      return [ptr_col_ptr, indices, data_ptr, ncol_ptr, nelem, start, end] (int bias) {
Guolin Ke's avatar
Guolin Ke committed
1329
1330
1331
        int64_t i = static_cast<int64_t>(start + bias);
        if (i >= end) {
          return std::make_pair(-1, 0.0);
1332
        }
Guolin Ke's avatar
Guolin Ke committed
1333
1334
1335
        int idx = static_cast<int>(indices[i]);
        double val = static_cast<double>(data_ptr[i]);
        return std::make_pair(idx, val);
1336
      };
Guolin Ke's avatar
Guolin Ke committed
1337
    } else if (col_ptr_type == C_API_DTYPE_INT64) {
1338
      const int64_t* ptr_col_ptr = reinterpret_cast<const int64_t*>(col_ptr);
Guolin Ke's avatar
Guolin Ke committed
1339
1340
      int64_t start = ptr_col_ptr[col_idx];
      int64_t end = ptr_col_ptr[col_idx + 1];
1341
      return [ptr_col_ptr, indices, data_ptr, ncol_ptr, nelem, start, end] (int bias) {
Guolin Ke's avatar
Guolin Ke committed
1342
1343
1344
        int64_t i = static_cast<int64_t>(start + bias);
        if (i >= end) {
          return std::make_pair(-1, 0.0);
1345
        }
Guolin Ke's avatar
Guolin Ke committed
1346
1347
1348
        int idx = static_cast<int>(indices[i]);
        double val = static_cast<double>(data_ptr[i]);
        return std::make_pair(idx, val);
1349
      };
Guolin Ke's avatar
Guolin Ke committed
1350
    }
Guolin Ke's avatar
Guolin Ke committed
1351
  } else if (data_type == C_API_DTYPE_FLOAT64) {
1352
    const double* data_ptr = reinterpret_cast<const double*>(data);
Guolin Ke's avatar
Guolin Ke committed
1353
    if (col_ptr_type == C_API_DTYPE_INT32) {
1354
      const int32_t* ptr_col_ptr = reinterpret_cast<const int32_t*>(col_ptr);
Guolin Ke's avatar
Guolin Ke committed
1355
1356
      int64_t start = ptr_col_ptr[col_idx];
      int64_t end = ptr_col_ptr[col_idx + 1];
1357
      return [ptr_col_ptr, indices, data_ptr, ncol_ptr, nelem, start, end] (int bias) {
Guolin Ke's avatar
Guolin Ke committed
1358
1359
1360
        int64_t i = static_cast<int64_t>(start + bias);
        if (i >= end) {
          return std::make_pair(-1, 0.0);
1361
        }
Guolin Ke's avatar
Guolin Ke committed
1362
1363
1364
        int idx = static_cast<int>(indices[i]);
        double val = static_cast<double>(data_ptr[i]);
        return std::make_pair(idx, val);
1365
      };
Guolin Ke's avatar
Guolin Ke committed
1366
    } else if (col_ptr_type == C_API_DTYPE_INT64) {
1367
      const int64_t* ptr_col_ptr = reinterpret_cast<const int64_t*>(col_ptr);
Guolin Ke's avatar
Guolin Ke committed
1368
1369
      int64_t start = ptr_col_ptr[col_idx];
      int64_t end = ptr_col_ptr[col_idx + 1];
1370
      return [ptr_col_ptr, indices, data_ptr, ncol_ptr, nelem, start, end] (int bias) {
Guolin Ke's avatar
Guolin Ke committed
1371
1372
1373
        int64_t i = static_cast<int64_t>(start + bias);
        if (i >= end) {
          return std::make_pair(-1, 0.0);
1374
        }
Guolin Ke's avatar
Guolin Ke committed
1375
1376
1377
        int idx = static_cast<int>(indices[i]);
        double val = static_cast<double>(data_ptr[i]);
        return std::make_pair(idx, val);
1378
      };
Guolin Ke's avatar
Guolin Ke committed
1379
1380
1381
    }
  }
  throw std::runtime_error("unknown data type in CSC matrix");
1382
1383
}

Guolin Ke's avatar
Guolin Ke committed
1384
CSC_RowIterator::CSC_RowIterator(const void* col_ptr, int col_ptr_type, const int32_t* indices,
1385
                                 const void* data, int data_type, int64_t ncol_ptr, int64_t nelem, int col_idx) {
Guolin Ke's avatar
Guolin Ke committed
1386
1387
1388
1389
1390
1391
1392
1393
1394
  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;
1395
    }
Guolin Ke's avatar
Guolin Ke committed
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
    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;
1413
    }
Guolin Ke's avatar
Guolin Ke committed
1414
1415
1416
    return ret;
  } else {
    return std::make_pair(-1, 0.0);
1417
  }
Guolin Ke's avatar
Guolin Ke committed
1418
}