c_api.cpp 27.1 KB
Newer Older
Guolin Ke's avatar
Guolin Ke committed
1
2
3
4
#include <omp.h>

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

#include <cstdio>
#include <vector>
#include <string>
#include <cstring>
Guolin Ke's avatar
Guolin Ke committed
17
#include <memory>
Guolin Ke's avatar
Guolin Ke committed
18
#include <stdexcept>
Guolin Ke's avatar
Guolin Ke committed
19

Guolin Ke's avatar
Guolin Ke committed
20
21
#include "./application/predictor.hpp"

Guolin Ke's avatar
Guolin Ke committed
22
23
24
25
namespace LightGBM {

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

  Booster(const Dataset* train_data, 
    std::vector<const Dataset*> valid_data, 
    const char* parameters)
Guolin Ke's avatar
Guolin Ke committed
33
    :train_data_(train_data), valid_datas_(valid_data) {
Guolin Ke's avatar
Guolin Ke committed
34
35
36
    config_.LoadFromString(parameters);
    // create boosting
    if (config_.io_config.input_model.size() > 0) {
Guolin Ke's avatar
Guolin Ke committed
37
      Log::Warning("continued train from model is not support for c_api, \
Guolin Ke's avatar
Guolin Ke committed
38
39
        please use continued train with input score");
    }
Guolin Ke's avatar
Guolin Ke committed
40
    boosting_.reset(Boosting::CreateBoosting(config_.boosting_type, ""));
Guolin Ke's avatar
Guolin Ke committed
41
    // create objective function
Guolin Ke's avatar
Guolin Ke committed
42
43
44
45
46
    objective_fun_.reset(ObjectiveFunction::CreateObjectiveFunction(config_.objective_type,
      config_.objective_config));
    if (objective_fun_ == nullptr) {
      Log::Warning("Using self-defined objective functions");
    }
Guolin Ke's avatar
Guolin Ke committed
47
    // create training metric
Guolin Ke's avatar
Guolin Ke committed
48
    for (auto metric_type : config_.metric_types) {
Guolin Ke's avatar
Guolin Ke committed
49
50
      auto metric = std::unique_ptr<Metric>(
        Metric::CreateMetric(metric_type, config_.metric_config));
Guolin Ke's avatar
Guolin Ke committed
51
      if (metric == nullptr) { continue; }
Guolin Ke's avatar
Guolin Ke committed
52
      metric->Init(train_data_->metadata(), train_data_->num_data());
Guolin Ke's avatar
Guolin Ke committed
53
      train_metric_.push_back(std::move(metric));
Guolin Ke's avatar
Guolin Ke committed
54
    }
Guolin Ke's avatar
Guolin Ke committed
55
    train_metric_.shrink_to_fit();
Guolin Ke's avatar
Guolin Ke committed
56
57
58
59
    // add metric for validation data
    for (size_t i = 0; i < valid_datas_.size(); ++i) {
      valid_metrics_.emplace_back();
      for (auto metric_type : config_.metric_types) {
Guolin Ke's avatar
Guolin Ke committed
60
        auto metric = std::unique_ptr<Metric>(Metric::CreateMetric(metric_type, config_.metric_config));
Guolin Ke's avatar
Guolin Ke committed
61
        if (metric == nullptr) { continue; }
Guolin Ke's avatar
Guolin Ke committed
62
        metric->Init(valid_datas_[i]->metadata(), valid_datas_[i]->num_data());
Guolin Ke's avatar
Guolin Ke committed
63
        valid_metrics_.back().push_back(std::move(metric));
Guolin Ke's avatar
Guolin Ke committed
64
      }
Guolin Ke's avatar
Guolin Ke committed
65
      valid_metrics_.back().shrink_to_fit();
Guolin Ke's avatar
Guolin Ke committed
66
    }
Guolin Ke's avatar
Guolin Ke committed
67
    valid_metrics_.shrink_to_fit();
Guolin Ke's avatar
Guolin Ke committed
68
    // initialize the objective function
Guolin Ke's avatar
Guolin Ke committed
69
70
71
    if (objective_fun_ != nullptr) {
      objective_fun_->Init(train_data_->metadata(), train_data_->num_data());
    }
Guolin Ke's avatar
Guolin Ke committed
72
    // initialize the boosting
Guolin Ke's avatar
Guolin Ke committed
73
74
    boosting_->Init(&config_.boosting_config, train_data_, objective_fun_.get(),
      Common::ConstPtrInVectorWrapper<Metric>(train_metric_));
Guolin Ke's avatar
Guolin Ke committed
75
76
77
    // add validation data into boosting
    for (size_t i = 0; i < valid_datas_.size(); ++i) {
      boosting_->AddDataset(valid_datas_[i],
Guolin Ke's avatar
Guolin Ke committed
78
        Common::ConstPtrInVectorWrapper<Metric>(valid_metrics_[i]));
Guolin Ke's avatar
Guolin Ke committed
79
80
    }
  }
Guolin Ke's avatar
Guolin Ke committed
81

82
83
84
  void LoadModelFromFile(const char* filename) {
    Boosting::LoadFileToBoosting(boosting_.get(), filename);
  }
Guolin Ke's avatar
Guolin Ke committed
85

Guolin Ke's avatar
Guolin Ke committed
86
  ~Booster() {
Guolin Ke's avatar
Guolin Ke committed
87

Guolin Ke's avatar
Guolin Ke committed
88
  }
Guolin Ke's avatar
Guolin Ke committed
89

90
91
92
93
94
95
96
97
98
99
  bool TrainOneIter() {
    return boosting_->TrainOneIter(nullptr, nullptr, false);
  }

  bool TrainOneIter(const float* gradients, const float* hessians) {
    return boosting_->TrainOneIter(gradients, hessians, false);
  }

  void PrepareForPrediction(int num_used_model, int predict_type) {
    boosting_->SetNumUsedModel(num_used_model);
Guolin Ke's avatar
Guolin Ke committed
100
101
    bool is_predict_leaf = false;
    bool is_raw_score = false;
Guolin Ke's avatar
Guolin Ke committed
102
    if (predict_type == C_API_PREDICT_LEAF_INDEX) {
Guolin Ke's avatar
Guolin Ke committed
103
      is_predict_leaf = true;
Guolin Ke's avatar
Guolin Ke committed
104
    } else if (predict_type == C_API_PREDICT_RAW_SCORE) {
Guolin Ke's avatar
Guolin Ke committed
105
      is_raw_score = true;
Guolin Ke's avatar
Guolin Ke committed
106
107
    } else {
      is_raw_score = false;
Guolin Ke's avatar
Guolin Ke committed
108
    }
Guolin Ke's avatar
Guolin Ke committed
109
    predictor_.reset(new Predictor(boosting_.get(), is_raw_score, is_predict_leaf));
Guolin Ke's avatar
Guolin Ke committed
110
111
112
113
  }

  std::vector<double> Predict(const std::vector<std::pair<int, double>>& features) {
    return predictor_->GetPredictFunction()(features);
114
115
  }

116
117
118
119
  void PredictForFile(const char* data_filename, const char* result_filename, bool data_has_header) {
    predictor_->Predict(data_filename, result_filename, data_has_header);
  }

Guolin Ke's avatar
Guolin Ke committed
120
121
122
  void SaveModelToFile(int num_used_model, const char* filename) {
    boosting_->SaveModelToFile(num_used_model, true, filename);
  }
Guolin Ke's avatar
Guolin Ke committed
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

  int GetEvalCounts() const {
    int ret = 0;
    for (const auto& metric : train_metric_) {
      ret += static_cast<int>(metric->GetName().size());
    }
    return ret;
  }

  int GetEvalNames(const char*** out_strs) const {
    int idx = 0;
    for (const auto& metric : train_metric_) {
      for (const auto& name : metric->GetName()) {
        *(out_strs[idx++]) = name.c_str();
      }
    }
    return idx;
  }

Guolin Ke's avatar
Guolin Ke committed
142
  const Boosting* GetBoosting() const { return boosting_.get(); }
143

144
145
  const float* GetTrainingScore(int* out_len) const { return boosting_->GetTrainingScore(out_len); }

Guolin Ke's avatar
Guolin Ke committed
146
  const inline int NumberOfClasses() const { return boosting_->NumberOfClasses(); }
147

Guolin Ke's avatar
Guolin Ke committed
148
private:
149

Guolin Ke's avatar
Guolin Ke committed
150
  std::unique_ptr<Boosting> boosting_;
Guolin Ke's avatar
Guolin Ke committed
151
152
153
154
155
156
157
  /*! \brief All configs */
  OverallConfig config_;
  /*! \brief Training data */
  const Dataset* train_data_;
  /*! \brief Validation data */
  std::vector<const Dataset*> valid_datas_;
  /*! \brief Metric for training data */
Guolin Ke's avatar
Guolin Ke committed
158
  std::vector<std::unique_ptr<Metric>> train_metric_;
Guolin Ke's avatar
Guolin Ke committed
159
  /*! \brief Metrics for validation data */
Guolin Ke's avatar
Guolin Ke committed
160
  std::vector<std::vector<std::unique_ptr<Metric>>> valid_metrics_;
Guolin Ke's avatar
Guolin Ke committed
161
  /*! \brief Training objective function */
Guolin Ke's avatar
Guolin Ke committed
162
  std::unique_ptr<ObjectiveFunction> objective_fun_;
Guolin Ke's avatar
Guolin Ke committed
163
  /*! \brief Using predictor for prediction task */
Guolin Ke's avatar
Guolin Ke committed
164
  std::unique_ptr<Predictor> predictor_;
165

Guolin Ke's avatar
Guolin Ke committed
166
167
168
};

}
Guolin Ke's avatar
Guolin Ke committed
169
170
171

using namespace LightGBM;

Guolin Ke's avatar
Guolin Ke committed
172
DllExport const char* LGBM_GetLastError() {
173
  return LastErrorMsg().c_str();
Guolin Ke's avatar
Guolin Ke committed
174
175
176
177
178
179
}

DllExport int LGBM_CreateDatasetFromFile(const char* filename,
  const char* parameters,
  const DatesetHandle* reference,
  DatesetHandle* out) {
180
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
181
182
183
  OverallConfig config;
  config.LoadFromString(parameters);
  DatasetLoader loader(config.io_config, nullptr);
184
  loader.SetHeader(filename);
Guolin Ke's avatar
Guolin Ke committed
185
  if (reference == nullptr) {
Guolin Ke's avatar
Guolin Ke committed
186
    *out = loader.LoadFromFile(filename);
Guolin Ke's avatar
Guolin Ke committed
187
  } else {
Guolin Ke's avatar
Guolin Ke committed
188
189
    *out = loader.LoadFromFileAlignWithOtherDataset(filename,
      reinterpret_cast<const Dataset*>(*reference));
Guolin Ke's avatar
Guolin Ke committed
190
  }
191
  API_END();
Guolin Ke's avatar
Guolin Ke committed
192
193
194
195
}

DllExport int LGBM_CreateDatasetFromBinaryFile(const char* filename,
  DatesetHandle* out) {
196
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
197
198
  OverallConfig config;
  DatasetLoader loader(config.io_config, nullptr);
Guolin Ke's avatar
Guolin Ke committed
199
  *out = loader.LoadFromBinFile(filename, 0, 1);
200
  API_END();
Guolin Ke's avatar
Guolin Ke committed
201
202
203
}

DllExport int LGBM_CreateDatasetFromMat(const void* data,
204
  int data_type,
Guolin Ke's avatar
Guolin Ke committed
205
206
207
208
209
210
  int32_t nrow,
  int32_t ncol,
  int is_row_major,
  const char* parameters,
  const DatesetHandle* reference,
  DatesetHandle* out) {
211
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
212
213
214
  OverallConfig config;
  config.LoadFromString(parameters);
  DatasetLoader loader(config.io_config, nullptr);
Guolin Ke's avatar
Guolin Ke committed
215
  std::unique_ptr<Dataset> ret;
216
  auto get_row_fun = RowFunctionFromDenseMatric(data, nrow, ncol, data_type, is_row_major);
Guolin Ke's avatar
Guolin Ke committed
217
218
219
  if (reference == nullptr) {
    // sample data first
    Random rand(config.io_config.data_random_seed);
220
    const int sample_cnt = static_cast<int>(nrow < config.io_config.bin_construct_sample_cnt ? nrow : config.io_config.bin_construct_sample_cnt);
Guolin Ke's avatar
Guolin Ke committed
221
    auto sample_indices = rand.Sample(nrow, sample_cnt);
222
    std::vector<std::vector<double>> sample_values(ncol);
Guolin Ke's avatar
Guolin Ke committed
223
    for (size_t i = 0; i < sample_indices.size(); ++i) {
Guolin Ke's avatar
Guolin Ke committed
224
      auto idx = sample_indices[i];
225
      auto row = get_row_fun(static_cast<int>(idx));
Guolin Ke's avatar
Guolin Ke committed
226
      for (size_t j = 0; j < row.size(); ++j) {
Guolin Ke's avatar
Guolin Ke committed
227
228
229
        if (std::fabs(row[j]) > 1e-15) {
          sample_values[j].push_back(row[j]);
        }
Guolin Ke's avatar
Guolin Ke committed
230
231
      }
    }
Guolin Ke's avatar
Guolin Ke committed
232
    ret.reset(loader.CostructFromSampleData(sample_values, sample_cnt, nrow));
Guolin Ke's avatar
Guolin Ke committed
233
  } else {
Guolin Ke's avatar
Guolin Ke committed
234
235
    ret.reset(new Dataset(nrow, config.io_config.num_class));
    ret->CopyFeatureMapperFrom(
Guolin Ke's avatar
Guolin Ke committed
236
      reinterpret_cast<const Dataset*>(*reference),
Guolin Ke's avatar
Guolin Ke committed
237
      config.io_config.is_enable_sparse);
Guolin Ke's avatar
Guolin Ke committed
238
239
240
241
242
  }

#pragma omp parallel for schedule(guided)
  for (int i = 0; i < nrow; ++i) {
    const int tid = omp_get_thread_num();
243
    auto one_row = get_row_fun(i);
Guolin Ke's avatar
Guolin Ke committed
244
245
246
    ret->PushOneRow(tid, i, one_row);
  }
  ret->FinishLoad();
Guolin Ke's avatar
Guolin Ke committed
247
  *out = ret.release();
248
  API_END();
249
250
}

251
252
DllExport int LGBM_CreateDatasetFromCSR(const void* indptr,
  int indptr_type,
253
254
  const int32_t* indices,
  const void* data,
255
256
257
258
  int data_type,
  int64_t nindptr,
  int64_t nelem,
  int64_t num_col,
259
260
261
  const char* parameters,
  const DatesetHandle* reference,
  DatesetHandle* out) {
262
  API_BEGIN();
263
264
265
  OverallConfig config;
  config.LoadFromString(parameters);
  DatasetLoader loader(config.io_config, nullptr);
Guolin Ke's avatar
Guolin Ke committed
266
  std::unique_ptr<Dataset> ret;
267
  auto get_row_fun = RowFunctionFromCSR(indptr, indptr_type, indices, data, data_type, nindptr, nelem);
268
269
270
271
  int32_t nrow = static_cast<int32_t>(nindptr - 1);
  if (reference == nullptr) {
    // sample data first
    Random rand(config.io_config.data_random_seed);
272
    const int sample_cnt = static_cast<int>(nrow < config.io_config.bin_construct_sample_cnt ? nrow : config.io_config.bin_construct_sample_cnt);
273
274
275
276
277
278
    auto sample_indices = rand.Sample(nrow, sample_cnt);
    std::vector<std::vector<double>> sample_values;
    for (size_t i = 0; i < sample_indices.size(); ++i) {
      auto idx = sample_indices[i];
      auto row = get_row_fun(static_cast<int>(idx));
      for (std::pair<int, double>& inner_data : row) {
Guolin Ke's avatar
Guolin Ke committed
279
280
281
282
283
284
285
        if (std::fabs(inner_data.second) > 1e-15) {
          if (static_cast<size_t>(inner_data.first) >= sample_values.size()) {
            // if need expand feature set
            size_t need_size = inner_data.first - sample_values.size() + 1;
            for (size_t j = 0; j < need_size; ++j) {
              sample_values.emplace_back();
            }
286
          }
Guolin Ke's avatar
Guolin Ke committed
287
288
          // edit the feature value
          sample_values[inner_data.first].push_back(inner_data.second);
289
290
291
        }
      }
    }
292
    CHECK(num_col >= static_cast<int>(sample_values.size()));
Guolin Ke's avatar
Guolin Ke committed
293
    ret.reset(loader.CostructFromSampleData(sample_values, sample_cnt, nrow));
294
  } else {
Guolin Ke's avatar
Guolin Ke committed
295
296
    ret.reset(new Dataset(nrow, config.io_config.num_class));
    ret->CopyFeatureMapperFrom(
Guolin Ke's avatar
Guolin Ke committed
297
      reinterpret_cast<const Dataset*>(*reference),
Guolin Ke's avatar
Guolin Ke committed
298
      config.io_config.is_enable_sparse);
299
300
301
302
303
304
305
306
307
  }

#pragma omp parallel for schedule(guided)
  for (int i = 0; i < nindptr - 1; ++i) {
    const int tid = omp_get_thread_num();
    auto one_row = get_row_fun(i);
    ret->PushOneRow(tid, i, one_row);
  }
  ret->FinishLoad();
Guolin Ke's avatar
Guolin Ke committed
308
  *out = ret.release();
309
  API_END();
310
311
}

312
313
DllExport int LGBM_CreateDatasetFromCSC(const void* col_ptr,
  int col_ptr_type,
Guolin Ke's avatar
Guolin Ke committed
314
315
  const int32_t* indices,
  const void* data,
316
317
318
319
  int data_type,
  int64_t ncol_ptr,
  int64_t nelem,
  int64_t num_row,
Guolin Ke's avatar
Guolin Ke committed
320
321
322
  const char* parameters,
  const DatesetHandle* reference,
  DatesetHandle* out) {
323
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
324
325
326
  OverallConfig config;
  config.LoadFromString(parameters);
  DatasetLoader loader(config.io_config, nullptr);
Guolin Ke's avatar
Guolin Ke committed
327
  std::unique_ptr<Dataset> ret;
328
  auto get_col_fun = ColumnFunctionFromCSC(col_ptr, col_ptr_type, indices, data, data_type, ncol_ptr, nelem);
Guolin Ke's avatar
Guolin Ke committed
329
330
331
332
333
  int32_t nrow = static_cast<int32_t>(num_row);
  if (reference == nullptr) {
    Log::Warning("Construct from CSC format is not efficient");
    // sample data first
    Random rand(config.io_config.data_random_seed);
334
    const int sample_cnt = static_cast<int>(nrow < config.io_config.bin_construct_sample_cnt ? nrow : config.io_config.bin_construct_sample_cnt);
Guolin Ke's avatar
Guolin Ke committed
335
336
337
338
339
    auto sample_indices = rand.Sample(nrow, sample_cnt);
    std::vector<std::vector<double>> sample_values(ncol_ptr - 1);
#pragma omp parallel for schedule(guided)
    for (int i = 0; i < static_cast<int>(sample_values.size()); ++i) {
      auto cur_col = get_col_fun(i);
340
      sample_values[i] = SampleFromOneColumn(cur_col, sample_indices);
Guolin Ke's avatar
Guolin Ke committed
341
    }
Guolin Ke's avatar
Guolin Ke committed
342
    ret.reset(loader.CostructFromSampleData(sample_values, sample_cnt, nrow));
Guolin Ke's avatar
Guolin Ke committed
343
  } else {
Guolin Ke's avatar
Guolin Ke committed
344
345
    ret.reset(new Dataset(nrow, config.io_config.num_class));
    ret->CopyFeatureMapperFrom(
Guolin Ke's avatar
Guolin Ke committed
346
      reinterpret_cast<const Dataset*>(*reference),
Guolin Ke's avatar
Guolin Ke committed
347
      config.io_config.is_enable_sparse);
Guolin Ke's avatar
Guolin Ke committed
348
349
350
351
352
353
  }

#pragma omp parallel for schedule(guided)
  for (int i = 0; i < ncol_ptr - 1; ++i) {
    const int tid = omp_get_thread_num();
    auto one_col = get_col_fun(i);
Guolin Ke's avatar
Guolin Ke committed
354
    ret->PushOneColumn(tid, i, one_col);
Guolin Ke's avatar
Guolin Ke committed
355
356
  }
  ret->FinishLoad();
Guolin Ke's avatar
Guolin Ke committed
357
  *out = ret.release();
358
  API_END();
Guolin Ke's avatar
Guolin Ke committed
359
360
}

361
DllExport int LGBM_DatasetFree(DatesetHandle handle) {
362
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
363
  delete reinterpret_cast<Dataset*>(handle);
364
  API_END();
365
366
367
368
}

DllExport int LGBM_DatasetSaveBinary(DatesetHandle handle,
  const char* filename) {
369
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
370
371
  auto dataset = reinterpret_cast<Dataset*>(handle);
  dataset->SaveBinaryFile(filename);
372
  API_END();
373
374
375
376
377
}

DllExport int LGBM_DatasetSetField(DatesetHandle handle,
  const char* field_name,
  const void* field_data,
378
  int64_t num_element,
379
  int type) {
380
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
381
  auto dataset = reinterpret_cast<Dataset*>(handle);
382
  bool is_success = false;
Guolin Ke's avatar
Guolin Ke committed
383
  if (type == C_API_DTYPE_FLOAT32) {
Guolin Ke's avatar
Guolin Ke committed
384
    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
385
  } else if (type == C_API_DTYPE_INT32) {
Guolin Ke's avatar
Guolin Ke committed
386
    is_success = dataset->SetIntField(field_name, reinterpret_cast<const int*>(field_data), static_cast<int32_t>(num_element));
387
  }
388
389
  if (!is_success) { throw std::runtime_error("Input data type erorr or field not found"); }
  API_END();
390
391
392
393
}

DllExport int LGBM_DatasetGetField(DatesetHandle handle,
  const char* field_name,
394
  int64_t* out_len,
395
396
  const void** out_ptr,
  int* out_type) {
397
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
398
  auto dataset = reinterpret_cast<Dataset*>(handle);
399
  bool is_success = false;
Guolin Ke's avatar
Guolin Ke committed
400
  if (dataset->GetFloatField(field_name, out_len, reinterpret_cast<const float**>(out_ptr))) {
Guolin Ke's avatar
Guolin Ke committed
401
    *out_type = C_API_DTYPE_FLOAT32;
402
    is_success = true;
Guolin Ke's avatar
Guolin Ke committed
403
  } else if (dataset->GetIntField(field_name, out_len, reinterpret_cast<const int**>(out_ptr))) {
Guolin Ke's avatar
Guolin Ke committed
404
    *out_type = C_API_DTYPE_INT32;
405
    is_success = true;
406
  }
Guolin Ke's avatar
Guolin Ke committed
407
  if (!is_success) { throw std::runtime_error("Field not found or not exist"); }
408
  API_END();
409
410
411
}

DllExport int LGBM_DatasetGetNumData(DatesetHandle handle,
412
  int64_t* out) {
413
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
414
415
  auto dataset = reinterpret_cast<Dataset*>(handle);
  *out = dataset->num_data();
416
  API_END();
417
418
419
}

DllExport int LGBM_DatasetGetNumFeature(DatesetHandle handle,
420
  int64_t* out) {
421
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
422
423
  auto dataset = reinterpret_cast<Dataset*>(handle);
  *out = dataset->num_total_features();
424
  API_END();
Guolin Ke's avatar
Guolin Ke committed
425
}
426
427
428
429
430
431
432
433


// ---- start of booster

DllExport int LGBM_BoosterCreate(const DatesetHandle train_data,
  const DatesetHandle valid_datas[],
  int n_valid_datas,
  const char* parameters,
434
  const char* init_model_filename,
435
  BoosterHandle* out) {
436
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
437
  const Dataset* p_train_data = reinterpret_cast<const Dataset*>(train_data);
438
439
  std::vector<const Dataset*> p_valid_datas;
  for (int i = 0; i < n_valid_datas; ++i) {
Guolin Ke's avatar
Guolin Ke committed
440
    p_valid_datas.emplace_back(reinterpret_cast<const Dataset*>(valid_datas[i]));
441
  }
Guolin Ke's avatar
Guolin Ke committed
442
  auto ret = std::unique_ptr<Booster>(new Booster(p_train_data, p_valid_datas, parameters));
443
444
445
446
  if (init_model_filename != nullptr) {
    ret->LoadModelFromFile(init_model_filename);
  }
  *out = ret.release();
447
  API_END();
448
449
}

450
DllExport int LGBM_BoosterCreateFromModelfile(
451
452
  const char* filename,
  BoosterHandle* out) {
453
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
454
  *out = new Booster(filename);
455
  API_END();
456
457
458
}

DllExport int LGBM_BoosterFree(BoosterHandle handle) {
459
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
460
  delete reinterpret_cast<Booster*>(handle);
461
  API_END();
462
463
464
}

DllExport int LGBM_BoosterUpdateOneIter(BoosterHandle handle, int* is_finished) {
465
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
466
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
467
468
469
470
471
  if (ref_booster->TrainOneIter()) {
    *is_finished = 1;
  } else {
    *is_finished = 0;
  }
472
  API_END();
473
474
475
476
477
478
}

DllExport int LGBM_BoosterUpdateOneIterCustom(BoosterHandle handle,
  const float* grad,
  const float* hess,
  int* is_finished) {
479
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
480
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
481
482
483
484
485
  if (ref_booster->TrainOneIter(grad, hess)) {
    *is_finished = 1;
  } else {
    *is_finished = 0;
  }
486
  API_END();
487
488
}

Guolin Ke's avatar
Guolin Ke committed
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
/*!
* \brief Get number of eval
* \return total number of eval result
*/
DllExport int LGBM_BoosterGetEvalCounts(BoosterHandle handle, int64_t* out_len) {
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  *out_len = ref_booster->GetEvalCounts();
  API_END();
}

/*!
* \brief Get number of eval
* \return total number of eval result
*/
DllExport int LGBM_BoosterGetEvalNames(BoosterHandle handle, int64_t* out_len, const char*** out_strs) {
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  *out_len = ref_booster->GetEvalNames(out_strs);
  API_END();
}


DllExport int LGBM_BoosterGetEval(BoosterHandle handle,
513
  int data,
514
  int64_t* out_len,
Guolin Ke's avatar
Guolin Ke committed
515
  float* out_results) {
516
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
517
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
518
519
  auto boosting = ref_booster->GetBoosting();
  auto result_buf = boosting->GetEvalAt(data);
520
  *out_len = static_cast<int64_t>(result_buf.size());
521
  for (size_t i = 0; i < result_buf.size(); ++i) {
Guolin Ke's avatar
Guolin Ke committed
522
    (out_results)[i] = static_cast<float>(result_buf[i]);
523
  }
524
  API_END();
525
526
}

Guolin Ke's avatar
Guolin Ke committed
527
DllExport int LGBM_BoosterGetTrainingScore(BoosterHandle handle,
528
  int64_t* out_len,
529
  const float** out_result) {
530
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
531
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
532
  int len = 0;
533
  *out_result = ref_booster->GetTrainingScore(&len);
534
  *out_len = static_cast<int64_t>(len);
535
  API_END();
536
537
}

Guolin Ke's avatar
Guolin Ke committed
538
539
DllExport int LGBM_BoosterGetPredict(BoosterHandle handle,
  int data,
540
  int64_t* out_len,
Guolin Ke's avatar
Guolin Ke committed
541
  float* out_result) {
542
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
543
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
Guolin Ke's avatar
Guolin Ke committed
544
545
  auto boosting = ref_booster->GetBoosting();
  int len = 0;
Guolin Ke's avatar
Guolin Ke committed
546
  boosting->GetPredictAt(data, out_result, &len);
547
  *out_len = static_cast<int64_t>(len);
548
  API_END();
Guolin Ke's avatar
Guolin Ke committed
549
550
}

551
552
553
554
555
556
DllExport int LGBM_BoosterPredictForFile(BoosterHandle handle,
  int predict_type,
  int64_t n_used_trees,
  int data_has_header,
  const char* data_filename,
  const char* result_filename) {
557
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
558
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
559
560
561
  ref_booster->PrepareForPrediction(static_cast<int>(n_used_trees), predict_type);
  bool bool_data_has_header = data_has_header > 0 ? true : false;
  ref_booster->PredictForFile(data_filename, result_filename, bool_data_has_header);
562
  API_END();
563
564
}

565
DllExport int LGBM_BoosterPredictForCSR(BoosterHandle handle,
566
567
  const void* indptr,
  int indptr_type,
568
569
  const int32_t* indices,
  const void* data,
570
571
572
573
  int data_type,
  int64_t nindptr,
  int64_t nelem,
  int64_t,
574
  int predict_type,
575
  int64_t n_used_trees,
Guolin Ke's avatar
Guolin Ke committed
576
  double* out_result) {
577
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
578
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
Guolin Ke's avatar
Guolin Ke committed
579
580
  ref_booster->PrepareForPrediction(static_cast<int>(n_used_trees), predict_type);

581
  auto get_row_fun = RowFunctionFromCSR(indptr, indptr_type, indices, data, data_type, nindptr, nelem);
Guolin Ke's avatar
Guolin Ke committed
582
  int num_class = ref_booster->NumberOfClasses();
Guolin Ke's avatar
Guolin Ke committed
583
584
585
586
587
  int nrow = static_cast<int>(nindptr - 1);
#pragma omp parallel for schedule(guided)
  for (int i = 0; i < nrow; ++i) {
    auto one_row = get_row_fun(i);
    auto predicton_result = ref_booster->Predict(one_row);
Guolin Ke's avatar
Guolin Ke committed
588
    for (int j = 0; j < num_class; ++j) {
Guolin Ke's avatar
Guolin Ke committed
589
590
591
      out_result[i * num_class + j] = predicton_result[j];
    }
  }
592
  API_END();
Guolin Ke's avatar
Guolin Ke committed
593
}
594
595
596

DllExport int LGBM_BoosterPredictForMat(BoosterHandle handle,
  const void* data,
597
  int data_type,
598
599
  int32_t nrow,
  int32_t ncol,
Guolin Ke's avatar
Guolin Ke committed
600
  int is_row_major,
601
  int predict_type,
602
  int64_t n_used_trees,
Guolin Ke's avatar
Guolin Ke committed
603
  double* out_result) {
604
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
605
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
Guolin Ke's avatar
Guolin Ke committed
606
607
  ref_booster->PrepareForPrediction(static_cast<int>(n_used_trees), predict_type);

608
  auto get_row_fun = RowPairFunctionFromDenseMatric(data, nrow, ncol, data_type, is_row_major);
Guolin Ke's avatar
Guolin Ke committed
609
  int num_class = ref_booster->NumberOfClasses();
Guolin Ke's avatar
Guolin Ke committed
610
611
612
613
#pragma omp parallel for schedule(guided)
  for (int i = 0; i < nrow; ++i) {
    auto one_row = get_row_fun(i);
    auto predicton_result = ref_booster->Predict(one_row);
Guolin Ke's avatar
Guolin Ke committed
614
    for (int j = 0; j < num_class; ++j) {
Guolin Ke's avatar
Guolin Ke committed
615
616
617
      out_result[i * num_class + j] = predicton_result[j];
    }
  }
618
  API_END();
Guolin Ke's avatar
Guolin Ke committed
619
}
620
621
622

DllExport int LGBM_BoosterSaveModel(BoosterHandle handle,
  int num_used_model,
Guolin Ke's avatar
Guolin Ke committed
623
  const char* filename) {
624
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
625
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
Guolin Ke's avatar
Guolin Ke committed
626
  ref_booster->SaveModelToFile(num_used_model, filename);
627
  API_END();
Guolin Ke's avatar
Guolin Ke committed
628
}
629

Guolin Ke's avatar
Guolin Ke committed
630
// ---- start of some help functions
631
632
633

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
634
  if (data_type == C_API_DTYPE_FLOAT32) {
635
636
637
    const float* data_ptr = reinterpret_cast<const float*>(data);
    if (is_row_major) {
      return [data_ptr, num_col, num_row](int row_idx) {
Guolin Ke's avatar
Guolin Ke committed
638
        std::vector<double> ret(num_col);
639
640
        auto tmp_ptr = data_ptr + num_col * row_idx;
        for (int i = 0; i < num_col; ++i) {
Guolin Ke's avatar
Guolin Ke committed
641
          ret[i] = static_cast<double>(*(tmp_ptr + i));
642
643
644
645
646
        }
        return ret;
      };
    } else {
      return [data_ptr, num_col, num_row](int row_idx) {
Guolin Ke's avatar
Guolin Ke committed
647
        std::vector<double> ret(num_col);
648
        for (int i = 0; i < num_col; ++i) {
Guolin Ke's avatar
Guolin Ke committed
649
          ret[i] = static_cast<double>(*(data_ptr + num_row * i + row_idx));
650
651
652
653
        }
        return ret;
      };
    }
Guolin Ke's avatar
Guolin Ke committed
654
  } else if (data_type == C_API_DTYPE_FLOAT64) {
655
656
657
    const double* data_ptr = reinterpret_cast<const double*>(data);
    if (is_row_major) {
      return [data_ptr, num_col, num_row](int row_idx) {
Guolin Ke's avatar
Guolin Ke committed
658
        std::vector<double> ret(num_col);
659
660
        auto tmp_ptr = data_ptr + num_col * row_idx;
        for (int i = 0; i < num_col; ++i) {
Guolin Ke's avatar
Guolin Ke committed
661
          ret[i] = static_cast<double>(*(tmp_ptr + i));
662
663
664
665
666
        }
        return ret;
      };
    } else {
      return [data_ptr, num_col, num_row](int row_idx) {
Guolin Ke's avatar
Guolin Ke committed
667
        std::vector<double> ret(num_col);
668
        for (int i = 0; i < num_col; ++i) {
Guolin Ke's avatar
Guolin Ke committed
669
          ret[i] = static_cast<double>(*(data_ptr + num_row * i + row_idx));
670
671
672
673
674
        }
        return ret;
      };
    }
  }
Guolin Ke's avatar
Guolin Ke committed
675
  throw std::runtime_error("unknown data type in RowFunctionFromDenseMatric");
676
677
678
679
}

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
680
681
682
683
684
685
686
687
  auto inner_function = RowFunctionFromDenseMatric(data, num_row, num_col, data_type, is_row_major);
  if (inner_function != nullptr) {
    return [inner_function](int row_idx) {
      auto raw_values = inner_function(row_idx);
      std::vector<std::pair<int, double>> ret;
      for (int i = 0; i < static_cast<int>(raw_values.size()); ++i) {
        if (std::fabs(raw_values[i]) > 1e-15) {
          ret.emplace_back(i, raw_values[i]);
688
        }
Guolin Ke's avatar
Guolin Ke committed
689
690
691
      }
      return ret;
    };
692
  }
Guolin Ke's avatar
Guolin Ke committed
693
  return nullptr;
694
695
696
697
}

std::function<std::vector<std::pair<int, double>>(int idx)>
RowFunctionFromCSR(const void* indptr, int indptr_type, const int32_t* indices, const void* data, int data_type, int64_t nindptr, int64_t nelem) {
Guolin Ke's avatar
Guolin Ke committed
698
  if (data_type == C_API_DTYPE_FLOAT32) {
699
    const float* data_ptr = reinterpret_cast<const float*>(data);
Guolin Ke's avatar
Guolin Ke committed
700
    if (indptr_type == C_API_DTYPE_INT32) {
701
702
703
704
705
      const int32_t* ptr_indptr = reinterpret_cast<const int32_t*>(indptr);
      return [ptr_indptr, indices, data_ptr, nindptr, nelem](int idx) {
        std::vector<std::pair<int, double>> ret;
        int64_t start = ptr_indptr[idx];
        int64_t end = ptr_indptr[idx + 1];
Guolin Ke's avatar
Guolin Ke committed
706
        for (int64_t i = start; i < end; ++i) {
707
708
709
710
          ret.emplace_back(indices[i], data_ptr[i]);
        }
        return ret;
      };
Guolin Ke's avatar
Guolin Ke committed
711
    } else if (indptr_type == C_API_DTYPE_INT64) {
712
713
714
715
716
      const int64_t* ptr_indptr = reinterpret_cast<const int64_t*>(indptr);
      return [ptr_indptr, indices, data_ptr, nindptr, nelem](int idx) {
        std::vector<std::pair<int, double>> ret;
        int64_t start = ptr_indptr[idx];
        int64_t end = ptr_indptr[idx + 1];
Guolin Ke's avatar
Guolin Ke committed
717
        for (int64_t i = start; i < end; ++i) {
718
719
720
721
722
          ret.emplace_back(indices[i], data_ptr[i]);
        }
        return ret;
      };
    }
Guolin Ke's avatar
Guolin Ke committed
723
  } else if (data_type == C_API_DTYPE_FLOAT64) {
724
    const double* data_ptr = reinterpret_cast<const double*>(data);
Guolin Ke's avatar
Guolin Ke committed
725
    if (indptr_type == C_API_DTYPE_INT32) {
726
727
728
729
730
      const int32_t* ptr_indptr = reinterpret_cast<const int32_t*>(indptr);
      return [ptr_indptr, indices, data_ptr, nindptr, nelem](int idx) {
        std::vector<std::pair<int, double>> ret;
        int64_t start = ptr_indptr[idx];
        int64_t end = ptr_indptr[idx + 1];
Guolin Ke's avatar
Guolin Ke committed
731
        for (int64_t i = start; i < end; ++i) {
732
733
734
735
          ret.emplace_back(indices[i], data_ptr[i]);
        }
        return ret;
      };
Guolin Ke's avatar
Guolin Ke committed
736
    } else if (indptr_type == C_API_DTYPE_INT64) {
737
738
739
740
741
      const int64_t* ptr_indptr = reinterpret_cast<const int64_t*>(indptr);
      return [ptr_indptr, indices, data_ptr, nindptr, nelem](int idx) {
        std::vector<std::pair<int, double>> ret;
        int64_t start = ptr_indptr[idx];
        int64_t end = ptr_indptr[idx + 1];
Guolin Ke's avatar
Guolin Ke committed
742
        for (int64_t i = start; i < end; ++i) {
743
744
745
746
          ret.emplace_back(indices[i], data_ptr[i]);
        }
        return ret;
      };
Guolin Ke's avatar
Guolin Ke committed
747
748
749
    } 
  } 
  throw std::runtime_error("unknown data type in RowFunctionFromCSR");
750
751
752
753
}

std::function<std::vector<std::pair<int, double>>(int idx)>
ColumnFunctionFromCSC(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) {
Guolin Ke's avatar
Guolin Ke committed
754
  if (data_type == C_API_DTYPE_FLOAT32) {
755
    const float* data_ptr = reinterpret_cast<const float*>(data);
Guolin Ke's avatar
Guolin Ke committed
756
    if (col_ptr_type == C_API_DTYPE_INT32) {
757
758
759
760
761
762
763
764
765
766
      const int32_t* ptr_col_ptr = reinterpret_cast<const int32_t*>(col_ptr);
      return [ptr_col_ptr, indices, data_ptr, ncol_ptr, nelem](int idx) {
        std::vector<std::pair<int, double>> ret;
        int64_t start = ptr_col_ptr[idx];
        int64_t end = ptr_col_ptr[idx + 1];
        for (int64_t i = start; i < end; ++i) {
          ret.emplace_back(indices[i], data_ptr[i]);
        }
        return ret;
      };
Guolin Ke's avatar
Guolin Ke committed
767
    } else if (col_ptr_type == C_API_DTYPE_INT64) {
768
769
770
771
772
773
774
775
776
777
      const int64_t* ptr_col_ptr = reinterpret_cast<const int64_t*>(col_ptr);
      return [ptr_col_ptr, indices, data_ptr, ncol_ptr, nelem](int idx) {
        std::vector<std::pair<int, double>> ret;
        int64_t start = ptr_col_ptr[idx];
        int64_t end = ptr_col_ptr[idx + 1];
        for (int64_t i = start; i < end; ++i) {
          ret.emplace_back(indices[i], data_ptr[i]);
        }
        return ret;
      };
Guolin Ke's avatar
Guolin Ke committed
778
    } 
Guolin Ke's avatar
Guolin Ke committed
779
  } else if (data_type == C_API_DTYPE_FLOAT64) {
780
    const double* data_ptr = reinterpret_cast<const double*>(data);
Guolin Ke's avatar
Guolin Ke committed
781
    if (col_ptr_type == C_API_DTYPE_INT32) {
782
783
784
785
786
787
788
789
790
791
      const int32_t* ptr_col_ptr = reinterpret_cast<const int32_t*>(col_ptr);
      return [ptr_col_ptr, indices, data_ptr, ncol_ptr, nelem](int idx) {
        std::vector<std::pair<int, double>> ret;
        int64_t start = ptr_col_ptr[idx];
        int64_t end = ptr_col_ptr[idx + 1];
        for (int64_t i = start; i < end; ++i) {
          ret.emplace_back(indices[i], data_ptr[i]);
        }
        return ret;
      };
Guolin Ke's avatar
Guolin Ke committed
792
    } else if (col_ptr_type == C_API_DTYPE_INT64) {
793
794
795
796
797
798
799
800
801
802
      const int64_t* ptr_col_ptr = reinterpret_cast<const int64_t*>(col_ptr);
      return [ptr_col_ptr, indices, data_ptr, ncol_ptr, nelem](int idx) {
        std::vector<std::pair<int, double>> ret;
        int64_t start = ptr_col_ptr[idx];
        int64_t end = ptr_col_ptr[idx + 1];
        for (int64_t i = start; i < end; ++i) {
          ret.emplace_back(indices[i], data_ptr[i]);
        }
        return ret;
      };
Guolin Ke's avatar
Guolin Ke committed
803
804
805
    } 
  } 
  throw std::runtime_error("unknown data type in ColumnFunctionFromCSC");
806
807
}

808
std::vector<double> SampleFromOneColumn(const std::vector<std::pair<int, double>>& data, const std::vector<int>& indices) {
809
810
811
812
813
814
815
816
817
818
819
  size_t j = 0;
  std::vector<double> ret;
  for (auto row_idx : indices) {
    while (j < data.size() && data[j].first < static_cast<int>(row_idx)) {
      ++j;
    }
    if (j < data.size() && data[j].first == static_cast<int>(row_idx)) {
      ret.push_back(data[j].second);
    }
  }
  return ret;
Guolin Ke's avatar
Guolin Ke committed
820
}