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

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

#include <string>
23
24
#include <cstdio>
#include <functional>
Guolin Ke's avatar
Guolin Ke committed
25
#include <memory>
wxchan's avatar
wxchan committed
26
#include <mutex>
27
28
#include <stdexcept>
#include <vector>
Guolin Ke's avatar
Guolin Ke committed
29

30
#include "application/predictor.hpp"
Guolin Ke's avatar
Guolin Ke committed
31

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

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

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

50
51
52
53
54
55
56
57
const int PREDICTOR_TYPES = 4;

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

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

82
  ~SingleRowPredictor() {}
83

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

92
93
94
95
96
97
98
99
100
 private:
  std::unique_ptr<Predictor> predictor_;
  bool early_stop_;
  int early_stop_freq_;
  double early_stop_margin_;
  int iter_;
  int num_total_model_;
};

Guolin Ke's avatar
Guolin Ke committed
101
class Booster {
Nikita Titov's avatar
Nikita Titov committed
102
 public:
Guolin Ke's avatar
Guolin Ke committed
103
  explicit Booster(const char* filename) {
104
    boosting_.reset(Boosting::CreateBoosting("gbdt", filename));
105
106
  }

Guolin Ke's avatar
Guolin Ke committed
107
  Booster(const Dataset* train_data,
108
          const char* parameters) {
Guolin Ke's avatar
Guolin Ke committed
109
    auto param = Config::Str2Map(parameters);
wxchan's avatar
wxchan committed
110
    config_.Set(param);
111
112
113
    if (config_.num_threads > 0) {
      omp_set_num_threads(config_.num_threads);
    }
Guolin Ke's avatar
Guolin Ke committed
114
    // create boosting
Guolin Ke's avatar
Guolin Ke committed
115
    if (config_.input_model.size() > 0) {
116
117
      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
118
    }
Guolin Ke's avatar
Guolin Ke committed
119

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

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

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

  ~Booster() {
  }
143

144
  void CreateObjectiveAndMetrics() {
Guolin Ke's avatar
Guolin Ke committed
145
    // create objective function
Guolin Ke's avatar
Guolin Ke committed
146
147
    objective_fun_.reset(ObjectiveFunction::CreateObjectiveFunction(config_.objective,
                                                                    config_));
Guolin Ke's avatar
Guolin Ke committed
148
149
150
151
152
153
154
155
156
157
    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
158
    for (auto metric_type : config_.metric) {
Guolin Ke's avatar
Guolin Ke committed
159
      auto metric = std::unique_ptr<Metric>(
Guolin Ke's avatar
Guolin Ke committed
160
        Metric::CreateMetric(metric_type, config_));
Guolin Ke's avatar
Guolin Ke committed
161
162
163
164
165
      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();
166
167
168
169
170
171
172
173
174
175
176
  }

  void ResetTrainingData(const Dataset* train_data) {
    if (train_data != train_data_) {
      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
177
178
  }

179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
  static void CheckDatasetResetConfig(
      const Config& old_config,
      const std::unordered_map<std::string, std::string>& new_param) {
    Config new_config;
    new_config.Set(new_param);
    if (new_param.count("data_random_seed") &&
        new_config.data_random_seed != old_config.data_random_seed) {
      Log::Fatal("Cannot change data_random_seed after constructed Dataset handle.");
    }
    if (new_param.count("max_bin") &&
        new_config.max_bin != old_config.max_bin) {
      Log::Fatal("Cannot change max_bin after constructed Dataset handle.");
    }
    if (new_param.count("max_bin_by_feature") &&
        new_config.max_bin_by_feature != old_config.max_bin_by_feature) {
      Log::Fatal(
          "Cannot change max_bin_by_feature after constructed Dataset handle.");
    }
    if (new_param.count("bin_construct_sample_cnt") &&
        new_config.bin_construct_sample_cnt !=
            old_config.bin_construct_sample_cnt) {
      Log::Fatal(
          "Cannot change bin_construct_sample_cnt after constructed Dataset "
          "handle.");
    }
    if (new_param.count("min_data_in_bin") &&
        new_config.min_data_in_bin != old_config.min_data_in_bin) {
      Log::Fatal(
          "Cannot change min_data_in_bin after constructed Dataset handle.");
    }
    if (new_param.count("use_missing") &&
        new_config.use_missing != old_config.use_missing) {
      Log::Fatal("Cannot change use_missing after constructed Dataset handle.");
    }
    if (new_param.count("zero_as_missing") &&
        new_config.zero_as_missing != old_config.zero_as_missing) {
      Log::Fatal(
          "Cannot change zero_as_missing after constructed Dataset handle.");
    }
    if (new_param.count("categorical_feature") &&
        new_config.categorical_feature != old_config.categorical_feature) {
      Log::Fatal(
          "Cannot change categorical_feature after constructed Dataset "
          "handle.");
    }
    if (new_param.count("feature_pre_filter") &&
        new_config.feature_pre_filter != old_config.feature_pre_filter) {
      Log::Fatal(
          "Cannot change feature_pre_filter after constructed Dataset handle.");
    }
    if (new_param.count("is_enable_sparse") &&
        new_config.is_enable_sparse != old_config.is_enable_sparse) {
      Log::Fatal(
          "Cannot change is_enable_sparse after constructed Dataset handle.");
    }
    if (new_param.count("pre_partition") &&
        new_config.pre_partition != old_config.pre_partition) {
      Log::Fatal(
          "Cannot change pre_partition after constructed Dataset handle.");
    }
    if (new_param.count("enable_bundle") &&
        new_config.enable_bundle != old_config.enable_bundle) {
      Log::Fatal(
          "Cannot change enable_bundle after constructed Dataset handle.");
    }
    if (new_param.count("header") && new_config.header != old_config.header) {
      Log::Fatal("Cannot change header after constructed Dataset handle.");
    }
    if (new_param.count("two_round") &&
        new_config.two_round != old_config.two_round) {
      Log::Fatal("Cannot change two_round after constructed Dataset handle.");
    }
    if (new_param.count("label_column") &&
        new_config.label_column != old_config.label_column) {
      Log::Fatal(
          "Cannot change label_column after constructed Dataset handle.");
    }
    if (new_param.count("weight_column") &&
        new_config.weight_column != old_config.weight_column) {
      Log::Fatal(
          "Cannot change weight_column after constructed Dataset handle.");
    }
    if (new_param.count("group_column") &&
        new_config.group_column != old_config.group_column) {
      Log::Fatal(
          "Cannot change group_column after constructed Dataset handle.");
    }
    if (new_param.count("ignore_column") &&
        new_config.ignore_column != old_config.ignore_column) {
      Log::Fatal(
          "Cannot change ignore_column after constructed Dataset handle.");
    }
    if (new_param.count("forcedbins_filename")) {
      Log::Fatal("Cannot change forced bins after constructed Dataset handle.");
    }
    if (new_param.count("min_data_in_leaf") &&
        new_config.min_data_in_leaf < old_config.min_data_in_leaf &&
        old_config.feature_pre_filter) {
      Log::Fatal(
          "Reducing `min_data_in_leaf` with `feature_pre_filter=true` may "
          "cause unexpected behaviour "
          "for features that were pre-filtered by the larger "
          "`min_data_in_leaf`.\n"
          "You need to set `feature_pre_filter=false` to dynamically change "
          "the `min_data_in_leaf`.");
    }
  }

wxchan's avatar
wxchan committed
287
  void ResetConfig(const char* parameters) {
Guolin Ke's avatar
Guolin Ke committed
288
    std::lock_guard<std::mutex> lock(mutex_);
Guolin Ke's avatar
Guolin Ke committed
289
    auto param = Config::Str2Map(parameters);
wxchan's avatar
wxchan committed
290
    if (param.count("num_class")) {
291
      Log::Fatal("Cannot change num_class during training");
wxchan's avatar
wxchan committed
292
    }
Guolin Ke's avatar
Guolin Ke committed
293
294
    if (param.count("boosting")) {
      Log::Fatal("Cannot change boosting during training");
wxchan's avatar
wxchan committed
295
    }
Guolin Ke's avatar
Guolin Ke committed
296
    if (param.count("metric")) {
297
      Log::Fatal("Cannot change metric during training");
Guolin Ke's avatar
Guolin Ke committed
298
    }
299
300
    CheckDatasetResetConfig(config_, param);

Guolin Ke's avatar
Guolin Ke committed
301
    config_.Set(param);
302

303
304
305
    if (config_.num_threads > 0) {
      omp_set_num_threads(config_.num_threads);
    }
Guolin Ke's avatar
Guolin Ke committed
306
307
308

    if (param.count("objective")) {
      // create objective function
Guolin Ke's avatar
Guolin Ke committed
309
310
      objective_fun_.reset(ObjectiveFunction::CreateObjectiveFunction(config_.objective,
                                                                      config_));
Guolin Ke's avatar
Guolin Ke committed
311
312
313
314
315
316
317
      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());
      }
318
319
      boosting_->ResetTrainingData(train_data_,
                                   objective_fun_.get(), Common::ConstPtrInVectorWrapper<Metric>(train_metric_));
wxchan's avatar
wxchan committed
320
    }
Guolin Ke's avatar
Guolin Ke committed
321

Guolin Ke's avatar
Guolin Ke committed
322
    boosting_->ResetConfig(&config_);
wxchan's avatar
wxchan committed
323
324
325
326
327
  }

  void AddValidData(const Dataset* valid_data) {
    std::lock_guard<std::mutex> lock(mutex_);
    valid_metrics_.emplace_back();
Guolin Ke's avatar
Guolin Ke committed
328
329
    for (auto metric_type : config_.metric) {
      auto metric = std::unique_ptr<Metric>(Metric::CreateMetric(metric_type, config_));
wxchan's avatar
wxchan committed
330
331
332
333
334
335
      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,
336
                               Common::ConstPtrInVectorWrapper<Metric>(valid_metrics_.back()));
wxchan's avatar
wxchan committed
337
  }
Guolin Ke's avatar
Guolin Ke committed
338

339
  bool TrainOneIter() {
wxchan's avatar
wxchan committed
340
    std::lock_guard<std::mutex> lock(mutex_);
Guolin Ke's avatar
Guolin Ke committed
341
    return boosting_->TrainOneIter(nullptr, nullptr);
342
343
  }

Guolin Ke's avatar
Guolin Ke committed
344
345
346
347
348
349
350
351
352
353
354
  void Refit(const int32_t* leaf_preds, int32_t nrow, int32_t ncol) {
    std::lock_guard<std::mutex> lock(mutex_);
    std::vector<std::vector<int32_t>> v_leaf_preds(nrow, std::vector<int32_t>(ncol, 0));
    for (int i = 0; i < nrow; ++i) {
      for (int j = 0; j < ncol; ++j) {
        v_leaf_preds[i][j] = leaf_preds[i * ncol + j];
      }
    }
    boosting_->RefitTree(v_leaf_preds);
  }

355
  bool TrainOneIter(const score_t* gradients, const score_t* hessians) {
wxchan's avatar
wxchan committed
356
    std::lock_guard<std::mutex> lock(mutex_);
Guolin Ke's avatar
Guolin Ke committed
357
    return boosting_->TrainOneIter(gradients, hessians);
358
359
  }

wxchan's avatar
wxchan committed
360
361
362
363
364
  void RollbackOneIter() {
    std::lock_guard<std::mutex> lock(mutex_);
    boosting_->RollbackOneIter();
  }

365
  void PredictSingleRow(int num_iteration, int predict_type, int ncol,
366
367
368
               std::function<std::vector<std::pair<int, double>>(int row_idx)> get_row_fun,
               const Config& config,
               double* out_result, int64_t* out_len) {
369
370
371
    if (!config.predict_disable_shape_check && ncol != boosting_->MaxFeatureIdx() + 1) {
      Log::Fatal("The number of features in data (%d) is not the same as it was in training data (%d).\n"\
                 "You can set ``predict_disable_shape_check=true`` to discard this error, but please be aware what you are doing.", ncol, boosting_->MaxFeatureIdx() + 1);
372
    }
373
    std::lock_guard<std::mutex> lock(mutex_);
374
    if (single_row_predictor_[predict_type].get() == nullptr ||
Guolin Ke's avatar
Guolin Ke committed
375
376
        !single_row_predictor_[predict_type]->IsPredictorEqual(config, num_iteration, boosting_.get())) {
      single_row_predictor_[predict_type].reset(new SingleRowPredictor(predict_type, boosting_.get(),
377
                                                                       config, num_iteration));
378
379
380
    }
    auto one_row = get_row_fun(0);
    auto pred_wrt_ptr = out_result;
381
    single_row_predictor_[predict_type]->predict_function(one_row, pred_wrt_ptr);
382

383
    *out_len = single_row_predictor_[predict_type]->num_pred_in_one_row;
384
385
386
  }


387
  void Predict(int num_iteration, int predict_type, int nrow, int ncol,
Guolin Ke's avatar
Guolin Ke committed
388
               std::function<std::vector<std::pair<int, double>>(int row_idx)> get_row_fun,
Guolin Ke's avatar
Guolin Ke committed
389
               const Config& config,
Guolin Ke's avatar
Guolin Ke committed
390
               double* out_result, int64_t* out_len) {
391
392
393
    if (!config.predict_disable_shape_check && ncol != boosting_->MaxFeatureIdx() + 1) {
      Log::Fatal("The number of features in data (%d) is not the same as it was in training data (%d).\n" \
                 "You can set ``predict_disable_shape_check=true`` to discard this error, but please be aware what you are doing.", ncol, boosting_->MaxFeatureIdx() + 1);
394
    }
wxchan's avatar
wxchan committed
395
    std::lock_guard<std::mutex> lock(mutex_);
Guolin Ke's avatar
Guolin Ke committed
396
397
    bool is_predict_leaf = false;
    bool is_raw_score = false;
Guolin Ke's avatar
Guolin Ke committed
398
    bool predict_contrib = false;
Guolin Ke's avatar
Guolin Ke committed
399
    if (predict_type == C_API_PREDICT_LEAF_INDEX) {
Guolin Ke's avatar
Guolin Ke committed
400
      is_predict_leaf = true;
Guolin Ke's avatar
Guolin Ke committed
401
    } else if (predict_type == C_API_PREDICT_RAW_SCORE) {
Guolin Ke's avatar
Guolin Ke committed
402
      is_raw_score = true;
403
    } else if (predict_type == C_API_PREDICT_CONTRIB) {
Guolin Ke's avatar
Guolin Ke committed
404
      predict_contrib = true;
Guolin Ke's avatar
Guolin Ke committed
405
406
    } else {
      is_raw_score = false;
Guolin Ke's avatar
Guolin Ke committed
407
    }
Guolin Ke's avatar
Guolin Ke committed
408

Guolin Ke's avatar
Guolin Ke committed
409
    Predictor predictor(boosting_.get(), num_iteration, is_raw_score, is_predict_leaf, predict_contrib,
410
                        config.pred_early_stop, config.pred_early_stop_freq, config.pred_early_stop_margin);
Guolin Ke's avatar
Guolin Ke committed
411
    int64_t num_pred_in_one_row = boosting_->NumPredictOneRow(num_iteration, is_predict_leaf, predict_contrib);
Guolin Ke's avatar
Guolin Ke committed
412
    auto pred_fun = predictor.GetPredictFunction();
413
414
    OMP_INIT_EX();
    #pragma omp parallel for schedule(static)
Guolin Ke's avatar
Guolin Ke committed
415
    for (int i = 0; i < nrow; ++i) {
416
      OMP_LOOP_EX_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
417
      auto one_row = get_row_fun(i);
Tony-Y's avatar
Tony-Y committed
418
      auto pred_wrt_ptr = out_result + static_cast<size_t>(num_pred_in_one_row) * i;
Guolin Ke's avatar
Guolin Ke committed
419
      pred_fun(one_row, pred_wrt_ptr);
420
      OMP_LOOP_EX_END();
Guolin Ke's avatar
Guolin Ke committed
421
    }
422
    OMP_THROW_EX();
423
    *out_len = num_pred_in_one_row * nrow;
Guolin Ke's avatar
Guolin Ke committed
424
425
426
  }

  void Predict(int num_iteration, int predict_type, const char* data_filename,
Guolin Ke's avatar
Guolin Ke committed
427
               int data_has_header, const Config& config,
cbecker's avatar
cbecker committed
428
               const char* result_filename) {
Guolin Ke's avatar
Guolin Ke committed
429
430
431
    std::lock_guard<std::mutex> lock(mutex_);
    bool is_predict_leaf = false;
    bool is_raw_score = false;
Guolin Ke's avatar
Guolin Ke committed
432
    bool predict_contrib = false;
Guolin Ke's avatar
Guolin Ke committed
433
434
435
436
    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;
437
    } else if (predict_type == C_API_PREDICT_CONTRIB) {
Guolin Ke's avatar
Guolin Ke committed
438
      predict_contrib = true;
Guolin Ke's avatar
Guolin Ke committed
439
440
441
    } else {
      is_raw_score = false;
    }
Guolin Ke's avatar
Guolin Ke committed
442
    Predictor predictor(boosting_.get(), num_iteration, is_raw_score, is_predict_leaf, predict_contrib,
443
                        config.pred_early_stop, config.pred_early_stop_freq, config.pred_early_stop_margin);
Guolin Ke's avatar
Guolin Ke committed
444
    bool bool_data_has_header = data_has_header > 0 ? true : false;
445
    predictor.Predict(data_filename, result_filename, bool_data_has_header, config.predict_disable_shape_check);
Guolin Ke's avatar
Guolin Ke committed
446
447
  }

Guolin Ke's avatar
Guolin Ke committed
448
  void GetPredictAt(int data_idx, double* out_result, int64_t* out_len) {
wxchan's avatar
wxchan committed
449
450
451
    boosting_->GetPredictAt(data_idx, out_result, out_len);
  }

452
453
  void SaveModelToFile(int start_iteration, int num_iteration, const char* filename) {
    boosting_->SaveModelToFile(start_iteration, num_iteration, filename);
Guolin Ke's avatar
Guolin Ke committed
454
  }
455

456
  void LoadModelFromString(const char* model_str) {
457
458
    size_t len = std::strlen(model_str);
    boosting_->LoadModelFromString(model_str, len);
459
460
  }

461
462
  std::string SaveModelToString(int start_iteration, int num_iteration) {
    return boosting_->SaveModelToString(start_iteration, num_iteration);
463
464
  }

465
  std::string DumpModel(int start_iteration, int num_iteration) {
466
    return boosting_->DumpModel(start_iteration, num_iteration);
wxchan's avatar
wxchan committed
467
  }
468

469
470
471
472
  std::vector<double> FeatureImportance(int num_iteration, int importance_type) {
    return boosting_->FeatureImportance(num_iteration, importance_type);
  }

473
474
475
476
477
478
479
480
481
482
  double UpperBoundValue() const {
    std::lock_guard<std::mutex> lock(mutex_);
    return boosting_->GetUpperBoundValue();
  }

  double LowerBoundValue() const {
    std::lock_guard<std::mutex> lock(mutex_);
    return boosting_->GetLowerBoundValue();
  }

Guolin Ke's avatar
Guolin Ke committed
483
  double GetLeafValue(int tree_idx, int leaf_idx) const {
Guolin Ke's avatar
Guolin Ke committed
484
    return dynamic_cast<GBDTBase*>(boosting_.get())->GetLeafValue(tree_idx, leaf_idx);
Guolin Ke's avatar
Guolin Ke committed
485
486
487
488
  }

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

492
  void ShuffleModels(int start_iter, int end_iter) {
493
    std::lock_guard<std::mutex> lock(mutex_);
494
    boosting_->ShuffleModels(start_iter, end_iter);
495
496
  }

wxchan's avatar
wxchan committed
497
498
499
500
501
502
503
  int GetEvalCounts() const {
    int ret = 0;
    for (const auto& metric : train_metric_) {
      ret += static_cast<int>(metric->GetName().size());
    }
    return ret;
  }
504

wxchan's avatar
wxchan committed
505
506
507
508
  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
509
        std::memcpy(out_strs[idx], name.c_str(), name.size() + 1);
wxchan's avatar
wxchan committed
510
511
512
513
514
515
        ++idx;
      }
    }
    return idx;
  }

wxchan's avatar
wxchan committed
516
517
518
  int GetFeatureNames(char** out_strs) const {
    int idx = 0;
    for (const auto& name : boosting_->FeatureNames()) {
Guolin Ke's avatar
Guolin Ke committed
519
      std::memcpy(out_strs[idx], name.c_str(), name.size() + 1);
wxchan's avatar
wxchan committed
520
521
522
523
524
      ++idx;
    }
    return idx;
  }

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

Nikita Titov's avatar
Nikita Titov committed
527
 private:
wxchan's avatar
wxchan committed
528
  const Dataset* train_data_;
Guolin Ke's avatar
Guolin Ke committed
529
  std::unique_ptr<Boosting> boosting_;
530
  std::unique_ptr<SingleRowPredictor> single_row_predictor_[PREDICTOR_TYPES];
531

Guolin Ke's avatar
Guolin Ke committed
532
  /*! \brief All configs */
Guolin Ke's avatar
Guolin Ke committed
533
  Config config_;
Guolin Ke's avatar
Guolin Ke committed
534
  /*! \brief Metric for training data */
Guolin Ke's avatar
Guolin Ke committed
535
  std::vector<std::unique_ptr<Metric>> train_metric_;
Guolin Ke's avatar
Guolin Ke committed
536
  /*! \brief Metrics for validation data */
Guolin Ke's avatar
Guolin Ke committed
537
  std::vector<std::vector<std::unique_ptr<Metric>>> valid_metrics_;
Guolin Ke's avatar
Guolin Ke committed
538
  /*! \brief Training objective function */
Guolin Ke's avatar
Guolin Ke committed
539
  std::unique_ptr<ObjectiveFunction> objective_fun_;
wxchan's avatar
wxchan committed
540
  /*! \brief mutex for threading safe call */
541
  mutable std::mutex mutex_;
Guolin Ke's avatar
Guolin Ke committed
542
543
};

544
}  // namespace LightGBM
Guolin Ke's avatar
Guolin Ke committed
545
546
547

using namespace LightGBM;

Guolin Ke's avatar
Guolin Ke committed
548
549
550
551
552
553
554
555
// 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);

556
557
558
std::function<std::vector<std::pair<int, double>>(int row_idx)>
RowPairFunctionFromDenseRows(const void** data, int num_col, int data_type);

Guolin Ke's avatar
Guolin Ke committed
559
560
std::function<std::vector<std::pair<int, double>>(int idx)>
RowFunctionFromCSR(const void* indptr, int indptr_type, const int32_t* indices,
561
                   const void* data, int data_type, int64_t nindptr, int64_t nelem);
Guolin Ke's avatar
Guolin Ke committed
562
563
564

// Row iterator of on column for CSC matrix
class CSC_RowIterator {
Nikita Titov's avatar
Nikita Titov committed
565
 public:
Guolin Ke's avatar
Guolin Ke committed
566
  CSC_RowIterator(const void* col_ptr, int col_ptr_type, const int32_t* indices,
567
                  const void* data, int data_type, int64_t ncol_ptr, int64_t nelem, int col_idx);
Guolin Ke's avatar
Guolin Ke committed
568
569
570
571
572
  ~CSC_RowIterator() {}
  // return value at idx, only can access by ascent order
  double Get(int idx);
  // return next non-zero pair, if index < 0, means no more data
  std::pair<int, double> NextNonZero();
Nikita Titov's avatar
Nikita Titov committed
573
574

 private:
Guolin Ke's avatar
Guolin Ke committed
575
576
577
578
579
580
581
582
583
  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
584
const char* LGBM_GetLastError() {
wxchan's avatar
wxchan committed
585
  return LastErrorMsg();
Guolin Ke's avatar
Guolin Ke committed
586
587
}

Guolin Ke's avatar
Guolin Ke committed
588
int LGBM_DatasetCreateFromFile(const char* filename,
589
590
591
                               const char* parameters,
                               const DatasetHandle reference,
                               DatasetHandle* out) {
592
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
593
594
  auto param = Config::Str2Map(parameters);
  Config config;
595
596
597
598
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
599
  DatasetLoader loader(config, nullptr, 1, filename);
Guolin Ke's avatar
Guolin Ke committed
600
  if (reference == nullptr) {
601
    if (Network::num_machines() == 1) {
602
      *out = loader.LoadFromFile(filename);
603
    } else {
604
      *out = loader.LoadFromFile(filename, Network::rank(), Network::num_machines());
605
    }
Guolin Ke's avatar
Guolin Ke committed
606
  } else {
607
    *out = loader.LoadFromFileAlignWithOtherDataset(filename,
608
                                                    reinterpret_cast<const Dataset*>(reference));
Guolin Ke's avatar
Guolin Ke committed
609
  }
610
  API_END();
Guolin Ke's avatar
Guolin Ke committed
611
612
}

613

Guolin Ke's avatar
Guolin Ke committed
614
int LGBM_DatasetCreateFromSampledColumn(double** sample_data,
615
616
617
618
619
620
621
                                        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) {
622
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
623
624
  auto param = Config::Str2Map(parameters);
  Config config;
625
626
627
628
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
Guolin Ke's avatar
Guolin Ke committed
629
  DatasetLoader loader(config, nullptr, 1, nullptr);
630
631
632
633
  *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
634
635
}

636

Guolin Ke's avatar
Guolin Ke committed
637
int LGBM_DatasetCreateByReference(const DatasetHandle reference,
638
639
                                  int64_t num_total_row,
                                  DatasetHandle* out) {
Guolin Ke's avatar
Guolin Ke committed
640
641
642
643
644
645
646
647
  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
648
int LGBM_DatasetPushRows(DatasetHandle dataset,
649
650
651
652
653
                         const void* data,
                         int data_type,
                         int32_t nrow,
                         int32_t ncol,
                         int32_t start_row) {
Guolin Ke's avatar
Guolin Ke committed
654
655
656
  API_BEGIN();
  auto p_dataset = reinterpret_cast<Dataset*>(dataset);
  auto get_row_fun = RowFunctionFromDenseMatric(data, nrow, ncol, data_type, 1);
657
  OMP_INIT_EX();
Guolin Ke's avatar
Guolin Ke committed
658
  #pragma omp parallel for schedule(static)
Guolin Ke's avatar
Guolin Ke committed
659
  for (int i = 0; i < nrow; ++i) {
660
    OMP_LOOP_EX_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
661
662
663
    const int tid = omp_get_thread_num();
    auto one_row = get_row_fun(i);
    p_dataset->PushOneRow(tid, start_row + i, one_row);
664
    OMP_LOOP_EX_END();
Guolin Ke's avatar
Guolin Ke committed
665
  }
666
  OMP_THROW_EX();
Guolin Ke's avatar
Guolin Ke committed
667
668
669
670
671
672
  if (start_row + nrow == p_dataset->num_data()) {
    p_dataset->FinishLoad();
  }
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
673
int LGBM_DatasetPushRowsByCSR(DatasetHandle dataset,
674
675
676
677
678
679
680
681
682
                              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
683
684
685
686
  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);
687
  OMP_INIT_EX();
Guolin Ke's avatar
Guolin Ke committed
688
  #pragma omp parallel for schedule(static)
Guolin Ke's avatar
Guolin Ke committed
689
  for (int i = 0; i < nrow; ++i) {
690
    OMP_LOOP_EX_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
691
692
693
    const int tid = omp_get_thread_num();
    auto one_row = get_row_fun(i);
    p_dataset->PushOneRow(tid,
694
                          static_cast<data_size_t>(start_row + i), one_row);
695
    OMP_LOOP_EX_END();
Guolin Ke's avatar
Guolin Ke committed
696
  }
697
  OMP_THROW_EX();
Guolin Ke's avatar
Guolin Ke committed
698
699
700
701
702
703
  if (start_row + nrow == static_cast<int64_t>(p_dataset->num_data())) {
    p_dataset->FinishLoad();
  }
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
704
int LGBM_DatasetCreateFromMat(const void* data,
705
706
707
708
709
710
711
                              int data_type,
                              int32_t nrow,
                              int32_t ncol,
                              int is_row_major,
                              const char* parameters,
                              const DatasetHandle reference,
                              DatasetHandle* out) {
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
  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) {
733
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
734
735
  auto param = Config::Str2Map(parameters);
  Config config;
736
737
738
739
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
Guolin Ke's avatar
Guolin Ke committed
740
  std::unique_ptr<Dataset> ret;
741
742
743
744
745
746
747
748
749
  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));
  }
750

Guolin Ke's avatar
Guolin Ke committed
751
752
  if (reference == nullptr) {
    // sample data first
Guolin Ke's avatar
Guolin Ke committed
753
    Random rand(config.data_random_seed);
754
755
    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);
756
    sample_cnt = static_cast<int>(sample_indices.size());
757
    std::vector<std::vector<double>> sample_values(ncol);
Guolin Ke's avatar
Guolin Ke committed
758
    std::vector<std::vector<int>> sample_idx(ncol);
759
760
761

    int offset = 0;
    int j = 0;
Guolin Ke's avatar
Guolin Ke committed
762
    for (size_t i = 0; i < sample_indices.size(); ++i) {
Guolin Ke's avatar
Guolin Ke committed
763
      auto idx = sample_indices[i];
764
765
766
767
      while ((idx - offset) >= nrow[j]) {
        offset += nrow[j];
        ++j;
      }
768

769
770
771
772
773
      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
774
        }
Guolin Ke's avatar
Guolin Ke committed
775
776
      }
    }
Guolin Ke's avatar
Guolin Ke committed
777
    DatasetLoader loader(config, nullptr, 1, nullptr);
Guolin Ke's avatar
Guolin Ke committed
778
779
    ret.reset(loader.CostructFromSampleData(Common::Vector2Ptr<double>(&sample_values).data(),
                                            Common::Vector2Ptr<int>(&sample_idx).data(),
780
                                            ncol,
781
                                            Common::VectorSize<double>(sample_values).data(),
782
                                            sample_cnt, total_nrow));
Guolin Ke's avatar
Guolin Ke committed
783
  } else {
784
    ret.reset(new Dataset(total_nrow));
Guolin Ke's avatar
Guolin Ke committed
785
    ret->CreateValid(
786
      reinterpret_cast<const Dataset*>(reference));
Guolin Ke's avatar
Guolin Ke committed
787
  }
788
789
790
791
792
793
794
795
796
797
798
799
800
801
  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
802
803
  }
  ret->FinishLoad();
Guolin Ke's avatar
Guolin Ke committed
804
  *out = ret.release();
805
  API_END();
806
807
}

Guolin Ke's avatar
Guolin Ke committed
808
int LGBM_DatasetCreateFromCSR(const void* indptr,
809
810
811
812
813
814
815
816
817
818
                              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) {
819
  API_BEGIN();
820
821
822
823
824
  if (num_col <= 0) {
    Log::Fatal("The number of columns should be greater than zero.");
  } else if (num_col >= INT32_MAX) {
    Log::Fatal("The number of columns should be smaller than INT32_MAX.");
  }
Guolin Ke's avatar
Guolin Ke committed
825
826
  auto param = Config::Str2Map(parameters);
  Config config;
827
828
829
830
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
Guolin Ke's avatar
Guolin Ke committed
831
  std::unique_ptr<Dataset> ret;
832
  auto get_row_fun = RowFunctionFromCSR(indptr, indptr_type, indices, data, data_type, nindptr, nelem);
833
834
835
  int32_t nrow = static_cast<int32_t>(nindptr - 1);
  if (reference == nullptr) {
    // sample data first
Guolin Ke's avatar
Guolin Ke committed
836
837
    Random rand(config.data_random_seed);
    int sample_cnt = static_cast<int>(nrow < config.bin_construct_sample_cnt ? nrow : config.bin_construct_sample_cnt);
838
    auto sample_indices = rand.Sample(nrow, sample_cnt);
839
    sample_cnt = static_cast<int>(sample_indices.size());
Guolin Ke's avatar
Guolin Ke committed
840
841
    std::vector<std::vector<double>> sample_values(num_col);
    std::vector<std::vector<int>> sample_idx(num_col);
842
843
844
845
    for (size_t i = 0; i < sample_indices.size(); ++i) {
      auto idx = sample_indices[i];
      auto row = get_row_fun(static_cast<int>(idx));
      for (std::pair<int, double>& inner_data : row) {
Nikita Titov's avatar
Nikita Titov committed
846
        CHECK_LT(inner_data.first, num_col);
Guolin Ke's avatar
Guolin Ke committed
847
        if (std::fabs(inner_data.second) > kZeroThreshold || std::isnan(inner_data.second)) {
Guolin Ke's avatar
Guolin Ke committed
848
849
          sample_values[inner_data.first].emplace_back(inner_data.second);
          sample_idx[inner_data.first].emplace_back(static_cast<int>(i));
850
851
852
        }
      }
    }
Guolin Ke's avatar
Guolin Ke committed
853
    DatasetLoader loader(config, nullptr, 1, nullptr);
Guolin Ke's avatar
Guolin Ke committed
854
855
    ret.reset(loader.CostructFromSampleData(Common::Vector2Ptr<double>(&sample_values).data(),
                                            Common::Vector2Ptr<int>(&sample_idx).data(),
856
                                            static_cast<int>(num_col),
857
858
                                            Common::VectorSize<double>(sample_values).data(),
                                            sample_cnt, nrow));
859
  } else {
860
    ret.reset(new Dataset(nrow));
Guolin Ke's avatar
Guolin Ke committed
861
    ret->CreateValid(
862
      reinterpret_cast<const Dataset*>(reference));
863
  }
864
  OMP_INIT_EX();
Guolin Ke's avatar
Guolin Ke committed
865
  #pragma omp parallel for schedule(static)
866
  for (int i = 0; i < nindptr - 1; ++i) {
867
    OMP_LOOP_EX_BEGIN();
868
869
870
    const int tid = omp_get_thread_num();
    auto one_row = get_row_fun(i);
    ret->PushOneRow(tid, i, one_row);
871
    OMP_LOOP_EX_END();
872
  }
873
  OMP_THROW_EX();
874
  ret->FinishLoad();
Guolin Ke's avatar
Guolin Ke committed
875
  *out = ret.release();
876
  API_END();
877
878
}

879
int LGBM_DatasetCreateFromCSRFunc(void* get_row_funptr,
880
881
882
883
884
                                  int num_rows,
                                  int64_t num_col,
                                  const char* parameters,
                                  const DatasetHandle reference,
                                  DatasetHandle* out) {
885
  API_BEGIN();
886
887
888
889
890
  if (num_col <= 0) {
    Log::Fatal("The number of columns should be greater than zero.");
  } else if (num_col >= INT32_MAX) {
    Log::Fatal("The number of columns should be smaller than INT32_MAX.");
  }
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
  auto get_row_fun = *static_cast<std::function<void(int idx, std::vector<std::pair<int, double>>&)>*>(get_row_funptr);
  auto param = Config::Str2Map(parameters);
  Config config;
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
  std::unique_ptr<Dataset> ret;
  int32_t nrow = num_rows;
  if (reference == nullptr) {
    // sample data first
    Random rand(config.data_random_seed);
    int sample_cnt = static_cast<int>(nrow < config.bin_construct_sample_cnt ? nrow : config.bin_construct_sample_cnt);
    auto sample_indices = rand.Sample(nrow, sample_cnt);
    sample_cnt = static_cast<int>(sample_indices.size());
    std::vector<std::vector<double>> sample_values(num_col);
    std::vector<std::vector<int>> sample_idx(num_col);
    // local buffer to re-use memory
    std::vector<std::pair<int, double>> buffer;
    for (size_t i = 0; i < sample_indices.size(); ++i) {
      auto idx = sample_indices[i];
      get_row_fun(static_cast<int>(idx), buffer);
      for (std::pair<int, double>& inner_data : buffer) {
Nikita Titov's avatar
Nikita Titov committed
914
        CHECK_LT(inner_data.first, num_col);
915
916
917
918
919
920
921
        if (std::fabs(inner_data.second) > kZeroThreshold || std::isnan(inner_data.second)) {
          sample_values[inner_data.first].emplace_back(inner_data.second);
          sample_idx[inner_data.first].emplace_back(static_cast<int>(i));
        }
      }
    }
    DatasetLoader loader(config, nullptr, 1, nullptr);
Guolin Ke's avatar
Guolin Ke committed
922
923
    ret.reset(loader.CostructFromSampleData(Common::Vector2Ptr<double>(&sample_values).data(),
                                            Common::Vector2Ptr<int>(&sample_idx).data(),
924
                                            static_cast<int>(num_col),
925
926
927
928
929
930
931
                                            Common::VectorSize<double>(sample_values).data(),
                                            sample_cnt, nrow));
  } else {
    ret.reset(new Dataset(nrow));
    ret->CreateValid(
      reinterpret_cast<const Dataset*>(reference));
  }
932

933
  OMP_INIT_EX();
Guolin Ke's avatar
Guolin Ke committed
934
935
  std::vector<std::pair<int, double>> thread_buffer;
  #pragma omp parallel for schedule(static) private(thread_buffer)
936
937
938
  for (int i = 0; i < num_rows; ++i) {
    OMP_LOOP_EX_BEGIN();
    {
939
      const int tid = omp_get_thread_num();
Guolin Ke's avatar
Guolin Ke committed
940
941
      get_row_fun(i, thread_buffer);
      ret->PushOneRow(tid, i, thread_buffer);
942
943
944
945
946
947
948
949
950
    }
    OMP_LOOP_EX_END();
  }
  OMP_THROW_EX();
  ret->FinishLoad();
  *out = ret.release();
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
951
int LGBM_DatasetCreateFromCSC(const void* col_ptr,
952
953
954
955
956
957
958
959
960
961
                              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) {
962
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
963
964
  auto param = Config::Str2Map(parameters);
  Config config;
965
966
967
968
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
Guolin Ke's avatar
Guolin Ke committed
969
  std::unique_ptr<Dataset> ret;
Guolin Ke's avatar
Guolin Ke committed
970
971
972
  int32_t nrow = static_cast<int32_t>(num_row);
  if (reference == nullptr) {
    // sample data first
Guolin Ke's avatar
Guolin Ke committed
973
974
    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
975
    auto sample_indices = rand.Sample(nrow, sample_cnt);
976
    sample_cnt = static_cast<int>(sample_indices.size());
Guolin Ke's avatar
Guolin Ke committed
977
    std::vector<std::vector<double>> sample_values(ncol_ptr - 1);
Guolin Ke's avatar
Guolin Ke committed
978
    std::vector<std::vector<int>> sample_idx(ncol_ptr - 1);
979
    OMP_INIT_EX();
Guolin Ke's avatar
Guolin Ke committed
980
    #pragma omp parallel for schedule(static)
Guolin Ke's avatar
Guolin Ke committed
981
    for (int i = 0; i < static_cast<int>(sample_values.size()); ++i) {
982
      OMP_LOOP_EX_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
983
984
985
      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
986
        if (std::fabs(val) > kZeroThreshold || std::isnan(val)) {
Guolin Ke's avatar
Guolin Ke committed
987
988
          sample_values[i].emplace_back(val);
          sample_idx[i].emplace_back(j);
Guolin Ke's avatar
Guolin Ke committed
989
990
        }
      }
991
      OMP_LOOP_EX_END();
Guolin Ke's avatar
Guolin Ke committed
992
    }
993
    OMP_THROW_EX();
Guolin Ke's avatar
Guolin Ke committed
994
    DatasetLoader loader(config, nullptr, 1, nullptr);
Guolin Ke's avatar
Guolin Ke committed
995
996
    ret.reset(loader.CostructFromSampleData(Common::Vector2Ptr<double>(&sample_values).data(),
                                            Common::Vector2Ptr<int>(&sample_idx).data(),
997
998
999
                                            static_cast<int>(sample_values.size()),
                                            Common::VectorSize<double>(sample_values).data(),
                                            sample_cnt, nrow));
Guolin Ke's avatar
Guolin Ke committed
1000
  } else {
1001
    ret.reset(new Dataset(nrow));
Guolin Ke's avatar
Guolin Ke committed
1002
    ret->CreateValid(
1003
      reinterpret_cast<const Dataset*>(reference));
Guolin Ke's avatar
Guolin Ke committed
1004
  }
1005
  OMP_INIT_EX();
Guolin Ke's avatar
Guolin Ke committed
1006
  #pragma omp parallel for schedule(static)
Guolin Ke's avatar
Guolin Ke committed
1007
  for (int i = 0; i < ncol_ptr - 1; ++i) {
1008
    OMP_LOOP_EX_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1009
    const int tid = omp_get_thread_num();
Guolin Ke's avatar
Guolin Ke committed
1010
    int feature_idx = ret->InnerFeatureIndex(i);
Guolin Ke's avatar
Guolin Ke committed
1011
    if (feature_idx < 0) { continue; }
Guolin Ke's avatar
Guolin Ke committed
1012
1013
    int group = ret->Feature2Group(feature_idx);
    int sub_feature = ret->Feture2SubFeature(feature_idx);
Guolin Ke's avatar
Guolin Ke committed
1014
    CSC_RowIterator col_it(col_ptr, col_ptr_type, indices, data, data_type, ncol_ptr, nelem, i);
Guolin Ke's avatar
Guolin Ke committed
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
    auto bin_mapper = ret->FeatureBinMapper(feature_idx);
    if (bin_mapper->GetDefaultBin() == bin_mapper->GetMostFreqBin()) {
      int row_idx = 0;
      while (row_idx < nrow) {
        auto pair = col_it.NextNonZero();
        row_idx = pair.first;
        // no more data
        if (row_idx < 0) { break; }
        ret->PushOneData(tid, row_idx, group, sub_feature, pair.second);
      }
    } else {
      for (int row_idx = 0; row_idx < nrow; ++row_idx) {
        auto val = col_it.Get(row_idx);
        ret->PushOneData(tid, row_idx, group, sub_feature, val);
      }
Guolin Ke's avatar
Guolin Ke committed
1030
    }
1031
    OMP_LOOP_EX_END();
Guolin Ke's avatar
Guolin Ke committed
1032
  }
1033
  OMP_THROW_EX();
Guolin Ke's avatar
Guolin Ke committed
1034
  ret->FinishLoad();
Guolin Ke's avatar
Guolin Ke committed
1035
  *out = ret.release();
1036
  API_END();
Guolin Ke's avatar
Guolin Ke committed
1037
1038
}

Guolin Ke's avatar
Guolin Ke committed
1039
int LGBM_DatasetGetSubset(
1040
  const DatasetHandle handle,
wxchan's avatar
wxchan committed
1041
1042
1043
  const int32_t* used_row_indices,
  int32_t num_used_row_indices,
  const char* parameters,
Guolin Ke's avatar
typo  
Guolin Ke committed
1044
  DatasetHandle* out) {
wxchan's avatar
wxchan committed
1045
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1046
1047
  auto param = Config::Str2Map(parameters);
  Config config;
1048
1049
1050
1051
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
1052
  auto full_dataset = reinterpret_cast<const Dataset*>(handle);
1053
  CHECK_GT(num_used_row_indices, 0);
1054
1055
1056
  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");
1057
1058
1059
  if (!std::is_sorted(used_row_indices, used_row_indices + num_used_row_indices)) {
    Log::Fatal("used_row_indices should be sorted in Subset");
  }
Guolin Ke's avatar
Guolin Ke committed
1060
  auto ret = std::unique_ptr<Dataset>(new Dataset(num_used_row_indices));
1061
  ret->CopyFeatureMapperFrom(full_dataset);
1062
  ret->CopySubrow(full_dataset, used_row_indices, num_used_row_indices, true);
wxchan's avatar
wxchan committed
1063
1064
1065
1066
  *out = ret.release();
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1067
int LGBM_DatasetSetFeatureNames(
Guolin Ke's avatar
typo  
Guolin Ke committed
1068
  DatasetHandle handle,
Guolin Ke's avatar
Guolin Ke committed
1069
  const char** feature_names,
Guolin Ke's avatar
Guolin Ke committed
1070
  int num_feature_names) {
Guolin Ke's avatar
Guolin Ke committed
1071
1072
1073
  API_BEGIN();
  auto dataset = reinterpret_cast<Dataset*>(handle);
  std::vector<std::string> feature_names_str;
Guolin Ke's avatar
Guolin Ke committed
1074
  for (int i = 0; i < num_feature_names; ++i) {
Guolin Ke's avatar
Guolin Ke committed
1075
1076
1077
1078
1079
1080
    feature_names_str.emplace_back(feature_names[i]);
  }
  dataset->set_feature_names(feature_names_str);
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1081
int LGBM_DatasetGetFeatureNames(
1082
1083
  DatasetHandle handle,
  char** feature_names,
Guolin Ke's avatar
Guolin Ke committed
1084
  int* num_feature_names) {
1085
1086
1087
  API_BEGIN();
  auto dataset = reinterpret_cast<Dataset*>(handle);
  auto inside_feature_name = dataset->feature_names();
Guolin Ke's avatar
Guolin Ke committed
1088
1089
  *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
1090
    std::memcpy(feature_names[i], inside_feature_name[i].c_str(), inside_feature_name[i].size() + 1);
1091
1092
1093
1094
  }
  API_END();
}

1095
1096
1097
#ifdef _MSC_VER
  #pragma warning(disable : 4702)
#endif
Guolin Ke's avatar
Guolin Ke committed
1098
int LGBM_DatasetFree(DatasetHandle handle) {
1099
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1100
  delete reinterpret_cast<Dataset*>(handle);
1101
  API_END();
1102
1103
}

Guolin Ke's avatar
Guolin Ke committed
1104
int LGBM_DatasetSaveBinary(DatasetHandle handle,
1105
                           const char* filename) {
1106
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1107
1108
  auto dataset = reinterpret_cast<Dataset*>(handle);
  dataset->SaveBinaryFile(filename);
1109
  API_END();
1110
1111
}

1112
1113
1114
1115
1116
1117
1118
1119
int LGBM_DatasetDumpText(DatasetHandle handle,
                         const char* filename) {
  API_BEGIN();
  auto dataset = reinterpret_cast<Dataset*>(handle);
  dataset->DumpTextFile(filename);
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1120
int LGBM_DatasetSetField(DatasetHandle handle,
1121
1122
1123
1124
                         const char* field_name,
                         const void* field_data,
                         int num_element,
                         int type) {
1125
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1126
  auto dataset = reinterpret_cast<Dataset*>(handle);
1127
  bool is_success = false;
Guolin Ke's avatar
Guolin Ke committed
1128
  if (type == C_API_DTYPE_FLOAT32) {
Guolin Ke's avatar
Guolin Ke committed
1129
    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
1130
  } else if (type == C_API_DTYPE_INT32) {
Guolin Ke's avatar
Guolin Ke committed
1131
    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
1132
1133
  } 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));
1134
  }
1135
  if (!is_success) { Log::Fatal("Input data type error or field not found"); }
1136
  API_END();
1137
1138
}

Guolin Ke's avatar
Guolin Ke committed
1139
int LGBM_DatasetGetField(DatasetHandle handle,
1140
1141
1142
1143
                         const char* field_name,
                         int* out_len,
                         const void** out_ptr,
                         int* out_type) {
1144
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1145
  auto dataset = reinterpret_cast<Dataset*>(handle);
1146
  bool is_success = false;
Guolin Ke's avatar
Guolin Ke committed
1147
  if (dataset->GetFloatField(field_name, out_len, reinterpret_cast<const float**>(out_ptr))) {
Guolin Ke's avatar
Guolin Ke committed
1148
    *out_type = C_API_DTYPE_FLOAT32;
1149
    is_success = true;
Guolin Ke's avatar
Guolin Ke committed
1150
  } else if (dataset->GetIntField(field_name, out_len, reinterpret_cast<const int**>(out_ptr))) {
Guolin Ke's avatar
Guolin Ke committed
1151
    *out_type = C_API_DTYPE_INT32;
1152
    is_success = true;
Guolin Ke's avatar
Guolin Ke committed
1153
1154
1155
  } else if (dataset->GetDoubleField(field_name, out_len, reinterpret_cast<const double**>(out_ptr))) {
    *out_type = C_API_DTYPE_FLOAT64;
    is_success = true;
Nikita Titov's avatar
Nikita Titov committed
1156
  }
1157
  if (!is_success) { Log::Fatal("Field not found"); }
wxchan's avatar
wxchan committed
1158
  if (*out_ptr == nullptr) { *out_len = 0; }
1159
  API_END();
1160
1161
}

1162
int LGBM_DatasetUpdateParamChecking(const char* old_parameters, const char* new_parameters) {
1163
  API_BEGIN();
1164
1165
1166
1167
1168
  auto old_param = Config::Str2Map(old_parameters);
  Config old_config;
  old_config.Set(old_param);
  auto new_param = Config::Str2Map(new_parameters);
  Booster::CheckDatasetResetConfig(old_config, new_param);
1169
1170
1171
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1172
int LGBM_DatasetGetNumData(DatasetHandle handle,
1173
                           int* out) {
1174
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1175
1176
  auto dataset = reinterpret_cast<Dataset*>(handle);
  *out = dataset->num_data();
1177
  API_END();
1178
1179
}

Guolin Ke's avatar
Guolin Ke committed
1180
int LGBM_DatasetGetNumFeature(DatasetHandle handle,
1181
                              int* out) {
1182
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1183
1184
  auto dataset = reinterpret_cast<Dataset*>(handle);
  *out = dataset->num_total_features();
1185
  API_END();
Guolin Ke's avatar
Guolin Ke committed
1186
}
1187

1188
1189
1190
1191
1192
int LGBM_DatasetAddFeaturesFrom(DatasetHandle target,
                                DatasetHandle source) {
  API_BEGIN();
  auto target_d = reinterpret_cast<Dataset*>(target);
  auto source_d = reinterpret_cast<Dataset*>(source);
1193
  target_d->AddFeaturesFrom(source_d);
1194
1195
1196
  API_END();
}

1197
1198
// ---- start of booster

Guolin Ke's avatar
Guolin Ke committed
1199
int LGBM_BoosterCreate(const DatasetHandle train_data,
1200
1201
                       const char* parameters,
                       BoosterHandle* out) {
1202
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1203
  const Dataset* p_train_data = reinterpret_cast<const Dataset*>(train_data);
wxchan's avatar
wxchan committed
1204
1205
  auto ret = std::unique_ptr<Booster>(new Booster(p_train_data, parameters));
  *out = ret.release();
1206
  API_END();
1207
1208
}

Guolin Ke's avatar
Guolin Ke committed
1209
int LGBM_BoosterCreateFromModelfile(
1210
  const char* filename,
Guolin Ke's avatar
Guolin Ke committed
1211
  int* out_num_iterations,
1212
  BoosterHandle* out) {
1213
  API_BEGIN();
1214
  LocaleContext withLocaleContext("C");
wxchan's avatar
wxchan committed
1215
  auto ret = std::unique_ptr<Booster>(new Booster(filename));
Guolin Ke's avatar
Guolin Ke committed
1216
  *out_num_iterations = ret->GetBoosting()->GetCurrentIteration();
wxchan's avatar
wxchan committed
1217
  *out = ret.release();
1218
  API_END();
1219
1220
}

Guolin Ke's avatar
Guolin Ke committed
1221
int LGBM_BoosterLoadModelFromString(
1222
1223
1224
1225
  const char* model_str,
  int* out_num_iterations,
  BoosterHandle* out) {
  API_BEGIN();
1226
  LocaleContext withLocaleContext("C");
wxchan's avatar
wxchan committed
1227
  auto ret = std::unique_ptr<Booster>(new Booster(nullptr));
1228
1229
1230
1231
1232
1233
  ret->LoadModelFromString(model_str);
  *out_num_iterations = ret->GetBoosting()->GetCurrentIteration();
  *out = ret.release();
  API_END();
}

1234
1235
1236
#ifdef _MSC_VER
  #pragma warning(disable : 4702)
#endif
Guolin Ke's avatar
Guolin Ke committed
1237
int LGBM_BoosterFree(BoosterHandle handle) {
1238
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1239
  delete reinterpret_cast<Booster*>(handle);
1240
  API_END();
1241
1242
}

1243
int LGBM_BoosterShuffleModels(BoosterHandle handle, int start_iter, int end_iter) {
1244
1245
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
1246
  ref_booster->ShuffleModels(start_iter, end_iter);
1247
1248
1249
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1250
int LGBM_BoosterMerge(BoosterHandle handle,
1251
                      BoosterHandle other_handle) {
wxchan's avatar
wxchan committed
1252
1253
1254
1255
1256
1257
1258
  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
1259
int LGBM_BoosterAddValidData(BoosterHandle handle,
1260
                             const DatasetHandle valid_data) {
wxchan's avatar
wxchan committed
1261
1262
1263
1264
1265
1266
1267
  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
1268
int LGBM_BoosterResetTrainingData(BoosterHandle handle,
1269
                                  const DatasetHandle train_data) {
wxchan's avatar
wxchan committed
1270
1271
1272
1273
1274
1275
1276
  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
1277
int LGBM_BoosterResetParameter(BoosterHandle handle, const char* parameters) {
wxchan's avatar
wxchan committed
1278
1279
1280
1281
1282
1283
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  ref_booster->ResetConfig(parameters);
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1284
int LGBM_BoosterGetNumClasses(BoosterHandle handle, int* out_len) {
wxchan's avatar
wxchan committed
1285
1286
1287
1288
1289
1290
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  *out_len = ref_booster->GetBoosting()->NumberOfClasses();
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1291
1292
1293
1294
1295
1296
1297
int LGBM_BoosterRefit(BoosterHandle handle, const int32_t* leaf_preds, int32_t nrow, int32_t ncol) {
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  ref_booster->Refit(leaf_preds, nrow, ncol);
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1298
int LGBM_BoosterUpdateOneIter(BoosterHandle handle, int* is_finished) {
1299
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1300
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
1301
1302
1303
1304
1305
  if (ref_booster->TrainOneIter()) {
    *is_finished = 1;
  } else {
    *is_finished = 0;
  }
1306
  API_END();
1307
1308
}

Guolin Ke's avatar
Guolin Ke committed
1309
int LGBM_BoosterUpdateOneIterCustom(BoosterHandle handle,
1310
1311
1312
                                    const float* grad,
                                    const float* hess,
                                    int* is_finished) {
1313
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1314
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
1315
  #ifdef SCORE_T_USE_DOUBLE
1316
  Log::Fatal("Don't support custom loss function when SCORE_T_USE_DOUBLE is enabled");
1317
  #else
1318
1319
1320
1321
1322
  if (ref_booster->TrainOneIter(grad, hess)) {
    *is_finished = 1;
  } else {
    *is_finished = 0;
  }
1323
  #endif
1324
  API_END();
1325
1326
}

Guolin Ke's avatar
Guolin Ke committed
1327
int LGBM_BoosterRollbackOneIter(BoosterHandle handle) {
wxchan's avatar
wxchan committed
1328
1329
1330
1331
1332
1333
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  ref_booster->RollbackOneIter();
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1334
int LGBM_BoosterGetCurrentIteration(BoosterHandle handle, int* out_iteration) {
wxchan's avatar
wxchan committed
1335
1336
1337
1338
1339
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  *out_iteration = ref_booster->GetBoosting()->GetCurrentIteration();
  API_END();
}
Guolin Ke's avatar
Guolin Ke committed
1340

1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
int LGBM_BoosterNumModelPerIteration(BoosterHandle handle, int* out_tree_per_iteration) {
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  *out_tree_per_iteration = ref_booster->GetBoosting()->NumModelPerIteration();
  API_END();
}

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

Guolin Ke's avatar
Guolin Ke committed
1355
int LGBM_BoosterGetEvalCounts(BoosterHandle handle, int* out_len) {
wxchan's avatar
wxchan committed
1356
1357
1358
1359
1360
1361
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  *out_len = ref_booster->GetEvalCounts();
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1362
int LGBM_BoosterGetEvalNames(BoosterHandle handle, int* out_len, char** out_strs) {
wxchan's avatar
wxchan committed
1363
1364
1365
1366
1367
1368
  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
1369
int LGBM_BoosterGetFeatureNames(BoosterHandle handle, int* out_len, char** out_strs) {
wxchan's avatar
wxchan committed
1370
1371
1372
1373
1374
1375
  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
1376
int LGBM_BoosterGetNumFeature(BoosterHandle handle, int* out_len) {
wxchan's avatar
wxchan committed
1377
1378
1379
1380
1381
1382
  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
1383
int LGBM_BoosterGetEval(BoosterHandle handle,
1384
1385
1386
                        int data_idx,
                        int* out_len,
                        double* out_results) {
1387
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1388
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
1389
  auto boosting = ref_booster->GetBoosting();
wxchan's avatar
wxchan committed
1390
  auto result_buf = boosting->GetEvalAt(data_idx);
Guolin Ke's avatar
Guolin Ke committed
1391
  *out_len = static_cast<int>(result_buf.size());
1392
  for (size_t i = 0; i < result_buf.size(); ++i) {
Guolin Ke's avatar
Guolin Ke committed
1393
    (out_results)[i] = static_cast<double>(result_buf[i]);
1394
  }
1395
  API_END();
1396
1397
}

Guolin Ke's avatar
Guolin Ke committed
1398
int LGBM_BoosterGetNumPredict(BoosterHandle handle,
1399
1400
                              int data_idx,
                              int64_t* out_len) {
Guolin Ke's avatar
Guolin Ke committed
1401
1402
1403
1404
1405
1406
  API_BEGIN();
  auto boosting = reinterpret_cast<Booster*>(handle)->GetBoosting();
  *out_len = boosting->GetNumPredictAt(data_idx);
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1407
int LGBM_BoosterGetPredict(BoosterHandle handle,
1408
1409
1410
                           int data_idx,
                           int64_t* out_len,
                           double* out_result) {
1411
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1412
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
1413
  ref_booster->GetPredictAt(data_idx, out_result, out_len);
1414
  API_END();
Guolin Ke's avatar
Guolin Ke committed
1415
1416
}

Guolin Ke's avatar
Guolin Ke committed
1417
int LGBM_BoosterPredictForFile(BoosterHandle handle,
1418
1419
1420
1421
                               const char* data_filename,
                               int data_has_header,
                               int predict_type,
                               int num_iteration,
1422
                               const char* parameter,
1423
                               const char* result_filename) {
1424
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1425
1426
  auto param = Config::Str2Map(parameter);
  Config config;
Guolin Ke's avatar
Guolin Ke committed
1427
1428
1429
1430
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
Guolin Ke's avatar
Guolin Ke committed
1431
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
cbecker's avatar
cbecker committed
1432
  ref_booster->Predict(num_iteration, predict_type, data_filename, data_has_header,
Guolin Ke's avatar
Guolin Ke committed
1433
                       config, result_filename);
1434
  API_END();
1435
1436
}

Guolin Ke's avatar
Guolin Ke committed
1437
int LGBM_BoosterCalcNumPredict(BoosterHandle handle,
1438
1439
1440
1441
                               int num_row,
                               int predict_type,
                               int num_iteration,
                               int64_t* out_len) {
Guolin Ke's avatar
Guolin Ke committed
1442
1443
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
1444
1445
  *out_len = static_cast<int64_t>(num_row) * ref_booster->GetBoosting()->NumPredictOneRow(
    num_iteration, predict_type == C_API_PREDICT_LEAF_INDEX, predict_type == C_API_PREDICT_CONTRIB);
Guolin Ke's avatar
Guolin Ke committed
1446
1447
1448
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1449
int LGBM_BoosterPredictForCSR(BoosterHandle handle,
1450
1451
1452
1453
1454
1455
1456
                              const void* indptr,
                              int indptr_type,
                              const int32_t* indices,
                              const void* data,
                              int data_type,
                              int64_t nindptr,
                              int64_t nelem,
1457
                              int64_t num_col,
1458
1459
                              int predict_type,
                              int num_iteration,
1460
                              const char* parameter,
1461
1462
                              int64_t* out_len,
                              double* out_result) {
1463
  API_BEGIN();
1464
1465
1466
1467
1468
  if (num_col <= 0) {
    Log::Fatal("The number of columns should be greater than zero.");
  } else if (num_col >= INT32_MAX) {
    Log::Fatal("The number of columns should be smaller than INT32_MAX.");
  }
Guolin Ke's avatar
Guolin Ke committed
1469
1470
  auto param = Config::Str2Map(parameter);
  Config config;
Guolin Ke's avatar
Guolin Ke committed
1471
1472
1473
1474
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
Guolin Ke's avatar
Guolin Ke committed
1475
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
1476
  auto get_row_fun = RowFunctionFromCSR(indptr, indptr_type, indices, data, data_type, nindptr, nelem);
Guolin Ke's avatar
Guolin Ke committed
1477
  int nrow = static_cast<int>(nindptr - 1);
1478
  ref_booster->Predict(num_iteration, predict_type, nrow, static_cast<int>(num_col), get_row_fun,
Guolin Ke's avatar
Guolin Ke committed
1479
                       config, out_result, out_len);
1480
  API_END();
Guolin Ke's avatar
Guolin Ke committed
1481
}
1482

1483
int LGBM_BoosterPredictForCSRSingleRow(BoosterHandle handle,
1484
1485
1486
1487
1488
1489
1490
                                       const void* indptr,
                                       int indptr_type,
                                       const int32_t* indices,
                                       const void* data,
                                       int data_type,
                                       int64_t nindptr,
                                       int64_t nelem,
1491
                                       int64_t num_col,
1492
1493
1494
1495
1496
                                       int predict_type,
                                       int num_iteration,
                                       const char* parameter,
                                       int64_t* out_len,
                                       double* out_result) {
1497
  API_BEGIN();
1498
1499
1500
1501
1502
  if (num_col <= 0) {
    Log::Fatal("The number of columns should be greater than zero.");
  } else if (num_col >= INT32_MAX) {
    Log::Fatal("The number of columns should be smaller than INT32_MAX.");
  }
1503
1504
1505
1506
1507
1508
1509
1510
  auto param = Config::Str2Map(parameter);
  Config config;
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  auto get_row_fun = RowFunctionFromCSR(indptr, indptr_type, indices, data, data_type, nindptr, nelem);
1511
  ref_booster->PredictSingleRow(num_iteration, predict_type, static_cast<int32_t>(num_col), get_row_fun, config, out_result, out_len);
1512
1513
1514
1515
  API_END();
}


Guolin Ke's avatar
Guolin Ke committed
1516
int LGBM_BoosterPredictForCSC(BoosterHandle handle,
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
                              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,
1527
                              const char* parameter,
1528
1529
                              int64_t* out_len,
                              double* out_result) {
Guolin Ke's avatar
Guolin Ke committed
1530
1531
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
Guolin Ke's avatar
Guolin Ke committed
1532
1533
  auto param = Config::Str2Map(parameter);
  Config config;
Guolin Ke's avatar
Guolin Ke committed
1534
1535
1536
1537
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
1538
  int num_threads = OMP_NUM_THREADS();
Guolin Ke's avatar
Guolin Ke committed
1539
  int ncol = static_cast<int>(ncol_ptr - 1);
Guolin Ke's avatar
Guolin Ke committed
1540
1541
1542
1543
1544
  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
1545
1546
  }
  std::function<std::vector<std::pair<int, double>>(int row_idx)> get_row_fun =
Guolin Ke's avatar
Guolin Ke committed
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
      [&iterators, ncol](int i) {
        std::vector<std::pair<int, double>> one_row;
        one_row.reserve(ncol);
        const int tid = omp_get_thread_num();
        for (int j = 0; j < ncol; ++j) {
          auto val = iterators[tid][j].Get(i);
          if (std::fabs(val) > kZeroThreshold || std::isnan(val)) {
            one_row.emplace_back(j, val);
          }
        }
        return one_row;
      };
1559
  ref_booster->Predict(num_iteration, predict_type, static_cast<int>(num_row), ncol, get_row_fun, config,
cbecker's avatar
cbecker committed
1560
                       out_result, out_len);
Guolin Ke's avatar
Guolin Ke committed
1561
1562
1563
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1564
int LGBM_BoosterPredictForMat(BoosterHandle handle,
1565
1566
1567
1568
1569
1570
1571
                              const void* data,
                              int data_type,
                              int32_t nrow,
                              int32_t ncol,
                              int is_row_major,
                              int predict_type,
                              int num_iteration,
1572
                              const char* parameter,
1573
1574
                              int64_t* out_len,
                              double* out_result) {
1575
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1576
1577
  auto param = Config::Str2Map(parameter);
  Config config;
Guolin Ke's avatar
Guolin Ke committed
1578
1579
1580
1581
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
Guolin Ke's avatar
Guolin Ke committed
1582
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
1583
  auto get_row_fun = RowPairFunctionFromDenseMatric(data, nrow, ncol, data_type, is_row_major);
1584
  ref_booster->Predict(num_iteration, predict_type, nrow, ncol, get_row_fun,
Guolin Ke's avatar
Guolin Ke committed
1585
                       config, out_result, out_len);
1586
  API_END();
Guolin Ke's avatar
Guolin Ke committed
1587
}
1588

1589
int LGBM_BoosterPredictForMatSingleRow(BoosterHandle handle,
1590
1591
1592
1593
1594
1595
1596
1597
1598
                                       const void* data,
                                       int data_type,
                                       int32_t ncol,
                                       int is_row_major,
                                       int predict_type,
                                       int num_iteration,
                                       const char* parameter,
                                       int64_t* out_len,
                                       double* out_result) {
1599
1600
1601
1602
1603
1604
1605
1606
1607
  API_BEGIN();
  auto param = Config::Str2Map(parameter);
  Config config;
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  auto get_row_fun = RowPairFunctionFromDenseMatric(data, 1, ncol, data_type, is_row_major);
1608
  ref_booster->PredictSingleRow(num_iteration, predict_type, ncol, get_row_fun, config, out_result, out_len);
1609
1610
1611
1612
  API_END();
}


1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
int LGBM_BoosterPredictForMats(BoosterHandle handle,
                               const void** data,
                               int data_type,
                               int32_t nrow,
                               int32_t ncol,
                               int predict_type,
                               int num_iteration,
                               const char* parameter,
                               int64_t* out_len,
                               double* out_result) {
  API_BEGIN();
  auto param = Config::Str2Map(parameter);
  Config config;
  config.Set(param);
  if (config.num_threads > 0) {
    omp_set_num_threads(config.num_threads);
  }
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  auto get_row_fun = RowPairFunctionFromDenseRows(data, ncol, data_type);
1632
  ref_booster->Predict(num_iteration, predict_type, nrow, ncol, get_row_fun, config, out_result, out_len);
1633
1634
1635
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1636
int LGBM_BoosterSaveModel(BoosterHandle handle,
1637
                          int start_iteration,
1638
1639
                          int num_iteration,
                          const char* filename) {
1640
  API_BEGIN();
1641
  LocaleContext withLocaleContext("C");
Guolin Ke's avatar
Guolin Ke committed
1642
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
1643
  ref_booster->SaveModelToFile(start_iteration, num_iteration, filename);
wxchan's avatar
wxchan committed
1644
1645
1646
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1647
int LGBM_BoosterSaveModelToString(BoosterHandle handle,
1648
                                  int start_iteration,
1649
                                  int num_iteration,
1650
                                  int64_t buffer_len,
1651
                                  int64_t* out_len,
1652
                                  char* out_str) {
1653
  API_BEGIN();
1654
  LocaleContext withLocaleContext("C");
1655
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
1656
  std::string model = ref_booster->SaveModelToString(start_iteration, num_iteration);
1657
  *out_len = static_cast<int64_t>(model.size()) + 1;
1658
  if (*out_len <= buffer_len) {
Guolin Ke's avatar
Guolin Ke committed
1659
    std::memcpy(out_str, model.c_str(), *out_len);
1660
1661
1662
1663
  }
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1664
int LGBM_BoosterDumpModel(BoosterHandle handle,
1665
                          int start_iteration,
1666
                          int num_iteration,
1667
1668
                          int64_t buffer_len,
                          int64_t* out_len,
1669
                          char* out_str) {
wxchan's avatar
wxchan committed
1670
  API_BEGIN();
1671
  LocaleContext withLocaleContext("C");
wxchan's avatar
wxchan committed
1672
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
1673
  std::string model = ref_booster->DumpModel(start_iteration, num_iteration);
1674
  *out_len = static_cast<int64_t>(model.size()) + 1;
wxchan's avatar
wxchan committed
1675
  if (*out_len <= buffer_len) {
Guolin Ke's avatar
Guolin Ke committed
1676
    std::memcpy(out_str, model.c_str(), *out_len);
wxchan's avatar
wxchan committed
1677
  }
1678
  API_END();
Guolin Ke's avatar
Guolin Ke committed
1679
}
1680

Guolin Ke's avatar
Guolin Ke committed
1681
int LGBM_BoosterGetLeafValue(BoosterHandle handle,
1682
1683
1684
                             int tree_idx,
                             int leaf_idx,
                             double* out_val) {
Guolin Ke's avatar
Guolin Ke committed
1685
1686
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
Guolin Ke's avatar
Guolin Ke committed
1687
  *out_val = static_cast<double>(ref_booster->GetLeafValue(tree_idx, leaf_idx));
Guolin Ke's avatar
Guolin Ke committed
1688
1689
1690
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
1691
int LGBM_BoosterSetLeafValue(BoosterHandle handle,
1692
1693
1694
                             int tree_idx,
                             int leaf_idx,
                             double val) {
Guolin Ke's avatar
Guolin Ke committed
1695
1696
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
Guolin Ke's avatar
Guolin Ke committed
1697
  ref_booster->SetLeafValue(tree_idx, leaf_idx, val);
Guolin Ke's avatar
Guolin Ke committed
1698
1699
1700
  API_END();
}

1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
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();
}

1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
int LGBM_BoosterGetUpperBoundValue(BoosterHandle handle,
                                   double* out_results) {
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  double max_value = ref_booster->UpperBoundValue();
  *out_results = max_value;
  API_END();
}

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

1732
1733
1734
1735
1736
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
1737
  Config config;
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
  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();
}

1754
1755
1756
int LGBM_NetworkInitWithFunctions(int num_machines, int rank,
                                  void* reduce_scatter_ext_fun,
                                  void* allgather_ext_fun) {
ww's avatar
ww committed
1757
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
1758
  if (num_machines > 1) {
1759
    Network::Init(num_machines, rank, (ReduceScatterFunction)reduce_scatter_ext_fun, (AllgatherFunction)allgather_ext_fun);
ww's avatar
ww committed
1760
1761
1762
  }
  API_END();
}
Guolin Ke's avatar
Guolin Ke committed
1763

Guolin Ke's avatar
Guolin Ke committed
1764
// ---- start of some help functions
1765
1766
1767

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
1768
  if (data_type == C_API_DTYPE_FLOAT32) {
1769
1770
    const float* data_ptr = reinterpret_cast<const float*>(data);
    if (is_row_major) {
1771
      return [=] (int row_idx) {
Guolin Ke's avatar
Guolin Ke committed
1772
        std::vector<double> ret(num_col);
1773
        auto tmp_ptr = data_ptr + static_cast<size_t>(num_col) * row_idx;
1774
        for (int i = 0; i < num_col; ++i) {
Guolin Ke's avatar
Guolin Ke committed
1775
          ret[i] = static_cast<double>(*(tmp_ptr + i));
1776
1777
1778
1779
        }
        return ret;
      };
    } else {
1780
      return [=] (int row_idx) {
Guolin Ke's avatar
Guolin Ke committed
1781
        std::vector<double> ret(num_col);
1782
        for (int i = 0; i < num_col; ++i) {
1783
          ret[i] = static_cast<double>(*(data_ptr + static_cast<size_t>(num_row) * i + row_idx));
1784
1785
1786
1787
        }
        return ret;
      };
    }
Guolin Ke's avatar
Guolin Ke committed
1788
  } else if (data_type == C_API_DTYPE_FLOAT64) {
1789
1790
    const double* data_ptr = reinterpret_cast<const double*>(data);
    if (is_row_major) {
1791
      return [=] (int row_idx) {
Guolin Ke's avatar
Guolin Ke committed
1792
        std::vector<double> ret(num_col);
1793
        auto tmp_ptr = data_ptr + static_cast<size_t>(num_col) * row_idx;
1794
        for (int i = 0; i < num_col; ++i) {
Guolin Ke's avatar
Guolin Ke committed
1795
          ret[i] = static_cast<double>(*(tmp_ptr + i));
1796
1797
1798
1799
        }
        return ret;
      };
    } else {
1800
      return [=] (int row_idx) {
Guolin Ke's avatar
Guolin Ke committed
1801
        std::vector<double> ret(num_col);
1802
        for (int i = 0; i < num_col; ++i) {
1803
          ret[i] = static_cast<double>(*(data_ptr + static_cast<size_t>(num_row) * i + row_idx));
1804
1805
1806
1807
1808
        }
        return ret;
      };
    }
  }
1809
  Log::Fatal("Unknown data type in RowFunctionFromDenseMatric");
1810
  return nullptr;
1811
1812
1813
1814
}

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
1815
1816
  auto inner_function = RowFunctionFromDenseMatric(data, num_row, num_col, data_type, is_row_major);
  if (inner_function != nullptr) {
1817
    return [inner_function] (int row_idx) {
Guolin Ke's avatar
Guolin Ke committed
1818
1819
      auto raw_values = inner_function(row_idx);
      std::vector<std::pair<int, double>> ret;
Guolin Ke's avatar
Guolin Ke committed
1820
      ret.reserve(raw_values.size());
Guolin Ke's avatar
Guolin Ke committed
1821
      for (int i = 0; i < static_cast<int>(raw_values.size()); ++i) {
Guolin Ke's avatar
Guolin Ke committed
1822
        if (std::fabs(raw_values[i]) > kZeroThreshold || std::isnan(raw_values[i])) {
Guolin Ke's avatar
Guolin Ke committed
1823
          ret.emplace_back(i, raw_values[i]);
1824
        }
Guolin Ke's avatar
Guolin Ke committed
1825
1826
1827
      }
      return ret;
    };
1828
  }
Guolin Ke's avatar
Guolin Ke committed
1829
  return nullptr;
1830
1831
}

1832
1833
1834
1835
1836
1837
1838
// data is array of pointers to individual rows
std::function<std::vector<std::pair<int, double>>(int row_idx)>
RowPairFunctionFromDenseRows(const void** data, int num_col, int data_type) {
  return [=](int row_idx) {
    auto inner_function = RowFunctionFromDenseMatric(data[row_idx], 1, num_col, data_type, /* is_row_major */ true);
    auto raw_values = inner_function(0);
    std::vector<std::pair<int, double>> ret;
Guolin Ke's avatar
Guolin Ke committed
1839
    ret.reserve(raw_values.size());
1840
1841
1842
1843
1844
1845
1846
1847
1848
    for (int i = 0; i < static_cast<int>(raw_values.size()); ++i) {
      if (std::fabs(raw_values[i]) > kZeroThreshold || std::isnan(raw_values[i])) {
        ret.emplace_back(i, raw_values[i]);
      }
    }
    return ret;
  };
}

1849
std::function<std::vector<std::pair<int, double>>(int idx)>
1850
RowFunctionFromCSR(const void* indptr, int indptr_type, const int32_t* indices, const void* data, int data_type, int64_t , int64_t ) {
Guolin Ke's avatar
Guolin Ke committed
1851
  if (data_type == C_API_DTYPE_FLOAT32) {
1852
    const float* data_ptr = reinterpret_cast<const float*>(data);
Guolin Ke's avatar
Guolin Ke committed
1853
    if (indptr_type == C_API_DTYPE_INT32) {
1854
      const int32_t* ptr_indptr = reinterpret_cast<const int32_t*>(indptr);
1855
      return [=] (int idx) {
1856
1857
1858
        std::vector<std::pair<int, double>> ret;
        int64_t start = ptr_indptr[idx];
        int64_t end = ptr_indptr[idx + 1];
1859
1860
1861
        if (end - start > 0)  {
          ret.reserve(end - start);
        }
Guolin Ke's avatar
Guolin Ke committed
1862
        for (int64_t i = start; i < end; ++i) {
Guolin Ke's avatar
Guolin Ke committed
1863
          ret.emplace_back(indices[i], data_ptr[i]);
1864
1865
1866
        }
        return ret;
      };
Guolin Ke's avatar
Guolin Ke committed
1867
    } else if (indptr_type == C_API_DTYPE_INT64) {
1868
      const int64_t* ptr_indptr = reinterpret_cast<const int64_t*>(indptr);
1869
      return [=] (int idx) {
1870
1871
1872
        std::vector<std::pair<int, double>> ret;
        int64_t start = ptr_indptr[idx];
        int64_t end = ptr_indptr[idx + 1];
1873
1874
1875
        if (end - start > 0)  {
          ret.reserve(end - start);
        }
Guolin Ke's avatar
Guolin Ke committed
1876
        for (int64_t i = start; i < end; ++i) {
Guolin Ke's avatar
Guolin Ke committed
1877
          ret.emplace_back(indices[i], data_ptr[i]);
1878
1879
1880
1881
        }
        return ret;
      };
    }
Guolin Ke's avatar
Guolin Ke committed
1882
  } else if (data_type == C_API_DTYPE_FLOAT64) {
1883
    const double* data_ptr = reinterpret_cast<const double*>(data);
Guolin Ke's avatar
Guolin Ke committed
1884
    if (indptr_type == C_API_DTYPE_INT32) {
1885
      const int32_t* ptr_indptr = reinterpret_cast<const int32_t*>(indptr);
1886
      return [=] (int idx) {
1887
1888
1889
        std::vector<std::pair<int, double>> ret;
        int64_t start = ptr_indptr[idx];
        int64_t end = ptr_indptr[idx + 1];
1890
1891
1892
        if (end - start > 0)  {
          ret.reserve(end - start);
        }
Guolin Ke's avatar
Guolin Ke committed
1893
        for (int64_t i = start; i < end; ++i) {
Guolin Ke's avatar
Guolin Ke committed
1894
          ret.emplace_back(indices[i], data_ptr[i]);
1895
1896
1897
        }
        return ret;
      };
Guolin Ke's avatar
Guolin Ke committed
1898
    } else if (indptr_type == C_API_DTYPE_INT64) {
1899
      const int64_t* ptr_indptr = reinterpret_cast<const int64_t*>(indptr);
1900
      return [=] (int idx) {
1901
1902
1903
        std::vector<std::pair<int, double>> ret;
        int64_t start = ptr_indptr[idx];
        int64_t end = ptr_indptr[idx + 1];
1904
1905
1906
        if (end - start > 0)  {
          ret.reserve(end - start);
        }
Guolin Ke's avatar
Guolin Ke committed
1907
        for (int64_t i = start; i < end; ++i) {
Guolin Ke's avatar
Guolin Ke committed
1908
          ret.emplace_back(indices[i], data_ptr[i]);
1909
1910
1911
        }
        return ret;
      };
Guolin Ke's avatar
Guolin Ke committed
1912
1913
    }
  }
1914
  Log::Fatal("Unknown data type in RowFunctionFromCSR");
1915
  return nullptr;
1916
1917
}

Guolin Ke's avatar
Guolin Ke committed
1918
std::function<std::pair<int, double>(int idx)>
1919
IterateFunctionFromCSC(const void* col_ptr, int col_ptr_type, const int32_t* indices, const void* data, int data_type, int64_t ncol_ptr, int64_t , int col_idx) {
Guolin Ke's avatar
Guolin Ke committed
1920
  CHECK(col_idx < ncol_ptr && col_idx >= 0);
Guolin Ke's avatar
Guolin Ke committed
1921
  if (data_type == C_API_DTYPE_FLOAT32) {
1922
    const float* data_ptr = reinterpret_cast<const float*>(data);
Guolin Ke's avatar
Guolin Ke committed
1923
    if (col_ptr_type == C_API_DTYPE_INT32) {
1924
      const int32_t* ptr_col_ptr = reinterpret_cast<const int32_t*>(col_ptr);
Guolin Ke's avatar
Guolin Ke committed
1925
1926
      int64_t start = ptr_col_ptr[col_idx];
      int64_t end = ptr_col_ptr[col_idx + 1];
1927
1928
      return [=] (int offset) {
        int64_t i = static_cast<int64_t>(start + offset);
Guolin Ke's avatar
Guolin Ke committed
1929
1930
        if (i >= end) {
          return std::make_pair(-1, 0.0);
1931
        }
Guolin Ke's avatar
Guolin Ke committed
1932
1933
1934
        int idx = static_cast<int>(indices[i]);
        double val = static_cast<double>(data_ptr[i]);
        return std::make_pair(idx, val);
1935
      };
Guolin Ke's avatar
Guolin Ke committed
1936
    } else if (col_ptr_type == C_API_DTYPE_INT64) {
1937
      const int64_t* ptr_col_ptr = reinterpret_cast<const int64_t*>(col_ptr);
Guolin Ke's avatar
Guolin Ke committed
1938
1939
      int64_t start = ptr_col_ptr[col_idx];
      int64_t end = ptr_col_ptr[col_idx + 1];
1940
1941
      return [=] (int offset) {
        int64_t i = static_cast<int64_t>(start + offset);
Guolin Ke's avatar
Guolin Ke committed
1942
1943
        if (i >= end) {
          return std::make_pair(-1, 0.0);
1944
        }
Guolin Ke's avatar
Guolin Ke committed
1945
1946
1947
        int idx = static_cast<int>(indices[i]);
        double val = static_cast<double>(data_ptr[i]);
        return std::make_pair(idx, val);
1948
      };
Guolin Ke's avatar
Guolin Ke committed
1949
    }
Guolin Ke's avatar
Guolin Ke committed
1950
  } else if (data_type == C_API_DTYPE_FLOAT64) {
1951
    const double* data_ptr = reinterpret_cast<const double*>(data);
Guolin Ke's avatar
Guolin Ke committed
1952
    if (col_ptr_type == C_API_DTYPE_INT32) {
1953
      const int32_t* ptr_col_ptr = reinterpret_cast<const int32_t*>(col_ptr);
Guolin Ke's avatar
Guolin Ke committed
1954
1955
      int64_t start = ptr_col_ptr[col_idx];
      int64_t end = ptr_col_ptr[col_idx + 1];
1956
1957
      return [=] (int offset) {
        int64_t i = static_cast<int64_t>(start + offset);
Guolin Ke's avatar
Guolin Ke committed
1958
1959
        if (i >= end) {
          return std::make_pair(-1, 0.0);
1960
        }
Guolin Ke's avatar
Guolin Ke committed
1961
1962
1963
        int idx = static_cast<int>(indices[i]);
        double val = static_cast<double>(data_ptr[i]);
        return std::make_pair(idx, val);
1964
      };
Guolin Ke's avatar
Guolin Ke committed
1965
    } else if (col_ptr_type == C_API_DTYPE_INT64) {
1966
      const int64_t* ptr_col_ptr = reinterpret_cast<const int64_t*>(col_ptr);
Guolin Ke's avatar
Guolin Ke committed
1967
1968
      int64_t start = ptr_col_ptr[col_idx];
      int64_t end = ptr_col_ptr[col_idx + 1];
1969
1970
      return [=] (int offset) {
        int64_t i = static_cast<int64_t>(start + offset);
Guolin Ke's avatar
Guolin Ke committed
1971
1972
        if (i >= end) {
          return std::make_pair(-1, 0.0);
1973
        }
Guolin Ke's avatar
Guolin Ke committed
1974
1975
1976
        int idx = static_cast<int>(indices[i]);
        double val = static_cast<double>(data_ptr[i]);
        return std::make_pair(idx, val);
1977
      };
Guolin Ke's avatar
Guolin Ke committed
1978
1979
    }
  }
1980
  Log::Fatal("Unknown data type in CSC matrix");
1981
  return nullptr;
1982
1983
}

Guolin Ke's avatar
Guolin Ke committed
1984
CSC_RowIterator::CSC_RowIterator(const void* col_ptr, int col_ptr_type, const int32_t* indices,
1985
                                 const void* data, int data_type, int64_t ncol_ptr, int64_t nelem, int col_idx) {
Guolin Ke's avatar
Guolin Ke committed
1986
1987
1988
1989
1990
1991
1992
1993
1994
  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;
1995
    }
Guolin Ke's avatar
Guolin Ke committed
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
    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;
2013
    }
Guolin Ke's avatar
Guolin Ke committed
2014
2015
2016
    return ret;
  } else {
    return std::make_pair(-1, 0.0);
2017
  }
Guolin Ke's avatar
Guolin Ke committed
2018
}