"tests/git@developer.sourcefind.cn:tianlh/lightgbm-dcu.git" did not exist on "d4658fbb6fe943e9afee8c639934339cff38fd90"
c_api.cpp 29.5 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
  }

  Booster(const Dataset* train_data, 
31
    const char* parameters) {
Guolin Ke's avatar
Guolin Ke committed
32
33
34
    config_.LoadFromString(parameters);
    // create boosting
    if (config_.io_config.input_model.size() > 0) {
Guolin Ke's avatar
Guolin Ke committed
35
      Log::Warning("continued train from model is not support for c_api, \
Guolin Ke's avatar
Guolin Ke committed
36
37
        please use continued train with input score");
    }
Guolin Ke's avatar
Guolin Ke committed
38
    boosting_.reset(Boosting::CreateBoosting(config_.boosting_type, ""));
39
40
41
42
43
44
    ConstructObjectAndTrainingMetrics(train_data);
    // initialize the boosting
    boosting_->Init(&config_.boosting_config, train_data, objective_fun_.get(),
      Common::ConstPtrInVectorWrapper<Metric>(train_metric_));
  }

Guolin Ke's avatar
Guolin Ke committed
45
46
47
48
  void MergeFrom(const Booster* other) {
    boosting_->MergeFrom(other->boosting_.get());
  }

49
50
51
52
53
  ~Booster() {

  }

  void ConstructObjectAndTrainingMetrics(const Dataset* train_data) {
Guolin Ke's avatar
Guolin Ke committed
54
    // create objective function
Guolin Ke's avatar
Guolin Ke committed
55
56
57
58
59
    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
60
    // create training metric
61
    train_metric_.clear();
Guolin Ke's avatar
Guolin Ke committed
62
    for (auto metric_type : config_.metric_types) {
Guolin Ke's avatar
Guolin Ke committed
63
64
      auto metric = std::unique_ptr<Metric>(
        Metric::CreateMetric(metric_type, config_.metric_config));
Guolin Ke's avatar
Guolin Ke committed
65
      if (metric == nullptr) { continue; }
66
      metric->Init(train_data->metadata(), train_data->num_data());
Guolin Ke's avatar
Guolin Ke committed
67
      train_metric_.push_back(std::move(metric));
Guolin Ke's avatar
Guolin Ke committed
68
    }
Guolin Ke's avatar
Guolin Ke committed
69
    train_metric_.shrink_to_fit();
Guolin Ke's avatar
Guolin Ke committed
70
    // initialize the objective function
Guolin Ke's avatar
Guolin Ke committed
71
    if (objective_fun_ != nullptr) {
72
      objective_fun_->Init(train_data->metadata(), train_data->num_data());
Guolin Ke's avatar
Guolin Ke committed
73
74
    }
  }
Guolin Ke's avatar
Guolin Ke committed
75

76
77
78
79
  void ResetTrainingData(const Dataset* train_data) {
    ConstructObjectAndTrainingMetrics(train_data);
    // initialize the boosting
    boosting_->ResetTrainingData(train_data, objective_fun_.get(), Common::ConstPtrInVectorWrapper<Metric>(train_metric_));
80
  }
Guolin Ke's avatar
Guolin Ke committed
81

82
83
84
85
86
87
88
89
90
91
92
  void AddValidData(const Dataset* valid_data) {
    valid_metrics_.emplace_back();
    for (auto metric_type : config_.metric_types) {
      auto metric = std::unique_ptr<Metric>(Metric::CreateMetric(metric_type, config_.metric_config));
      if (metric == nullptr) { continue; }
      metric->Init(valid_data->metadata(), valid_data->num_data());
      valid_metrics_.back().push_back(std::move(metric));
    }
    valid_metrics_.back().shrink_to_fit();
    boosting_->AddValidDataset(valid_data,
      Common::ConstPtrInVectorWrapper<Metric>(valid_metrics_.back()));
Guolin Ke's avatar
Guolin Ke committed
93
  }
94
95
96
97
98
99
100
101
  bool TrainOneIter() {
    return boosting_->TrainOneIter(nullptr, nullptr, false);
  }

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

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

Guolin Ke's avatar
Guolin Ke committed
116
117
118
119
  void GetPredictAt(int data_idx, score_t* out_result, data_size_t* out_len) {
    boosting_->GetPredictAt(data_idx, out_result, out_len);
  }

Guolin Ke's avatar
Guolin Ke committed
120
121
  std::vector<double> Predict(const std::vector<std::pair<int, double>>& features) {
    return predictor_->GetPredictFunction()(features);
122
123
  }

124
125
126
127
  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
128
129
  void SaveModelToFile(int num_iteration, const char* filename) {
    boosting_->SaveModelToFile(num_iteration, true, filename);
Guolin Ke's avatar
Guolin Ke committed
130
  }
Guolin Ke's avatar
Guolin Ke committed
131
132
133
134
135
136
137
138
139

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

Guolin Ke's avatar
Guolin Ke committed
140
  int GetEvalNames(char** out_strs) const {
Guolin Ke's avatar
Guolin Ke committed
141
142
143
    int idx = 0;
    for (const auto& metric : train_metric_) {
      for (const auto& name : metric->GetName()) {
Guolin Ke's avatar
Guolin Ke committed
144
145
146
147
148
149
150
151
        int j = 0;
        auto name_cstr = name.c_str();
        while (name_cstr[j] != '\0') {
          out_strs[idx][j] = name_cstr[j];
          ++j;
        }
        out_strs[idx][j] = '\0';
        ++idx;
Guolin Ke's avatar
Guolin Ke committed
152
153
154
155
156
      }
    }
    return idx;
  }

157
  void ResetBoostingConfig(const char* parameters) {
158
    config_.LoadFromString(parameters);
159
160
161
162
163
164
165
    boosting_->ResetConfig(&config_.boosting_config);
  }

  void RollbackOneIter() {
    boosting_->RollbackOneIter();
  }

Guolin Ke's avatar
Guolin Ke committed
166
  const Boosting* GetBoosting() const { return boosting_.get(); }
Guolin Ke's avatar
Guolin Ke committed
167
  
Guolin Ke's avatar
Guolin Ke committed
168
private:
Guolin Ke's avatar
Guolin Ke committed
169
  std::unique_ptr<Boosting> boosting_;
Guolin Ke's avatar
Guolin Ke committed
170
171
172
  /*! \brief All configs */
  OverallConfig config_;
  /*! \brief Metric for training data */
Guolin Ke's avatar
Guolin Ke committed
173
  std::vector<std::unique_ptr<Metric>> train_metric_;
Guolin Ke's avatar
Guolin Ke committed
174
  /*! \brief Metrics for validation data */
Guolin Ke's avatar
Guolin Ke committed
175
  std::vector<std::vector<std::unique_ptr<Metric>>> valid_metrics_;
Guolin Ke's avatar
Guolin Ke committed
176
  /*! \brief Training objective function */
Guolin Ke's avatar
Guolin Ke committed
177
  std::unique_ptr<ObjectiveFunction> objective_fun_;
Guolin Ke's avatar
Guolin Ke committed
178
  /*! \brief Using predictor for prediction task */
Guolin Ke's avatar
Guolin Ke committed
179
  std::unique_ptr<Predictor> predictor_;
180

Guolin Ke's avatar
Guolin Ke committed
181
182
183
};

}
Guolin Ke's avatar
Guolin Ke committed
184
185
186

using namespace LightGBM;

Guolin Ke's avatar
Guolin Ke committed
187
DllExport const char* LGBM_GetLastError() {
188
  return LastErrorMsg().c_str();
Guolin Ke's avatar
Guolin Ke committed
189
190
191
192
193
194
}

DllExport int LGBM_CreateDatasetFromFile(const char* filename,
  const char* parameters,
  const DatesetHandle* reference,
  DatesetHandle* out) {
195
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
196
197
198
  OverallConfig config;
  config.LoadFromString(parameters);
  DatasetLoader loader(config.io_config, nullptr);
199
  loader.SetHeader(filename);
Guolin Ke's avatar
Guolin Ke committed
200
  if (reference == nullptr) {
Guolin Ke's avatar
Guolin Ke committed
201
    *out = loader.LoadFromFile(filename);
Guolin Ke's avatar
Guolin Ke committed
202
  } else {
Guolin Ke's avatar
Guolin Ke committed
203
204
    *out = loader.LoadFromFileAlignWithOtherDataset(filename,
      reinterpret_cast<const Dataset*>(*reference));
Guolin Ke's avatar
Guolin Ke committed
205
  }
206
  API_END();
Guolin Ke's avatar
Guolin Ke committed
207
208
209
210
}

DllExport int LGBM_CreateDatasetFromBinaryFile(const char* filename,
  DatesetHandle* out) {
211
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
212
213
  OverallConfig config;
  DatasetLoader loader(config.io_config, nullptr);
Guolin Ke's avatar
Guolin Ke committed
214
  *out = loader.LoadFromBinFile(filename, 0, 1);
215
  API_END();
Guolin Ke's avatar
Guolin Ke committed
216
217
218
}

DllExport int LGBM_CreateDatasetFromMat(const void* data,
219
  int data_type,
Guolin Ke's avatar
Guolin Ke committed
220
221
222
223
224
225
  int32_t nrow,
  int32_t ncol,
  int is_row_major,
  const char* parameters,
  const DatesetHandle* reference,
  DatesetHandle* out) {
226
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
227
228
229
  OverallConfig config;
  config.LoadFromString(parameters);
  DatasetLoader loader(config.io_config, nullptr);
Guolin Ke's avatar
Guolin Ke committed
230
  std::unique_ptr<Dataset> ret;
231
  auto get_row_fun = RowFunctionFromDenseMatric(data, nrow, ncol, data_type, is_row_major);
Guolin Ke's avatar
Guolin Ke committed
232
233
234
  if (reference == nullptr) {
    // sample data first
    Random rand(config.io_config.data_random_seed);
235
    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
236
    auto sample_indices = rand.Sample(nrow, sample_cnt);
237
    std::vector<std::vector<double>> sample_values(ncol);
Guolin Ke's avatar
Guolin Ke committed
238
    for (size_t i = 0; i < sample_indices.size(); ++i) {
Guolin Ke's avatar
Guolin Ke committed
239
      auto idx = sample_indices[i];
240
      auto row = get_row_fun(static_cast<int>(idx));
Guolin Ke's avatar
Guolin Ke committed
241
      for (size_t j = 0; j < row.size(); ++j) {
Guolin Ke's avatar
Guolin Ke committed
242
243
244
        if (std::fabs(row[j]) > 1e-15) {
          sample_values[j].push_back(row[j]);
        }
Guolin Ke's avatar
Guolin Ke committed
245
246
      }
    }
Guolin Ke's avatar
Guolin Ke committed
247
    ret.reset(loader.CostructFromSampleData(sample_values, sample_cnt, nrow));
Guolin Ke's avatar
Guolin Ke committed
248
  } else {
Guolin Ke's avatar
Guolin Ke committed
249
250
    ret.reset(new Dataset(nrow, config.io_config.num_class));
    ret->CopyFeatureMapperFrom(
Guolin Ke's avatar
Guolin Ke committed
251
      reinterpret_cast<const Dataset*>(*reference),
Guolin Ke's avatar
Guolin Ke committed
252
      config.io_config.is_enable_sparse);
Guolin Ke's avatar
Guolin Ke committed
253
254
255
256
257
  }

#pragma omp parallel for schedule(guided)
  for (int i = 0; i < nrow; ++i) {
    const int tid = omp_get_thread_num();
258
    auto one_row = get_row_fun(i);
Guolin Ke's avatar
Guolin Ke committed
259
260
261
    ret->PushOneRow(tid, i, one_row);
  }
  ret->FinishLoad();
Guolin Ke's avatar
Guolin Ke committed
262
  *out = ret.release();
263
  API_END();
264
265
}

266
267
DllExport int LGBM_CreateDatasetFromCSR(const void* indptr,
  int indptr_type,
268
269
  const int32_t* indices,
  const void* data,
270
271
272
273
  int data_type,
  int64_t nindptr,
  int64_t nelem,
  int64_t num_col,
274
275
276
  const char* parameters,
  const DatesetHandle* reference,
  DatesetHandle* out) {
277
  API_BEGIN();
278
279
280
  OverallConfig config;
  config.LoadFromString(parameters);
  DatasetLoader loader(config.io_config, nullptr);
Guolin Ke's avatar
Guolin Ke committed
281
  std::unique_ptr<Dataset> ret;
282
  auto get_row_fun = RowFunctionFromCSR(indptr, indptr_type, indices, data, data_type, nindptr, nelem);
283
284
285
286
  int32_t nrow = static_cast<int32_t>(nindptr - 1);
  if (reference == nullptr) {
    // sample data first
    Random rand(config.io_config.data_random_seed);
287
    const int sample_cnt = static_cast<int>(nrow < config.io_config.bin_construct_sample_cnt ? nrow : config.io_config.bin_construct_sample_cnt);
288
289
290
291
292
293
    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
294
295
296
297
298
299
300
        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();
            }
301
          }
Guolin Ke's avatar
Guolin Ke committed
302
303
          // edit the feature value
          sample_values[inner_data.first].push_back(inner_data.second);
304
305
306
        }
      }
    }
307
    CHECK(num_col >= static_cast<int>(sample_values.size()));
Guolin Ke's avatar
Guolin Ke committed
308
    ret.reset(loader.CostructFromSampleData(sample_values, sample_cnt, nrow));
309
  } else {
Guolin Ke's avatar
Guolin Ke committed
310
311
    ret.reset(new Dataset(nrow, config.io_config.num_class));
    ret->CopyFeatureMapperFrom(
Guolin Ke's avatar
Guolin Ke committed
312
      reinterpret_cast<const Dataset*>(*reference),
Guolin Ke's avatar
Guolin Ke committed
313
      config.io_config.is_enable_sparse);
314
315
316
317
318
319
320
321
322
  }

#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
323
  *out = ret.release();
324
  API_END();
325
326
}

327
328
DllExport int LGBM_CreateDatasetFromCSC(const void* col_ptr,
  int col_ptr_type,
Guolin Ke's avatar
Guolin Ke committed
329
330
  const int32_t* indices,
  const void* data,
331
332
333
334
  int data_type,
  int64_t ncol_ptr,
  int64_t nelem,
  int64_t num_row,
Guolin Ke's avatar
Guolin Ke committed
335
336
337
  const char* parameters,
  const DatesetHandle* reference,
  DatesetHandle* out) {
338
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
339
340
341
  OverallConfig config;
  config.LoadFromString(parameters);
  DatasetLoader loader(config.io_config, nullptr);
Guolin Ke's avatar
Guolin Ke committed
342
  std::unique_ptr<Dataset> ret;
343
  auto get_col_fun = ColumnFunctionFromCSC(col_ptr, col_ptr_type, indices, data, data_type, ncol_ptr, nelem);
Guolin Ke's avatar
Guolin Ke committed
344
345
346
347
348
  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);
349
    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
350
351
352
353
354
    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);
355
      sample_values[i] = SampleFromOneColumn(cur_col, sample_indices);
Guolin Ke's avatar
Guolin Ke committed
356
    }
Guolin Ke's avatar
Guolin Ke committed
357
    ret.reset(loader.CostructFromSampleData(sample_values, sample_cnt, nrow));
Guolin Ke's avatar
Guolin Ke committed
358
  } else {
Guolin Ke's avatar
Guolin Ke committed
359
360
    ret.reset(new Dataset(nrow, config.io_config.num_class));
    ret->CopyFeatureMapperFrom(
Guolin Ke's avatar
Guolin Ke committed
361
      reinterpret_cast<const Dataset*>(*reference),
Guolin Ke's avatar
Guolin Ke committed
362
      config.io_config.is_enable_sparse);
Guolin Ke's avatar
Guolin Ke committed
363
364
365
366
367
368
  }

#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
369
    ret->PushOneColumn(tid, i, one_col);
Guolin Ke's avatar
Guolin Ke committed
370
371
  }
  ret->FinishLoad();
Guolin Ke's avatar
Guolin Ke committed
372
  *out = ret.release();
373
  API_END();
Guolin Ke's avatar
Guolin Ke committed
374
375
}

376
DllExport int LGBM_DatasetFree(DatesetHandle handle) {
377
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
378
  delete reinterpret_cast<Dataset*>(handle);
379
  API_END();
380
381
382
383
}

DllExport int LGBM_DatasetSaveBinary(DatesetHandle handle,
  const char* filename) {
384
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
385
386
  auto dataset = reinterpret_cast<Dataset*>(handle);
  dataset->SaveBinaryFile(filename);
387
  API_END();
388
389
390
391
392
}

DllExport int LGBM_DatasetSetField(DatesetHandle handle,
  const char* field_name,
  const void* field_data,
393
  int64_t num_element,
394
  int type) {
395
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
396
  auto dataset = reinterpret_cast<Dataset*>(handle);
397
  bool is_success = false;
Guolin Ke's avatar
Guolin Ke committed
398
  if (type == C_API_DTYPE_FLOAT32) {
Guolin Ke's avatar
Guolin Ke committed
399
    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
400
  } else if (type == C_API_DTYPE_INT32) {
Guolin Ke's avatar
Guolin Ke committed
401
    is_success = dataset->SetIntField(field_name, reinterpret_cast<const int*>(field_data), static_cast<int32_t>(num_element));
402
  }
403
404
  if (!is_success) { throw std::runtime_error("Input data type erorr or field not found"); }
  API_END();
405
406
407
408
}

DllExport int LGBM_DatasetGetField(DatesetHandle handle,
  const char* field_name,
409
  int64_t* out_len,
410
411
  const void** out_ptr,
  int* out_type) {
412
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
413
  auto dataset = reinterpret_cast<Dataset*>(handle);
414
  bool is_success = false;
Guolin Ke's avatar
Guolin Ke committed
415
  if (dataset->GetFloatField(field_name, out_len, reinterpret_cast<const float**>(out_ptr))) {
Guolin Ke's avatar
Guolin Ke committed
416
    *out_type = C_API_DTYPE_FLOAT32;
417
    is_success = true;
Guolin Ke's avatar
Guolin Ke committed
418
  } else if (dataset->GetIntField(field_name, out_len, reinterpret_cast<const int**>(out_ptr))) {
Guolin Ke's avatar
Guolin Ke committed
419
    *out_type = C_API_DTYPE_INT32;
420
    is_success = true;
421
  }
422
423
  if (!is_success) { throw std::runtime_error("Field not found"); }
  if (*out_ptr == nullptr) { *out_len = 0; }
424
  API_END();
425
426
427
}

DllExport int LGBM_DatasetGetNumData(DatesetHandle handle,
428
  int64_t* out) {
429
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
430
431
  auto dataset = reinterpret_cast<Dataset*>(handle);
  *out = dataset->num_data();
432
  API_END();
433
434
435
}

DllExport int LGBM_DatasetGetNumFeature(DatesetHandle handle,
436
  int64_t* out) {
437
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
438
439
  auto dataset = reinterpret_cast<Dataset*>(handle);
  *out = dataset->num_total_features();
440
  API_END();
Guolin Ke's avatar
Guolin Ke committed
441
}
442
443
444
445
446
447
448


// ---- start of booster

DllExport int LGBM_BoosterCreate(const DatesetHandle train_data,
  const char* parameters,
  BoosterHandle* out) {
449
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
450
  const Dataset* p_train_data = reinterpret_cast<const Dataset*>(train_data);
451
  auto ret = std::unique_ptr<Booster>(new Booster(p_train_data, parameters));
452
  *out = ret.release();
453
  API_END();
454
455
}

456
DllExport int LGBM_BoosterCreateFromModelfile(
457
  const char* filename,
Guolin Ke's avatar
Guolin Ke committed
458
  int64_t* num_total_model,
459
  BoosterHandle* out) {
460
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
461
462
463
  auto ret = std::unique_ptr<Booster>(new Booster(filename));
  *num_total_model = static_cast<int64_t>(ret->GetBoosting()->NumberOfTotalModel());
  *out = ret.release();
464
  API_END();
465
466
467
}

DllExport int LGBM_BoosterFree(BoosterHandle handle) {
468
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
469
  delete reinterpret_cast<Booster*>(handle);
470
  API_END();
471
472
}

Guolin Ke's avatar
Guolin Ke committed
473
474
475
476
477
478
479
480
DllExport int LGBM_BoosterMerge(BoosterHandle handle,
  BoosterHandle other_handle) {
  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();
}
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499

DllExport int LGBM_BoosterAddValidData(BoosterHandle handle,
  const DatesetHandle valid_data) {
  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();
}

DllExport int LGBM_BoosterResetTrainingData(BoosterHandle handle,
  const DatesetHandle train_data) {
  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();
}

500
501
502
503
504
505
506
DllExport int LGBM_BoosterResetParameter(BoosterHandle handle, const char* parameters) {
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  ref_booster->ResetBoostingConfig(parameters);
  API_END();
}

Guolin Ke's avatar
Guolin Ke committed
507
508
509
510
511
512
513
DllExport int LGBM_BoosterGetNumClasses(BoosterHandle handle, int64_t* out_len) {
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  *out_len = ref_booster->GetBoosting()->NumberOfClasses();
  API_END();
}

514
DllExport int LGBM_BoosterUpdateOneIter(BoosterHandle handle, int* is_finished) {
515
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
516
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
517
518
519
520
521
  if (ref_booster->TrainOneIter()) {
    *is_finished = 1;
  } else {
    *is_finished = 0;
  }
522
  API_END();
523
524
525
526
527
528
}

DllExport int LGBM_BoosterUpdateOneIterCustom(BoosterHandle handle,
  const float* grad,
  const float* hess,
  int* is_finished) {
529
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
530
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
531
532
533
534
535
  if (ref_booster->TrainOneIter(grad, hess)) {
    *is_finished = 1;
  } else {
    *is_finished = 0;
  }
536
  API_END();
537
538
}

539
540
541
542
543
544
545
546
547
548
549
550
551
DllExport int LGBM_BoosterRollbackOneIter(BoosterHandle handle) {
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  ref_booster->RollbackOneIter();
  API_END();
}

DllExport int LGBM_BoosterGetCurrentIteration(BoosterHandle handle, int64_t* out_iteration) {
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  *out_iteration = ref_booster->GetBoosting()->GetCurrentIteration();
  API_END();
}
Guolin Ke's avatar
Guolin Ke committed
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
/*!
* \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
*/
Guolin Ke's avatar
Guolin Ke committed
567
DllExport int LGBM_BoosterGetEvalNames(BoosterHandle handle, int64_t* out_len, char** out_strs) {
Guolin Ke's avatar
Guolin Ke committed
568
569
570
571
572
573
574
575
  API_BEGIN();
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
  *out_len = ref_booster->GetEvalNames(out_strs);
  API_END();
}


DllExport int LGBM_BoosterGetEval(BoosterHandle handle,
576
  int data,
577
  int64_t* out_len,
Guolin Ke's avatar
Guolin Ke committed
578
  float* out_results) {
579
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
580
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
581
582
  auto boosting = ref_booster->GetBoosting();
  auto result_buf = boosting->GetEvalAt(data);
583
  *out_len = static_cast<int64_t>(result_buf.size());
584
  for (size_t i = 0; i < result_buf.size(); ++i) {
Guolin Ke's avatar
Guolin Ke committed
585
    (out_results)[i] = static_cast<float>(result_buf[i]);
586
  }
587
  API_END();
588
589
}

Guolin Ke's avatar
Guolin Ke committed
590
591
DllExport int LGBM_BoosterGetPredict(BoosterHandle handle,
  int data,
592
  int64_t* out_len,
Guolin Ke's avatar
Guolin Ke committed
593
  float* out_result) {
594
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
595
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
Guolin Ke's avatar
Guolin Ke committed
596
  int len = 0;
Guolin Ke's avatar
Guolin Ke committed
597
  ref_booster->GetPredictAt(data, out_result, &len);
598
  *out_len = static_cast<int64_t>(len);
599
  API_END();
Guolin Ke's avatar
Guolin Ke committed
600
601
}

602
603
DllExport int LGBM_BoosterPredictForFile(BoosterHandle handle,
  const char* data_filename,
Guolin Ke's avatar
Guolin Ke committed
604
605
606
  int data_has_header,
  int predict_type,
  int64_t num_iteration,
607
  const char* result_filename) {
608
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
609
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
Guolin Ke's avatar
Guolin Ke committed
610
  ref_booster->PrepareForPrediction(static_cast<int>(num_iteration), predict_type);
611
612
  bool bool_data_has_header = data_has_header > 0 ? true : false;
  ref_booster->PredictForFile(data_filename, result_filename, bool_data_has_header);
613
  API_END();
614
615
}

616
DllExport int LGBM_BoosterPredictForCSR(BoosterHandle handle,
617
618
  const void* indptr,
  int indptr_type,
619
620
  const int32_t* indices,
  const void* data,
621
622
623
624
  int data_type,
  int64_t nindptr,
  int64_t nelem,
  int64_t,
625
  int predict_type,
Guolin Ke's avatar
Guolin Ke committed
626
627
628
  int64_t num_iteration,
  int64_t* out_len,
  float* out_result) {
629
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
630
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
Guolin Ke's avatar
Guolin Ke committed
631
  ref_booster->PrepareForPrediction(static_cast<int>(num_iteration), predict_type);
Guolin Ke's avatar
Guolin Ke committed
632

633
  auto get_row_fun = RowFunctionFromCSR(indptr, indptr_type, indices, data, data_type, nindptr, nelem);
Guolin Ke's avatar
Guolin Ke committed
634
635
636
637
638
639
640
641
  int num_preb_in_one_row = ref_booster->GetBoosting()->NumberOfClasses();
  if (predict_type == C_API_PREDICT_LEAF_INDEX) {
    if (num_iteration > 0) {
      num_preb_in_one_row *= static_cast<int>(num_iteration);
    } else {
      num_preb_in_one_row *= ref_booster->GetBoosting()->NumberOfTotalModel() / num_preb_in_one_row;
    }
  }
Guolin Ke's avatar
Guolin Ke committed
642
643
644
645
646
  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
647
648
    for (int j = 0; j < static_cast<int>(predicton_result.size()); ++j) {
      out_result[i * num_preb_in_one_row + j] = static_cast<float>(predicton_result[j]);
Guolin Ke's avatar
Guolin Ke committed
649
650
    }
  }
Guolin Ke's avatar
Guolin Ke committed
651
  *out_len = nrow * num_preb_in_one_row;
652
  API_END();
Guolin Ke's avatar
Guolin Ke committed
653
}
654
655
656

DllExport int LGBM_BoosterPredictForMat(BoosterHandle handle,
  const void* data,
657
  int data_type,
658
659
  int32_t nrow,
  int32_t ncol,
Guolin Ke's avatar
Guolin Ke committed
660
  int is_row_major,
661
  int predict_type,
Guolin Ke's avatar
Guolin Ke committed
662
663
664
  int64_t num_iteration,
  int64_t* out_len,
  float* out_result) {
665
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
666
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
Guolin Ke's avatar
Guolin Ke committed
667
  ref_booster->PrepareForPrediction(static_cast<int>(num_iteration), predict_type);
Guolin Ke's avatar
Guolin Ke committed
668

669
  auto get_row_fun = RowPairFunctionFromDenseMatric(data, nrow, ncol, data_type, is_row_major);
Guolin Ke's avatar
Guolin Ke committed
670
671
672
673
674
675
676
677
  int num_preb_in_one_row = ref_booster->GetBoosting()->NumberOfClasses();
  if (predict_type == C_API_PREDICT_LEAF_INDEX) {
    if (num_iteration > 0) {
      num_preb_in_one_row *= static_cast<int>(num_iteration);
    } else {
      num_preb_in_one_row *= ref_booster->GetBoosting()->NumberOfTotalModel() / num_preb_in_one_row;
    }
  }
Guolin Ke's avatar
Guolin Ke committed
678
679
680
681
#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
682
683
    for (int j = 0; j < static_cast<int>(predicton_result.size()); ++j) {
      out_result[i * num_preb_in_one_row + j] = static_cast<float>(predicton_result[j]);
Guolin Ke's avatar
Guolin Ke committed
684
685
    }
  }
Guolin Ke's avatar
Guolin Ke committed
686
  *out_len = nrow * num_preb_in_one_row;
687
  API_END();
Guolin Ke's avatar
Guolin Ke committed
688
}
689
690

DllExport int LGBM_BoosterSaveModel(BoosterHandle handle,
Guolin Ke's avatar
Guolin Ke committed
691
  int num_iteration,
Guolin Ke's avatar
Guolin Ke committed
692
  const char* filename) {
693
  API_BEGIN();
Guolin Ke's avatar
Guolin Ke committed
694
  Booster* ref_booster = reinterpret_cast<Booster*>(handle);
Guolin Ke's avatar
Guolin Ke committed
695
  ref_booster->SaveModelToFile(num_iteration, filename);
696
  API_END();
Guolin Ke's avatar
Guolin Ke committed
697
}
698

Guolin Ke's avatar
Guolin Ke committed
699
// ---- start of some help functions
700
701
702

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
703
  if (data_type == C_API_DTYPE_FLOAT32) {
704
705
706
    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
707
        std::vector<double> ret(num_col);
708
709
        auto tmp_ptr = data_ptr + num_col * row_idx;
        for (int i = 0; i < num_col; ++i) {
Guolin Ke's avatar
Guolin Ke committed
710
          ret[i] = static_cast<double>(*(tmp_ptr + i));
711
712
713
714
715
        }
        return ret;
      };
    } else {
      return [data_ptr, num_col, num_row](int row_idx) {
Guolin Ke's avatar
Guolin Ke committed
716
        std::vector<double> ret(num_col);
717
        for (int i = 0; i < num_col; ++i) {
Guolin Ke's avatar
Guolin Ke committed
718
          ret[i] = static_cast<double>(*(data_ptr + num_row * i + row_idx));
719
720
721
722
        }
        return ret;
      };
    }
Guolin Ke's avatar
Guolin Ke committed
723
  } else if (data_type == C_API_DTYPE_FLOAT64) {
724
725
726
    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
727
        std::vector<double> ret(num_col);
728
729
        auto tmp_ptr = data_ptr + num_col * row_idx;
        for (int i = 0; i < num_col; ++i) {
Guolin Ke's avatar
Guolin Ke committed
730
          ret[i] = static_cast<double>(*(tmp_ptr + i));
731
732
733
734
735
        }
        return ret;
      };
    } else {
      return [data_ptr, num_col, num_row](int row_idx) {
Guolin Ke's avatar
Guolin Ke committed
736
        std::vector<double> ret(num_col);
737
        for (int i = 0; i < num_col; ++i) {
Guolin Ke's avatar
Guolin Ke committed
738
          ret[i] = static_cast<double>(*(data_ptr + num_row * i + row_idx));
739
740
741
742
743
        }
        return ret;
      };
    }
  }
Guolin Ke's avatar
Guolin Ke committed
744
  throw std::runtime_error("unknown data type in RowFunctionFromDenseMatric");
745
746
747
748
}

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
749
750
751
752
753
754
755
756
  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]);
757
        }
Guolin Ke's avatar
Guolin Ke committed
758
759
760
      }
      return ret;
    };
761
  }
Guolin Ke's avatar
Guolin Ke committed
762
  return nullptr;
763
764
765
766
}

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
767
  if (data_type == C_API_DTYPE_FLOAT32) {
768
    const float* data_ptr = reinterpret_cast<const float*>(data);
Guolin Ke's avatar
Guolin Ke committed
769
    if (indptr_type == C_API_DTYPE_INT32) {
770
771
772
773
774
      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
775
        for (int64_t i = start; i < end; ++i) {
776
777
778
779
          ret.emplace_back(indices[i], data_ptr[i]);
        }
        return ret;
      };
Guolin Ke's avatar
Guolin Ke committed
780
    } else if (indptr_type == C_API_DTYPE_INT64) {
781
782
783
784
785
      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
786
        for (int64_t i = start; i < end; ++i) {
787
788
789
790
791
          ret.emplace_back(indices[i], data_ptr[i]);
        }
        return ret;
      };
    }
Guolin Ke's avatar
Guolin Ke committed
792
  } else if (data_type == C_API_DTYPE_FLOAT64) {
793
    const double* data_ptr = reinterpret_cast<const double*>(data);
Guolin Ke's avatar
Guolin Ke committed
794
    if (indptr_type == C_API_DTYPE_INT32) {
795
796
797
798
799
      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
800
        for (int64_t i = start; i < end; ++i) {
801
802
803
804
          ret.emplace_back(indices[i], data_ptr[i]);
        }
        return ret;
      };
Guolin Ke's avatar
Guolin Ke committed
805
    } else if (indptr_type == C_API_DTYPE_INT64) {
806
807
808
809
810
      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
811
        for (int64_t i = start; i < end; ++i) {
812
813
814
815
          ret.emplace_back(indices[i], data_ptr[i]);
        }
        return ret;
      };
Guolin Ke's avatar
Guolin Ke committed
816
817
818
    } 
  } 
  throw std::runtime_error("unknown data type in RowFunctionFromCSR");
819
820
821
822
}

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
823
  if (data_type == C_API_DTYPE_FLOAT32) {
824
    const float* data_ptr = reinterpret_cast<const float*>(data);
Guolin Ke's avatar
Guolin Ke committed
825
    if (col_ptr_type == C_API_DTYPE_INT32) {
826
827
828
829
830
831
832
833
834
835
      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
836
    } else if (col_ptr_type == C_API_DTYPE_INT64) {
837
838
839
840
841
842
843
844
845
846
      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
847
    } 
Guolin Ke's avatar
Guolin Ke committed
848
  } else if (data_type == C_API_DTYPE_FLOAT64) {
849
    const double* data_ptr = reinterpret_cast<const double*>(data);
Guolin Ke's avatar
Guolin Ke committed
850
    if (col_ptr_type == C_API_DTYPE_INT32) {
851
852
853
854
855
856
857
858
859
860
      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
861
    } else if (col_ptr_type == C_API_DTYPE_INT64) {
862
863
864
865
866
867
868
869
870
871
      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
872
873
874
    } 
  } 
  throw std::runtime_error("unknown data type in ColumnFunctionFromCSC");
875
876
}

877
std::vector<double> SampleFromOneColumn(const std::vector<std::pair<int, double>>& data, const std::vector<int>& indices) {
878
879
880
881
882
883
884
885
886
887
888
  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
889
}