"include/vscode:/vscode.git/clone" did not exist on "d84e9a2e5526bbb08bd901bc8d1c3ce528d68b85"
c_api.cpp 52.9 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>
14
#include <LightGBM/network.h>
Guolin Ke's avatar
Guolin Ke committed
15
16
17
18
19

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

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

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

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

Guolin Ke's avatar
Guolin Ke committed
35
  Booster(const Dataset* train_data,
36
          const char* parameters) {
Guolin Ke's avatar
Guolin Ke committed
37
    CHECK(train_data->num_features() > 0);
Guolin Ke's avatar
Guolin Ke committed
38
    auto param = Config::Str2Map(parameters);
wxchan's avatar
wxchan committed
39
    config_.Set(param);
40
41
42
    if (config_.num_threads > 0) {
      omp_set_num_threads(config_.num_threads);
    }
Guolin Ke's avatar
Guolin Ke committed
43
    // create boosting
Guolin Ke's avatar
Guolin Ke committed
44
    if (config_.input_model.size() > 0) {
45
46
      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
47
    }
Guolin Ke's avatar
Guolin Ke committed
48

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

51
52
    train_data_ = train_data;
    CreateObjectiveAndMetrics();
Guolin Ke's avatar
Guolin Ke committed
53
    // initialize the boosting
Guolin Ke's avatar
Guolin Ke committed
54
    if (config_.tree_learner == std::string("feature")) {
55
      Log::Fatal("Do not support feature parallel in c api");
56
    }
Guolin Ke's avatar
Guolin Ke committed
57
    if (Network::num_machines() == 1 && config_.tree_learner != std::string("serial")) {
58
      Log::Warning("Only find one worker, will switch to serial tree learner");
Guolin Ke's avatar
Guolin Ke committed
59
      config_.tree_learner = "serial";
60
    }
Guolin Ke's avatar
Guolin Ke committed
61
    boosting_->Init(&config_, train_data_, objective_fun_.get(),
62
                    Common::ConstPtrInVectorWrapper<Metric>(train_metric_));
Guolin Ke's avatar
Guolin Ke committed
63

wxchan's avatar
wxchan committed
64
65
66
67
68
  }

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

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

Guolin Ke's avatar
Guolin Ke committed
73
  }
74

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

    // create training metric
    train_metric_.clear();
Guolin Ke's avatar
Guolin Ke committed
89
    for (auto metric_type : config_.metric) {
Guolin Ke's avatar
Guolin Ke committed
90
      auto metric = std::unique_ptr<Metric>(
Guolin Ke's avatar
Guolin Ke committed
91
        Metric::CreateMetric(metric_type, config_));
Guolin Ke's avatar
Guolin Ke committed
92
93
94
95
96
      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();
97
98
99
100
  }

  void ResetTrainingData(const Dataset* train_data) {
    if (train_data != train_data_) {
Guolin Ke's avatar
Guolin Ke committed
101
      CHECK(train_data->num_features() > 0);
102
103
104
105
106
107
108
      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
109
110
111
  }

  void ResetConfig(const char* parameters) {
Guolin Ke's avatar
Guolin Ke committed
112
    std::lock_guard<std::mutex> lock(mutex_);
Guolin Ke's avatar
Guolin Ke committed
113
    auto param = Config::Str2Map(parameters);
wxchan's avatar
wxchan committed
114
    if (param.count("num_class")) {
115
      Log::Fatal("Cannot change num_class during training");
wxchan's avatar
wxchan committed
116
    }
Guolin Ke's avatar
Guolin Ke committed
117
118
    if (param.count("boosting")) {
      Log::Fatal("Cannot change boosting during training");
wxchan's avatar
wxchan committed
119
    }
Guolin Ke's avatar
Guolin Ke committed
120
    if (param.count("metric")) {
121
      Log::Fatal("Cannot change metric during training");
Guolin Ke's avatar
Guolin Ke committed
122
    }
Guolin Ke's avatar
Guolin Ke committed
123
124

    config_.Set(param);
125
126
127
    if (config_.num_threads > 0) {
      omp_set_num_threads(config_.num_threads);
    }
Guolin Ke's avatar
Guolin Ke committed
128
129
130

    if (param.count("objective")) {
      // create objective function
Guolin Ke's avatar
Guolin Ke committed
131
132
      objective_fun_.reset(ObjectiveFunction::CreateObjectiveFunction(config_.objective,
                                                                      config_));
Guolin Ke's avatar
Guolin Ke committed
133
134
135
136
137
138
139
      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());
      }
140
141
      boosting_->ResetTrainingData(train_data_,
                                   objective_fun_.get(), Common::ConstPtrInVectorWrapper<Metric>(train_metric_));
wxchan's avatar
wxchan committed
142
    }
Guolin Ke's avatar
Guolin Ke committed
143

Guolin Ke's avatar
Guolin Ke committed
144
    boosting_->ResetConfig(&config_);
Guolin Ke's avatar
Guolin Ke committed
145

wxchan's avatar
wxchan committed
146
147
148
149
150
  }

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

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

167
  bool TrainOneIter(const score_t* gradients, const score_t* hessians) {
wxchan's avatar
wxchan committed
168
    std::lock_guard<std::mutex> lock(mutex_);
Guolin Ke's avatar
Guolin Ke committed
169
    return boosting_->TrainOneIter(gradients, hessians);
170
171
  }

wxchan's avatar
wxchan committed
172
173
174
175
176
  void RollbackOneIter() {
    std::lock_guard<std::mutex> lock(mutex_);
    boosting_->RollbackOneIter();
  }

Guolin Ke's avatar
Guolin Ke committed
177
178
  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
179
               const Config& config,
Guolin Ke's avatar
Guolin Ke committed
180
               double* out_result, int64_t* out_len) {
wxchan's avatar
wxchan committed
181
    std::lock_guard<std::mutex> lock(mutex_);
Guolin Ke's avatar
Guolin Ke committed
182
183
    bool is_predict_leaf = false;
    bool is_raw_score = false;
Guolin Ke's avatar
Guolin Ke committed
184
    bool predict_contrib = false;
Guolin Ke's avatar
Guolin Ke committed
185
    if (predict_type == C_API_PREDICT_LEAF_INDEX) {
Guolin Ke's avatar
Guolin Ke committed
186
      is_predict_leaf = true;
Guolin Ke's avatar
Guolin Ke committed
187
    } else if (predict_type == C_API_PREDICT_RAW_SCORE) {
Guolin Ke's avatar
Guolin Ke committed
188
      is_raw_score = true;
189
    } else if (predict_type == C_API_PREDICT_CONTRIB) {
Guolin Ke's avatar
Guolin Ke committed
190
      predict_contrib = true;
Guolin Ke's avatar
Guolin Ke committed
191
192
    } else {
      is_raw_score = false;
Guolin Ke's avatar
Guolin Ke committed
193
    }
Guolin Ke's avatar
Guolin Ke committed
194

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

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

Guolin Ke's avatar
Guolin Ke committed
234
  void GetPredictAt(int data_idx, double* out_result, int64_t* out_len) {
wxchan's avatar
wxchan committed
235
236
237
238
239
    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
240
  }
241

242
  void LoadModelFromString(const char* model_str) {
243
244
    size_t len = std::strlen(model_str);
    boosting_->LoadModelFromString(model_str, len);
245
246
247
248
249
250
  }

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

251
252
  std::string DumpModel(int num_iteration) {
    return boosting_->DumpModel(num_iteration);
wxchan's avatar
wxchan committed
253
  }
254

255
256
257
258
  std::vector<double> FeatureImportance(int num_iteration, int importance_type) {
    return boosting_->FeatureImportance(num_iteration, importance_type);
  }

Guolin Ke's avatar
Guolin Ke committed
259
  double GetLeafValue(int tree_idx, int leaf_idx) const {
Guolin Ke's avatar
Guolin Ke committed
260
    return dynamic_cast<GBDTBase*>(boosting_.get())->GetLeafValue(tree_idx, leaf_idx);
Guolin Ke's avatar
Guolin Ke committed
261
262
263
264
  }

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

wxchan's avatar
wxchan committed
268
269
270
271
272
273
274
  int GetEvalCounts() const {
    int ret = 0;
    for (const auto& metric : train_metric_) {
      ret += static_cast<int>(metric->GetName().size());
    }
    return ret;
  }
275

wxchan's avatar
wxchan committed
276
277
278
279
  int GetEvalNames(char** out_strs) const {
    int idx = 0;
    for (const auto& metric : train_metric_) {
      for (const auto& name : metric->GetName()) {
Guolin Ke's avatar
Guolin Ke committed
280
        std::memcpy(out_strs[idx], name.c_str(), name.size() + 1);
wxchan's avatar
wxchan committed
281
282
283
284
285
286
        ++idx;
      }
    }
    return idx;
  }

wxchan's avatar
wxchan committed
287
288
289
  int GetFeatureNames(char** out_strs) const {
    int idx = 0;
    for (const auto& name : boosting_->FeatureNames()) {
Guolin Ke's avatar
Guolin Ke committed
290
      std::memcpy(out_strs[idx], name.c_str(), name.size() + 1);
wxchan's avatar
wxchan committed
291
292
293
294
295
      ++idx;
    }
    return idx;
  }

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

Guolin Ke's avatar
Guolin Ke committed
298
private:
299

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

}
Guolin Ke's avatar
Guolin Ke committed
315
316
317

using namespace LightGBM;

Guolin Ke's avatar
Guolin Ke committed
318
319
320
321
322
323
324
325
326
327
// 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,
328
                   const void* data, int data_type, int64_t nindptr, int64_t nelem);
Guolin Ke's avatar
Guolin Ke committed
329
330
331
332
333

// 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,
334
                  const void* data, int data_type, int64_t ncol_ptr, int64_t nelem, int col_idx);
Guolin Ke's avatar
Guolin Ke committed
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
  ~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
350
const char* LGBM_GetLastError() {
wxchan's avatar
wxchan committed
351
  return LastErrorMsg();
Guolin Ke's avatar
Guolin Ke committed
352
353
}

Guolin Ke's avatar
Guolin Ke committed
354
int LGBM_DatasetCreateFromFile(const char* filename,
355
356
357
                               const char* parameters,
                               const DatasetHandle reference,
                               DatasetHandle* out) {
358
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
359
360
  auto param = Config::Str2Map(parameters);
  Config config;
361
362
363
364
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
Guolin Ke's avatar
Guolin Ke committed
365
  DatasetLoader loader(config,nullptr, 1, filename);
Guolin Ke's avatar
Guolin Ke committed
366
  if (reference == nullptr) {
367
368
369
370
371
    if (Network::num_machines() == 1) {
      *out = loader.LoadFromFile(filename, "");
    } else {
      *out = loader.LoadFromFile(filename, "", Network::rank(), Network::num_machines());
    }
Guolin Ke's avatar
Guolin Ke committed
372
  } else {
373
    *out = loader.LoadFromFileAlignWithOtherDataset(filename, "",
374
                                                    reinterpret_cast<const Dataset*>(reference));
Guolin Ke's avatar
Guolin Ke committed
375
  }
376
  API_END();
Guolin Ke's avatar
Guolin Ke committed
377
378
}

379

Guolin Ke's avatar
Guolin Ke committed
380
int LGBM_DatasetCreateFromSampledColumn(double** sample_data,
381
382
383
384
385
386
387
                                        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) {
388
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
389
390
  auto param = Config::Str2Map(parameters);
  Config config;
391
392
393
394
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
Guolin Ke's avatar
Guolin Ke committed
395
  DatasetLoader loader(config, nullptr, 1, nullptr);
396
397
398
399
  *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
400
401
}

402

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

Guolin Ke's avatar
Guolin Ke committed
439
int LGBM_DatasetPushRowsByCSR(DatasetHandle dataset,
440
441
442
443
444
445
446
447
448
                              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
449
450
451
452
  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);
453
  OMP_INIT_EX();
Guolin Ke's avatar
Guolin Ke committed
454
  #pragma omp parallel for schedule(static)
Guolin Ke's avatar
Guolin Ke committed
455
  for (int i = 0; i < nrow; ++i) {
456
    OMP_LOOP_EX_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
457
458
459
    const int tid = omp_get_thread_num();
    auto one_row = get_row_fun(i);
    p_dataset->PushOneRow(tid,
460
                          static_cast<data_size_t>(start_row + i), one_row);
461
    OMP_LOOP_EX_END();
Guolin Ke's avatar
Guolin Ke committed
462
  }
463
  OMP_THROW_EX();
Guolin Ke's avatar
Guolin Ke committed
464
465
466
467
468
469
  if (start_row + nrow == static_cast<int64_t>(p_dataset->num_data())) {
    p_dataset->FinishLoad();
  }
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
470
int LGBM_DatasetCreateFromMat(const void* data,
471
472
473
474
475
476
477
                              int data_type,
                              int32_t nrow,
                              int32_t ncol,
                              int is_row_major,
                              const char* parameters,
                              const DatasetHandle reference,
                              DatasetHandle* out) {
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
  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) {
499
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
500
501
  auto param = Config::Str2Map(parameters);
  Config config;
502
503
504
505
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
Guolin Ke's avatar
Guolin Ke committed
506
  std::unique_ptr<Dataset> ret;
507
508
509
510
511
512
513
514
515
516
  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));
  }
  
Guolin Ke's avatar
Guolin Ke committed
517
518
  if (reference == nullptr) {
    // sample data first
Guolin Ke's avatar
Guolin Ke committed
519
    Random rand(config.data_random_seed);
520
521
    int sample_cnt = static_cast<int>(total_nrow < config.bin_construct_sample_cnt ? total_nrow : config.bin_construct_sample_cnt);
    auto sample_indices = rand.Sample(total_nrow, sample_cnt);
522
    sample_cnt = static_cast<int>(sample_indices.size());
523
    std::vector<std::vector<double>> sample_values(ncol);
Guolin Ke's avatar
Guolin Ke committed
524
    std::vector<std::vector<int>> sample_idx(ncol);
525
526
527

    int offset = 0;
    int j = 0;
Guolin Ke's avatar
Guolin Ke committed
528
    for (size_t i = 0; i < sample_indices.size(); ++i) {
Guolin Ke's avatar
Guolin Ke committed
529
      auto idx = sample_indices[i];
530
531
532
533
534
535
536
537
538
539
      while ((idx - offset) >= nrow[j]) {
        offset += nrow[j];
        ++j;
      }
      
      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
540
        }
Guolin Ke's avatar
Guolin Ke committed
541
542
      }
    }
Guolin Ke's avatar
Guolin Ke committed
543
    DatasetLoader loader(config, nullptr, 1, nullptr);
Guolin Ke's avatar
Guolin Ke committed
544
545
    ret.reset(loader.CostructFromSampleData(Common::Vector2Ptr<double>(sample_values).data(),
                                            Common::Vector2Ptr<int>(sample_idx).data(),
546
547
                                            static_cast<int>(sample_values.size()),
                                            Common::VectorSize<double>(sample_values).data(),
548
                                            sample_cnt, total_nrow));
Guolin Ke's avatar
Guolin Ke committed
549
  } else {
550
    ret.reset(new Dataset(total_nrow));
Guolin Ke's avatar
Guolin Ke committed
551
    ret->CreateValid(
552
      reinterpret_cast<const Dataset*>(reference));
Guolin Ke's avatar
Guolin Ke committed
553
  }
554
555
556
557
558
559
560
561
562
563
564
565
566
567
  int32_t start_row = 0;
  for (int j = 0; j < nmat; ++j) {
    OMP_INIT_EX();
    #pragma omp parallel for schedule(static)
    for (int i = 0; i < nrow[j]; ++i) {
      OMP_LOOP_EX_BEGIN();
      const int tid = omp_get_thread_num();
      auto one_row = get_row_fun[j](i);
      ret->PushOneRow(tid, start_row + i, one_row);
      OMP_LOOP_EX_END();
    }
    OMP_THROW_EX();

    start_row += nrow[j];
Guolin Ke's avatar
Guolin Ke committed
568
569
  }
  ret->FinishLoad();
Guolin Ke's avatar
Guolin Ke committed
570
  *out = ret.release();
571
  API_END();
572
573
}

Guolin Ke's avatar
Guolin Ke committed
574
int LGBM_DatasetCreateFromCSR(const void* indptr,
575
576
577
578
579
580
581
582
583
584
                              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) {
585
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
586
587
  auto param = Config::Str2Map(parameters);
  Config config;
588
589
590
591
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
Guolin Ke's avatar
Guolin Ke committed
592
  std::unique_ptr<Dataset> ret;
593
  auto get_row_fun = RowFunctionFromCSR(indptr, indptr_type, indices, data, data_type, nindptr, nelem);
594
595
596
  int32_t nrow = static_cast<int32_t>(nindptr - 1);
  if (reference == nullptr) {
    // sample data first
Guolin Ke's avatar
Guolin Ke committed
597
598
    Random rand(config.data_random_seed);
    int sample_cnt = static_cast<int>(nrow < config.bin_construct_sample_cnt ? nrow : config.bin_construct_sample_cnt);
599
    auto sample_indices = rand.Sample(nrow, sample_cnt);
600
    sample_cnt = static_cast<int>(sample_indices.size());
Guolin Ke's avatar
Guolin Ke committed
601
602
    std::vector<std::vector<double>> sample_values(num_col);
    std::vector<std::vector<int>> sample_idx(num_col);
603
604
605
606
    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) {
Guolin Ke's avatar
Guolin Ke committed
607
        CHECK(inner_data.first < num_col);
Guolin Ke's avatar
Guolin Ke committed
608
        if (std::fabs(inner_data.second) > kZeroThreshold || std::isnan(inner_data.second)) {
Guolin Ke's avatar
Guolin Ke committed
609
610
          sample_values[inner_data.first].emplace_back(inner_data.second);
          sample_idx[inner_data.first].emplace_back(static_cast<int>(i));
611
612
613
        }
      }
    }
Guolin Ke's avatar
Guolin Ke committed
614
    DatasetLoader loader(config, nullptr, 1, nullptr);
Guolin Ke's avatar
Guolin Ke committed
615
616
    ret.reset(loader.CostructFromSampleData(Common::Vector2Ptr<double>(sample_values).data(),
                                            Common::Vector2Ptr<int>(sample_idx).data(),
617
618
619
                                            static_cast<int>(sample_values.size()),
                                            Common::VectorSize<double>(sample_values).data(),
                                            sample_cnt, nrow));
620
  } else {
621
    ret.reset(new Dataset(nrow));
Guolin Ke's avatar
Guolin Ke committed
622
    ret->CreateValid(
623
      reinterpret_cast<const Dataset*>(reference));
624
  }
625
  OMP_INIT_EX();
Guolin Ke's avatar
Guolin Ke committed
626
  #pragma omp parallel for schedule(static)
627
  for (int i = 0; i < nindptr - 1; ++i) {
628
    OMP_LOOP_EX_BEGIN();
629
630
631
    const int tid = omp_get_thread_num();
    auto one_row = get_row_fun(i);
    ret->PushOneRow(tid, i, one_row);
632
    OMP_LOOP_EX_END();
633
  }
634
  OMP_THROW_EX();
635
  ret->FinishLoad();
Guolin Ke's avatar
Guolin Ke committed
636
  *out = ret.release();
637
  API_END();
638
639
}

Guolin Ke's avatar
Guolin Ke committed
640
int LGBM_DatasetCreateFromCSC(const void* col_ptr,
641
642
643
644
645
646
647
648
649
650
                              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) {
651
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
652
653
  auto param = Config::Str2Map(parameters);
  Config config;
654
655
656
657
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
Guolin Ke's avatar
Guolin Ke committed
658
  std::unique_ptr<Dataset> ret;
Guolin Ke's avatar
Guolin Ke committed
659
660
661
  int32_t nrow = static_cast<int32_t>(num_row);
  if (reference == nullptr) {
    // sample data first
Guolin Ke's avatar
Guolin Ke committed
662
663
    Random rand(config.data_random_seed);
    int sample_cnt = static_cast<int>(nrow < config.bin_construct_sample_cnt ? nrow : config.bin_construct_sample_cnt);
Guolin Ke's avatar
Guolin Ke committed
664
    auto sample_indices = rand.Sample(nrow, sample_cnt);
665
    sample_cnt = static_cast<int>(sample_indices.size());
Guolin Ke's avatar
Guolin Ke committed
666
    std::vector<std::vector<double>> sample_values(ncol_ptr - 1);
Guolin Ke's avatar
Guolin Ke committed
667
    std::vector<std::vector<int>> sample_idx(ncol_ptr - 1);
668
    OMP_INIT_EX();
Guolin Ke's avatar
Guolin Ke committed
669
    #pragma omp parallel for schedule(static)
Guolin Ke's avatar
Guolin Ke committed
670
    for (int i = 0; i < static_cast<int>(sample_values.size()); ++i) {
671
      OMP_LOOP_EX_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
672
673
674
      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
675
        if (std::fabs(val) > kZeroThreshold || std::isnan(val)) {
Guolin Ke's avatar
Guolin Ke committed
676
677
          sample_values[i].emplace_back(val);
          sample_idx[i].emplace_back(j);
Guolin Ke's avatar
Guolin Ke committed
678
679
        }
      }
680
      OMP_LOOP_EX_END();
Guolin Ke's avatar
Guolin Ke committed
681
    }
682
    OMP_THROW_EX();
Guolin Ke's avatar
Guolin Ke committed
683
    DatasetLoader loader(config, nullptr, 1, nullptr);
Guolin Ke's avatar
Guolin Ke committed
684
685
    ret.reset(loader.CostructFromSampleData(Common::Vector2Ptr<double>(sample_values).data(),
                                            Common::Vector2Ptr<int>(sample_idx).data(),
686
687
688
                                            static_cast<int>(sample_values.size()),
                                            Common::VectorSize<double>(sample_values).data(),
                                            sample_cnt, nrow));
Guolin Ke's avatar
Guolin Ke committed
689
  } else {
690
    ret.reset(new Dataset(nrow));
Guolin Ke's avatar
Guolin Ke committed
691
    ret->CreateValid(
692
      reinterpret_cast<const Dataset*>(reference));
Guolin Ke's avatar
Guolin Ke committed
693
  }
694
  OMP_INIT_EX();
Guolin Ke's avatar
Guolin Ke committed
695
  #pragma omp parallel for schedule(static)
Guolin Ke's avatar
Guolin Ke committed
696
  for (int i = 0; i < ncol_ptr - 1; ++i) {
697
    OMP_LOOP_EX_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
698
    const int tid = omp_get_thread_num();
Guolin Ke's avatar
Guolin Ke committed
699
    int feature_idx = ret->InnerFeatureIndex(i);
Guolin Ke's avatar
Guolin Ke committed
700
    if (feature_idx < 0) { continue; }
Guolin Ke's avatar
Guolin Ke committed
701
702
    int group = ret->Feature2Group(feature_idx);
    int sub_feature = ret->Feture2SubFeature(feature_idx);
Guolin Ke's avatar
Guolin Ke committed
703
704
705
706
707
708
709
    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
710
      ret->PushOneData(tid, row_idx, group, sub_feature, pair.second);
Guolin Ke's avatar
Guolin Ke committed
711
    }
712
    OMP_LOOP_EX_END();
Guolin Ke's avatar
Guolin Ke committed
713
  }
714
  OMP_THROW_EX();
Guolin Ke's avatar
Guolin Ke committed
715
  ret->FinishLoad();
Guolin Ke's avatar
Guolin Ke committed
716
  *out = ret.release();
717
  API_END();
Guolin Ke's avatar
Guolin Ke committed
718
719
}

Guolin Ke's avatar
Guolin Ke committed
720
int LGBM_DatasetGetSubset(
721
  const DatasetHandle handle,
wxchan's avatar
wxchan committed
722
723
724
  const int32_t* used_row_indices,
  int32_t num_used_row_indices,
  const char* parameters,
Guolin Ke's avatar
typo  
Guolin Ke committed
725
  DatasetHandle* out) {
wxchan's avatar
wxchan committed
726
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
727
728
  auto param = Config::Str2Map(parameters);
  Config config;
729
730
731
732
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
733
  auto full_dataset = reinterpret_cast<const Dataset*>(handle);
Guolin Ke's avatar
Guolin Ke committed
734
  CHECK(num_used_row_indices > 0);
735
736
737
  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
738
  auto ret = std::unique_ptr<Dataset>(new Dataset(num_used_row_indices));
739
  ret->CopyFeatureMapperFrom(full_dataset);
Guolin Ke's avatar
Guolin Ke committed
740
  ret->CopySubset(full_dataset, used_row_indices, num_used_row_indices, true);
wxchan's avatar
wxchan committed
741
742
743
744
  *out = ret.release();
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
745
int LGBM_DatasetSetFeatureNames(
Guolin Ke's avatar
typo  
Guolin Ke committed
746
  DatasetHandle handle,
Guolin Ke's avatar
Guolin Ke committed
747
  const char** feature_names,
Guolin Ke's avatar
Guolin Ke committed
748
  int num_feature_names) {
Guolin Ke's avatar
Guolin Ke committed
749
750
751
  API_BEGIN();
  auto dataset = reinterpret_cast<Dataset*>(handle);
  std::vector<std::string> feature_names_str;
Guolin Ke's avatar
Guolin Ke committed
752
  for (int i = 0; i < num_feature_names; ++i) {
Guolin Ke's avatar
Guolin Ke committed
753
754
755
756
757
758
    feature_names_str.emplace_back(feature_names[i]);
  }
  dataset->set_feature_names(feature_names_str);
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
759
int LGBM_DatasetGetFeatureNames(
760
761
  DatasetHandle handle,
  char** feature_names,
Guolin Ke's avatar
Guolin Ke committed
762
  int* num_feature_names) {
763
764
765
  API_BEGIN();
  auto dataset = reinterpret_cast<Dataset*>(handle);
  auto inside_feature_name = dataset->feature_names();
Guolin Ke's avatar
Guolin Ke committed
766
767
  *num_feature_names = static_cast<int>(inside_feature_name.size());
  for (int i = 0; i < *num_feature_names; ++i) {
Guolin Ke's avatar
Guolin Ke committed
768
    std::memcpy(feature_names[i], inside_feature_name[i].c_str(), inside_feature_name[i].size() + 1);
769
770
771
772
  }
  API_END();
}

773
#pragma warning(disable : 4702)
Guolin Ke's avatar
Guolin Ke committed
774
int LGBM_DatasetFree(DatasetHandle handle) {
775
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
776
  delete reinterpret_cast<Dataset*>(handle);
777
  API_END();
778
779
}

Guolin Ke's avatar
Guolin Ke committed
780
int LGBM_DatasetSaveBinary(DatasetHandle handle,
781
                           const char* filename) {
782
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
783
784
  auto dataset = reinterpret_cast<Dataset*>(handle);
  dataset->SaveBinaryFile(filename);
785
  API_END();
786
787
}

Guolin Ke's avatar
Guolin Ke committed
788
int LGBM_DatasetSetField(DatasetHandle handle,
789
790
791
792
                         const char* field_name,
                         const void* field_data,
                         int num_element,
                         int type) {
793
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
794
  auto dataset = reinterpret_cast<Dataset*>(handle);
795
  bool is_success = false;
Guolin Ke's avatar
Guolin Ke committed
796
  if (type == C_API_DTYPE_FLOAT32) {
Guolin Ke's avatar
Guolin Ke committed
797
    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
798
  } else if (type == C_API_DTYPE_INT32) {
Guolin Ke's avatar
Guolin Ke committed
799
    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
800
801
  } 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));
802
  }
803
  if (!is_success) { throw std::runtime_error("Input data type error or field not found"); }
804
  API_END();
805
806
}

Guolin Ke's avatar
Guolin Ke committed
807
int LGBM_DatasetGetField(DatasetHandle handle,
808
809
810
811
                         const char* field_name,
                         int* out_len,
                         const void** out_ptr,
                         int* out_type) {
812
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
813
  auto dataset = reinterpret_cast<Dataset*>(handle);
814
  bool is_success = false;
Guolin Ke's avatar
Guolin Ke committed
815
  if (dataset->GetFloatField(field_name, out_len, reinterpret_cast<const float**>(out_ptr))) {
Guolin Ke's avatar
Guolin Ke committed
816
    *out_type = C_API_DTYPE_FLOAT32;
817
    is_success = true;
Guolin Ke's avatar
Guolin Ke committed
818
  } else if (dataset->GetIntField(field_name, out_len, reinterpret_cast<const int**>(out_ptr))) {
Guolin Ke's avatar
Guolin Ke committed
819
    *out_type = C_API_DTYPE_INT32;
820
    is_success = true;
Guolin Ke's avatar
Guolin Ke committed
821
822
823
  } else if (dataset->GetDoubleField(field_name, out_len, reinterpret_cast<const double**>(out_ptr))) {
    *out_type = C_API_DTYPE_FLOAT64;
    is_success = true;
824
  }
825
  if (!is_success) { throw std::runtime_error("Field not found"); }
wxchan's avatar
wxchan committed
826
  if (*out_ptr == nullptr) { *out_len = 0; }
827
  API_END();
828
829
}

Guolin Ke's avatar
Guolin Ke committed
830
int LGBM_DatasetGetNumData(DatasetHandle handle,
831
                           int* out) {
832
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
833
834
  auto dataset = reinterpret_cast<Dataset*>(handle);
  *out = dataset->num_data();
835
  API_END();
836
837
}

Guolin Ke's avatar
Guolin Ke committed
838
int LGBM_DatasetGetNumFeature(DatasetHandle handle,
839
                              int* out) {
840
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
841
842
  auto dataset = reinterpret_cast<Dataset*>(handle);
  *out = dataset->num_total_features();
843
  API_END();
Guolin Ke's avatar
Guolin Ke committed
844
}
845
846
847

// ---- start of booster

Guolin Ke's avatar
Guolin Ke committed
848
int LGBM_BoosterCreate(const DatasetHandle train_data,
849
850
                       const char* parameters,
                       BoosterHandle* out) {
851
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
852
  const Dataset* p_train_data = reinterpret_cast<const Dataset*>(train_data);
wxchan's avatar
wxchan committed
853
854
  auto ret = std::unique_ptr<Booster>(new Booster(p_train_data, parameters));
  *out = ret.release();
855
  API_END();
856
857
}

Guolin Ke's avatar
Guolin Ke committed
858
int LGBM_BoosterCreateFromModelfile(
859
  const char* filename,
Guolin Ke's avatar
Guolin Ke committed
860
  int* out_num_iterations,
861
  BoosterHandle* out) {
862
  API_BEGIN();
wxchan's avatar
wxchan committed
863
  auto ret = std::unique_ptr<Booster>(new Booster(filename));
Guolin Ke's avatar
Guolin Ke committed
864
  *out_num_iterations = ret->GetBoosting()->GetCurrentIteration();
wxchan's avatar
wxchan committed
865
  *out = ret.release();
866
  API_END();
867
868
}

Guolin Ke's avatar
Guolin Ke committed
869
int LGBM_BoosterLoadModelFromString(
870
871
872
873
  const char* model_str,
  int* out_num_iterations,
  BoosterHandle* out) {
  API_BEGIN();
wxchan's avatar
wxchan committed
874
  auto ret = std::unique_ptr<Booster>(new Booster(nullptr));
875
876
877
878
879
880
  ret->LoadModelFromString(model_str);
  *out_num_iterations = ret->GetBoosting()->GetCurrentIteration();
  *out = ret.release();
  API_END();
}

881
#pragma warning(disable : 4702)
Guolin Ke's avatar
Guolin Ke committed
882
int LGBM_BoosterFree(BoosterHandle handle) {
883
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
884
  delete reinterpret_cast<Booster*>(handle);
885
  API_END();
886
887
}

Guolin Ke's avatar
Guolin Ke committed
888
int LGBM_BoosterMerge(BoosterHandle handle,
889
                      BoosterHandle other_handle) {
wxchan's avatar
wxchan committed
890
891
892
893
894
895
896
  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
897
int LGBM_BoosterAddValidData(BoosterHandle handle,
898
                             const DatasetHandle valid_data) {
wxchan's avatar
wxchan committed
899
900
901
902
903
904
905
  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
906
int LGBM_BoosterResetTrainingData(BoosterHandle handle,
907
                                  const DatasetHandle train_data) {
wxchan's avatar
wxchan committed
908
909
910
911
912
913
914
  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
915
int LGBM_BoosterResetParameter(BoosterHandle handle, const char* parameters) {
wxchan's avatar
wxchan committed
916
917
918
919
920
921
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  ref_booster->ResetConfig(parameters);
  API_END();
}

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

Guolin Ke's avatar
Guolin Ke committed
929
int LGBM_BoosterUpdateOneIter(BoosterHandle handle, int* is_finished) {
930
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
931
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
932
933
934
935
936
  if (ref_booster->TrainOneIter()) {
    *is_finished = 1;
  } else {
    *is_finished = 0;
  }
937
  API_END();
938
939
}

Guolin Ke's avatar
Guolin Ke committed
940
int LGBM_BoosterUpdateOneIterCustom(BoosterHandle handle,
941
942
943
                                    const float* grad,
                                    const float* hess,
                                    int* is_finished) {
944
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
945
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
946
  #ifdef SCORE_T_USE_DOUBLE
947
  Log::Fatal("Don't support custom loss function when SCORE_T_USE_DOUBLE is enabled");
948
  #else
949
950
951
952
953
  if (ref_booster->TrainOneIter(grad, hess)) {
    *is_finished = 1;
  } else {
    *is_finished = 0;
  }
954
  #endif
955
  API_END();
956
957
}

Guolin Ke's avatar
Guolin Ke committed
958
int LGBM_BoosterRollbackOneIter(BoosterHandle handle) {
wxchan's avatar
wxchan committed
959
960
961
962
963
964
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  ref_booster->RollbackOneIter();
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
965
int LGBM_BoosterGetCurrentIteration(BoosterHandle handle, int* out_iteration) {
wxchan's avatar
wxchan committed
966
967
968
969
970
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  *out_iteration = ref_booster->GetBoosting()->GetCurrentIteration();
  API_END();
}
Guolin Ke's avatar
Guolin Ke committed
971

Guolin Ke's avatar
Guolin Ke committed
972
int LGBM_BoosterGetEvalCounts(BoosterHandle handle, int* out_len) {
wxchan's avatar
wxchan committed
973
974
975
976
977
978
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  *out_len = ref_booster->GetEvalCounts();
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
979
int LGBM_BoosterGetEvalNames(BoosterHandle handle, int* out_len, char** out_strs) {
wxchan's avatar
wxchan committed
980
981
982
983
984
985
  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
986
int LGBM_BoosterGetFeatureNames(BoosterHandle handle, int* out_len, char** out_strs) {
wxchan's avatar
wxchan committed
987
988
989
990
991
992
  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
993
int LGBM_BoosterGetNumFeature(BoosterHandle handle, int* out_len) {
wxchan's avatar
wxchan committed
994
995
996
997
998
999
  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
1000
int LGBM_BoosterGetEval(BoosterHandle handle,
1001
1002
1003
                        int data_idx,
                        int* out_len,
                        double* out_results) {
1004
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1005
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
1006
  auto boosting = ref_booster->GetBoosting();
wxchan's avatar
wxchan committed
1007
  auto result_buf = boosting->GetEvalAt(data_idx);
Guolin Ke's avatar
Guolin Ke committed
1008
  *out_len = static_cast<int>(result_buf.size());
1009
  for (size_t i = 0; i < result_buf.size(); ++i) {
Guolin Ke's avatar
Guolin Ke committed
1010
    (out_results)[i] = static_cast<double>(result_buf[i]);
1011
  }
1012
  API_END();
1013
1014
}

Guolin Ke's avatar
Guolin Ke committed
1015
int LGBM_BoosterGetNumPredict(BoosterHandle handle,
1016
1017
                              int data_idx,
                              int64_t* out_len) {
Guolin Ke's avatar
Guolin Ke committed
1018
1019
1020
1021
1022
1023
  API_BEGIN();
  auto boosting = reinterpret_cast<Booster*>(handle)->GetBoosting();
  *out_len = boosting->GetNumPredictAt(data_idx);
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1024
int LGBM_BoosterGetPredict(BoosterHandle handle,
1025
1026
1027
                           int data_idx,
                           int64_t* out_len,
                           double* out_result) {
1028
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1029
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
1030
  ref_booster->GetPredictAt(data_idx, out_result, out_len);
1031
  API_END();
Guolin Ke's avatar
Guolin Ke committed
1032
1033
}

Guolin Ke's avatar
Guolin Ke committed
1034
int LGBM_BoosterPredictForFile(BoosterHandle handle,
1035
1036
1037
1038
                               const char* data_filename,
                               int data_has_header,
                               int predict_type,
                               int num_iteration,
1039
                               const char* parameter,
1040
                               const char* result_filename) {
1041
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1042
1043
  auto param = Config::Str2Map(parameter);
  Config config;
Guolin Ke's avatar
Guolin Ke committed
1044
1045
1046
1047
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
Guolin Ke's avatar
Guolin Ke committed
1048
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
cbecker's avatar
cbecker committed
1049
  ref_booster->Predict(num_iteration, predict_type, data_filename, data_has_header,
Guolin Ke's avatar
Guolin Ke committed
1050
                       config, result_filename);
1051
  API_END();
1052
1053
}

Guolin Ke's avatar
Guolin Ke committed
1054
int LGBM_BoosterCalcNumPredict(BoosterHandle handle,
1055
1056
1057
1058
                               int num_row,
                               int predict_type,
                               int num_iteration,
                               int64_t* out_len) {
Guolin Ke's avatar
Guolin Ke committed
1059
1060
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
Guolin Ke's avatar
Guolin Ke committed
1061
  *out_len = static_cast<int64_t>(num_row * ref_booster->GetBoosting()->NumPredictOneRow(
1062
    num_iteration, predict_type == C_API_PREDICT_LEAF_INDEX, predict_type == C_API_PREDICT_CONTRIB));
Guolin Ke's avatar
Guolin Ke committed
1063
1064
1065
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1066
int LGBM_BoosterPredictForCSR(BoosterHandle handle,
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
                              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,
1077
                              const char* parameter,
1078
1079
                              int64_t* out_len,
                              double* out_result) {
1080
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1081
1082
  auto param = Config::Str2Map(parameter);
  Config config;
Guolin Ke's avatar
Guolin Ke committed
1083
1084
1085
1086
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
Guolin Ke's avatar
Guolin Ke committed
1087
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
1088
  auto get_row_fun = RowFunctionFromCSR(indptr, indptr_type, indices, data, data_type, nindptr, nelem);
Guolin Ke's avatar
Guolin Ke committed
1089
  int nrow = static_cast<int>(nindptr - 1);
cbecker's avatar
cbecker committed
1090
  ref_booster->Predict(num_iteration, predict_type, nrow, get_row_fun,
Guolin Ke's avatar
Guolin Ke committed
1091
                       config, out_result, out_len);
1092
  API_END();
Guolin Ke's avatar
Guolin Ke committed
1093
}
1094

Guolin Ke's avatar
Guolin Ke committed
1095
int LGBM_BoosterPredictForCSC(BoosterHandle handle,
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
                              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,
1106
                              const char* parameter,
1107
1108
                              int64_t* out_len,
                              double* out_result) {
Guolin Ke's avatar
Guolin Ke committed
1109
1110
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
Guolin Ke's avatar
Guolin Ke committed
1111
1112
  auto param = Config::Str2Map(parameter);
  Config config;
Guolin Ke's avatar
Guolin Ke committed
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
  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
1123
  int ncol = static_cast<int>(ncol_ptr - 1);
Guolin Ke's avatar
Guolin Ke committed
1124
1125
1126
1127
1128
  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
1129
1130
  }
  std::function<std::vector<std::pair<int, double>>(int row_idx)> get_row_fun =
1131
    [&iterators, ncol] (int i) {
Guolin Ke's avatar
Guolin Ke committed
1132
    std::vector<std::pair<int, double>> one_row;
Guolin Ke's avatar
Guolin Ke committed
1133
    const int tid = omp_get_thread_num();
Guolin Ke's avatar
Guolin Ke committed
1134
    for (int j = 0; j < ncol; ++j) {
Guolin Ke's avatar
Guolin Ke committed
1135
      auto val = iterators[tid][j].Get(i);
Guolin Ke's avatar
Guolin Ke committed
1136
      if (std::fabs(val) > kZeroThreshold || std::isnan(val)) {
Guolin Ke's avatar
Guolin Ke committed
1137
        one_row.emplace_back(j, val);
Guolin Ke's avatar
Guolin Ke committed
1138
1139
      }
    }
Guolin Ke's avatar
Guolin Ke committed
1140
1141
    return one_row;
  };
Guolin Ke's avatar
Guolin Ke committed
1142
  ref_booster->Predict(num_iteration, predict_type, static_cast<int>(num_row), get_row_fun, config,
cbecker's avatar
cbecker committed
1143
                       out_result, out_len);
Guolin Ke's avatar
Guolin Ke committed
1144
1145
1146
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1147
int LGBM_BoosterPredictForMat(BoosterHandle handle,
1148
1149
1150
1151
1152
1153
1154
                              const void* data,
                              int data_type,
                              int32_t nrow,
                              int32_t ncol,
                              int is_row_major,
                              int predict_type,
                              int num_iteration,
1155
                              const char* parameter,
1156
1157
                              int64_t* out_len,
                              double* out_result) {
1158
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1159
1160
  auto param = Config::Str2Map(parameter);
  Config config;
Guolin Ke's avatar
Guolin Ke committed
1161
1162
1163
1164
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
Guolin Ke's avatar
Guolin Ke committed
1165
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
1166
  auto get_row_fun = RowPairFunctionFromDenseMatric(data, nrow, ncol, data_type, is_row_major);
cbecker's avatar
cbecker committed
1167
  ref_booster->Predict(num_iteration, predict_type, nrow, get_row_fun,
Guolin Ke's avatar
Guolin Ke committed
1168
                       config, out_result, out_len);
1169
  API_END();
Guolin Ke's avatar
Guolin Ke committed
1170
}
1171

Guolin Ke's avatar
Guolin Ke committed
1172
int LGBM_BoosterSaveModel(BoosterHandle handle,
1173
1174
                          int num_iteration,
                          const char* filename) {
1175
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1176
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
wxchan's avatar
wxchan committed
1177
1178
1179
1180
  ref_booster->SaveModelToFile(num_iteration, filename);
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1181
int LGBM_BoosterSaveModelToString(BoosterHandle handle,
1182
                                  int num_iteration,
1183
1184
                                  int64_t buffer_len, 
                                  int64_t* out_len,
1185
                                  char* out_str) {
1186
1187
1188
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  std::string model = ref_booster->SaveModelToString(num_iteration);
1189
  *out_len = static_cast<int64_t>(model.size()) + 1;
1190
  if (*out_len <= buffer_len) {
Guolin Ke's avatar
Guolin Ke committed
1191
    std::memcpy(out_str, model.c_str(), *out_len);
1192
1193
1194
1195
  }
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1196
int LGBM_BoosterDumpModel(BoosterHandle handle,
1197
                          int num_iteration,
1198
1199
                          int64_t buffer_len,
                          int64_t* out_len,
1200
                          char* out_str) {
wxchan's avatar
wxchan committed
1201
1202
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
1203
  std::string model = ref_booster->DumpModel(num_iteration);
1204
  *out_len = static_cast<int64_t>(model.size()) + 1;
wxchan's avatar
wxchan committed
1205
  if (*out_len <= buffer_len) {
Guolin Ke's avatar
Guolin Ke committed
1206
    std::memcpy(out_str, model.c_str(), *out_len);
wxchan's avatar
wxchan committed
1207
  }
1208
  API_END();
Guolin Ke's avatar
Guolin Ke committed
1209
}
1210

Guolin Ke's avatar
Guolin Ke committed
1211
int LGBM_BoosterGetLeafValue(BoosterHandle handle,
1212
1213
1214
                             int tree_idx,
                             int leaf_idx,
                             double* out_val) {
Guolin Ke's avatar
Guolin Ke committed
1215
1216
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
Guolin Ke's avatar
Guolin Ke committed
1217
  *out_val = static_cast<double>(ref_booster->GetLeafValue(tree_idx, leaf_idx));
Guolin Ke's avatar
Guolin Ke committed
1218
1219
1220
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1221
int LGBM_BoosterSetLeafValue(BoosterHandle handle,
1222
1223
1224
                             int tree_idx,
                             int leaf_idx,
                             double val) {
Guolin Ke's avatar
Guolin Ke committed
1225
1226
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
Guolin Ke's avatar
Guolin Ke committed
1227
  ref_booster->SetLeafValue(tree_idx, leaf_idx, val);
Guolin Ke's avatar
Guolin Ke committed
1228
1229
1230
  API_END();
}

1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
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();
}

1244
1245
1246
1247
1248
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
1249
  Config config;
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
  config.machines = Common::RemoveQuotationSymbol(std::string(machines));
  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();
}

1266
1267
1268
int LGBM_NetworkInitWithFunctions(int num_machines, int rank,
                                  void* reduce_scatter_ext_fun,
                                  void* allgather_ext_fun) {
ww's avatar
ww committed
1269
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1270
  if (num_machines > 1) {
1271
    Network::Init(num_machines, rank, (ReduceScatterFunction)reduce_scatter_ext_fun, (AllgatherFunction)allgather_ext_fun);
ww's avatar
ww committed
1272
1273
1274
  }
  API_END();
}
Guolin Ke's avatar
Guolin Ke committed
1275

Guolin Ke's avatar
Guolin Ke committed
1276
// ---- start of some help functions
1277
1278
1279

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
1280
  if (data_type == C_API_DTYPE_FLOAT32) {
1281
1282
    const float* data_ptr = reinterpret_cast<const float*>(data);
    if (is_row_major) {
1283
      return [data_ptr, num_col, num_row] (int row_idx) {
Guolin Ke's avatar
Guolin Ke committed
1284
        std::vector<double> ret(num_col);
1285
        auto tmp_ptr = data_ptr + static_cast<size_t>(num_col) * row_idx;
1286
        for (int i = 0; i < num_col; ++i) {
Guolin Ke's avatar
Guolin Ke committed
1287
          ret[i] = static_cast<double>(*(tmp_ptr + i));
1288
1289
1290
1291
        }
        return ret;
      };
    } else {
1292
      return [data_ptr, num_col, num_row] (int row_idx) {
Guolin Ke's avatar
Guolin Ke committed
1293
        std::vector<double> ret(num_col);
1294
        for (int i = 0; i < num_col; ++i) {
1295
          ret[i] = static_cast<double>(*(data_ptr + static_cast<size_t>(num_row) * i + row_idx));
1296
1297
1298
1299
        }
        return ret;
      };
    }
Guolin Ke's avatar
Guolin Ke committed
1300
  } else if (data_type == C_API_DTYPE_FLOAT64) {
1301
1302
    const double* data_ptr = reinterpret_cast<const double*>(data);
    if (is_row_major) {
1303
      return [data_ptr, num_col, num_row] (int row_idx) {
Guolin Ke's avatar
Guolin Ke committed
1304
        std::vector<double> ret(num_col);
1305
        auto tmp_ptr = data_ptr + static_cast<size_t>(num_col) * row_idx;
1306
        for (int i = 0; i < num_col; ++i) {
Guolin Ke's avatar
Guolin Ke committed
1307
          ret[i] = static_cast<double>(*(tmp_ptr + i));
1308
1309
1310
1311
        }
        return ret;
      };
    } else {
1312
      return [data_ptr, num_col, num_row] (int row_idx) {
Guolin Ke's avatar
Guolin Ke committed
1313
        std::vector<double> ret(num_col);
1314
        for (int i = 0; i < num_col; ++i) {
1315
          ret[i] = static_cast<double>(*(data_ptr + static_cast<size_t>(num_row) * i + row_idx));
1316
1317
1318
1319
1320
        }
        return ret;
      };
    }
  }
1321
  throw std::runtime_error("Unknown data type in RowFunctionFromDenseMatric");
1322
1323
1324
1325
}

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
1326
1327
  auto inner_function = RowFunctionFromDenseMatric(data, num_row, num_col, data_type, is_row_major);
  if (inner_function != nullptr) {
1328
    return [inner_function] (int row_idx) {
Guolin Ke's avatar
Guolin Ke committed
1329
1330
1331
      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
1332
        if (std::fabs(raw_values[i]) > kZeroThreshold || std::isnan(raw_values[i])) {
Guolin Ke's avatar
Guolin Ke committed
1333
          ret.emplace_back(i, raw_values[i]);
1334
        }
Guolin Ke's avatar
Guolin Ke committed
1335
1336
1337
      }
      return ret;
    };
1338
  }
Guolin Ke's avatar
Guolin Ke committed
1339
  return nullptr;
1340
1341
1342
1343
}

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
1344
  if (data_type == C_API_DTYPE_FLOAT32) {
1345
    const float* data_ptr = reinterpret_cast<const float*>(data);
Guolin Ke's avatar
Guolin Ke committed
1346
    if (indptr_type == C_API_DTYPE_INT32) {
1347
      const int32_t* ptr_indptr = reinterpret_cast<const int32_t*>(indptr);
1348
      return [ptr_indptr, indices, data_ptr, nindptr, nelem] (int idx) {
1349
1350
1351
        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
1352
        for (int64_t i = start; i < end; ++i) {
Guolin Ke's avatar
Guolin Ke committed
1353
          ret.emplace_back(indices[i], data_ptr[i]);
1354
1355
1356
        }
        return ret;
      };
Guolin Ke's avatar
Guolin Ke committed
1357
    } else if (indptr_type == C_API_DTYPE_INT64) {
1358
      const int64_t* ptr_indptr = reinterpret_cast<const int64_t*>(indptr);
1359
      return [ptr_indptr, indices, data_ptr, nindptr, nelem] (int idx) {
1360
1361
1362
        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
1363
        for (int64_t i = start; i < end; ++i) {
Guolin Ke's avatar
Guolin Ke committed
1364
          ret.emplace_back(indices[i], data_ptr[i]);
1365
1366
1367
1368
        }
        return ret;
      };
    }
Guolin Ke's avatar
Guolin Ke committed
1369
  } else if (data_type == C_API_DTYPE_FLOAT64) {
1370
    const double* data_ptr = reinterpret_cast<const double*>(data);
Guolin Ke's avatar
Guolin Ke committed
1371
    if (indptr_type == C_API_DTYPE_INT32) {
1372
      const int32_t* ptr_indptr = reinterpret_cast<const int32_t*>(indptr);
1373
      return [ptr_indptr, indices, data_ptr, nindptr, nelem] (int idx) {
1374
1375
1376
        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
1377
        for (int64_t i = start; i < end; ++i) {
Guolin Ke's avatar
Guolin Ke committed
1378
          ret.emplace_back(indices[i], data_ptr[i]);
1379
1380
1381
        }
        return ret;
      };
Guolin Ke's avatar
Guolin Ke committed
1382
    } else if (indptr_type == C_API_DTYPE_INT64) {
1383
      const int64_t* ptr_indptr = reinterpret_cast<const int64_t*>(indptr);
1384
      return [ptr_indptr, indices, data_ptr, nindptr, nelem] (int idx) {
1385
1386
1387
        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
1388
        for (int64_t i = start; i < end; ++i) {
Guolin Ke's avatar
Guolin Ke committed
1389
          ret.emplace_back(indices[i], data_ptr[i]);
1390
1391
1392
        }
        return ret;
      };
Guolin Ke's avatar
Guolin Ke committed
1393
1394
    }
  }
1395
  throw std::runtime_error("Unknown data type in RowFunctionFromCSR");
1396
1397
}

Guolin Ke's avatar
Guolin Ke committed
1398
1399
1400
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
1401
  if (data_type == C_API_DTYPE_FLOAT32) {
1402
    const float* data_ptr = reinterpret_cast<const float*>(data);
Guolin Ke's avatar
Guolin Ke committed
1403
    if (col_ptr_type == C_API_DTYPE_INT32) {
1404
      const int32_t* ptr_col_ptr = reinterpret_cast<const int32_t*>(col_ptr);
Guolin Ke's avatar
Guolin Ke committed
1405
1406
      int64_t start = ptr_col_ptr[col_idx];
      int64_t end = ptr_col_ptr[col_idx + 1];
1407
      return [ptr_col_ptr, indices, data_ptr, ncol_ptr, nelem, start, end] (int bias) {
Guolin Ke's avatar
Guolin Ke committed
1408
1409
1410
        int64_t i = static_cast<int64_t>(start + bias);
        if (i >= end) {
          return std::make_pair(-1, 0.0);
1411
        }
Guolin Ke's avatar
Guolin Ke committed
1412
1413
1414
        int idx = static_cast<int>(indices[i]);
        double val = static_cast<double>(data_ptr[i]);
        return std::make_pair(idx, val);
1415
      };
Guolin Ke's avatar
Guolin Ke committed
1416
    } else if (col_ptr_type == C_API_DTYPE_INT64) {
1417
      const int64_t* ptr_col_ptr = reinterpret_cast<const int64_t*>(col_ptr);
Guolin Ke's avatar
Guolin Ke committed
1418
1419
      int64_t start = ptr_col_ptr[col_idx];
      int64_t end = ptr_col_ptr[col_idx + 1];
1420
      return [ptr_col_ptr, indices, data_ptr, ncol_ptr, nelem, start, end] (int bias) {
Guolin Ke's avatar
Guolin Ke committed
1421
1422
1423
        int64_t i = static_cast<int64_t>(start + bias);
        if (i >= end) {
          return std::make_pair(-1, 0.0);
1424
        }
Guolin Ke's avatar
Guolin Ke committed
1425
1426
1427
        int idx = static_cast<int>(indices[i]);
        double val = static_cast<double>(data_ptr[i]);
        return std::make_pair(idx, val);
1428
      };
Guolin Ke's avatar
Guolin Ke committed
1429
    }
Guolin Ke's avatar
Guolin Ke committed
1430
  } else if (data_type == C_API_DTYPE_FLOAT64) {
1431
    const double* data_ptr = reinterpret_cast<const double*>(data);
Guolin Ke's avatar
Guolin Ke committed
1432
    if (col_ptr_type == C_API_DTYPE_INT32) {
1433
      const int32_t* ptr_col_ptr = reinterpret_cast<const int32_t*>(col_ptr);
Guolin Ke's avatar
Guolin Ke committed
1434
1435
      int64_t start = ptr_col_ptr[col_idx];
      int64_t end = ptr_col_ptr[col_idx + 1];
1436
      return [ptr_col_ptr, indices, data_ptr, ncol_ptr, nelem, start, end] (int bias) {
Guolin Ke's avatar
Guolin Ke committed
1437
1438
1439
        int64_t i = static_cast<int64_t>(start + bias);
        if (i >= end) {
          return std::make_pair(-1, 0.0);
1440
        }
Guolin Ke's avatar
Guolin Ke committed
1441
1442
1443
        int idx = static_cast<int>(indices[i]);
        double val = static_cast<double>(data_ptr[i]);
        return std::make_pair(idx, val);
1444
      };
Guolin Ke's avatar
Guolin Ke committed
1445
    } else if (col_ptr_type == C_API_DTYPE_INT64) {
1446
      const int64_t* ptr_col_ptr = reinterpret_cast<const int64_t*>(col_ptr);
Guolin Ke's avatar
Guolin Ke committed
1447
1448
      int64_t start = ptr_col_ptr[col_idx];
      int64_t end = ptr_col_ptr[col_idx + 1];
1449
      return [ptr_col_ptr, indices, data_ptr, ncol_ptr, nelem, start, end] (int bias) {
Guolin Ke's avatar
Guolin Ke committed
1450
1451
1452
        int64_t i = static_cast<int64_t>(start + bias);
        if (i >= end) {
          return std::make_pair(-1, 0.0);
1453
        }
Guolin Ke's avatar
Guolin Ke committed
1454
1455
1456
        int idx = static_cast<int>(indices[i]);
        double val = static_cast<double>(data_ptr[i]);
        return std::make_pair(idx, val);
1457
      };
Guolin Ke's avatar
Guolin Ke committed
1458
1459
    }
  }
1460
  throw std::runtime_error("Unknown data type in CSC matrix");
1461
1462
}

Guolin Ke's avatar
Guolin Ke committed
1463
CSC_RowIterator::CSC_RowIterator(const void* col_ptr, int col_ptr_type, const int32_t* indices,
1464
                                 const void* data, int data_type, int64_t ncol_ptr, int64_t nelem, int col_idx) {
Guolin Ke's avatar
Guolin Ke committed
1465
1466
1467
1468
1469
1470
1471
1472
1473
  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;
1474
    }
Guolin Ke's avatar
Guolin Ke committed
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
    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;
1492
    }
Guolin Ke's avatar
Guolin Ke committed
1493
1494
1495
    return ret;
  } else {
    return std::make_pair(-1, 0.0);
1496
  }
Guolin Ke's avatar
Guolin Ke committed
1497
}