c_api.h 76.2 KB
Newer Older
1
/*!
2
3
4
5
6
7
 * \file c_api.h
 * \copyright Copyright (c) 2016 Microsoft Corporation. All rights reserved.
 *            Licensed under the MIT License. See LICENSE file in the project root for license information.
 * \note
 * To avoid type conversion on large data, the most of our exposed interface supports both float32 and float64,
 * except the following:
8
9
10
 * 1. gradient and Hessian;
 * 2. current score for training and validation data.
 * .
11
 * The reason is that they are called frequently, and the type conversion on them may be time-cost.
12
 */
Guolin Ke's avatar
Guolin Ke committed
13
14
#ifndef LIGHTGBM_C_API_H_
#define LIGHTGBM_C_API_H_
ww's avatar
ww committed
15

16
17
#include <LightGBM/export.h>

18
#ifdef __cplusplus
19
#include <cstdint>
20
#include <cstdio>
wxchan's avatar
wxchan committed
21
#include <cstring>
22
23
24
25
26
#else
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#endif
wxchan's avatar
wxchan committed
27

28

29
30
typedef void* DatasetHandle;  /*!< \brief Handle of dataset. */
typedef void* BoosterHandle;  /*!< \brief Handle of booster. */
31
typedef void* FastConfigHandle; /*!< \brief Handle of FastConfig. */
Guolin Ke's avatar
Guolin Ke committed
32

33
34
35
36
#define C_API_DTYPE_FLOAT32 (0)  /*!< \brief float32 (single precision float). */
#define C_API_DTYPE_FLOAT64 (1)  /*!< \brief float64 (double precision float). */
#define C_API_DTYPE_INT32   (2)  /*!< \brief int32. */
#define C_API_DTYPE_INT64   (3)  /*!< \brief int64. */
Guolin Ke's avatar
Guolin Ke committed
37

38
39
40
41
#define C_API_PREDICT_NORMAL     (0)  /*!< \brief Normal prediction, with transform (if needed). */
#define C_API_PREDICT_RAW_SCORE  (1)  /*!< \brief Predict raw score. */
#define C_API_PREDICT_LEAF_INDEX (2)  /*!< \brief Predict leaf index. */
#define C_API_PREDICT_CONTRIB    (3)  /*!< \brief Predict feature contributions (SHAP values). */
42

43
44
45
#define C_API_MATRIX_TYPE_CSR (0)  /*!< \brief CSR sparse matrix type. */
#define C_API_MATRIX_TYPE_CSC (1)  /*!< \brief CSC sparse matrix type. */

46
47
48
#define C_API_FEATURE_IMPORTANCE_SPLIT (0)  /*!< \brief Split type of feature importance. */
#define C_API_FEATURE_IMPORTANCE_GAIN  (1)  /*!< \brief Gain type of feature importance. */

Guolin Ke's avatar
Guolin Ke committed
49
/*!
50
 * \brief Get string message of the last error.
51
52
 * \return Error information
 */
53
LIGHTGBM_C_EXPORT const char* LGBM_GetLastError();
Guolin Ke's avatar
Guolin Ke committed
54

55
56
57
58
59
60
61
62
63
64
65
/*!
 * \brief Dump all parameter names with their aliases to JSON.
 * \param buffer_len String buffer length, if ``buffer_len < out_len``, you should re-allocate buffer
 * \param[out] out_len Actual output length
 * \param[out] out_str JSON format string of parameters, should pre-allocate memory
 * \return 0 when succeed, -1 when failure happens
 */
LIGHTGBM_C_EXPORT int LGBM_DumpParamAliases(int64_t buffer_len,
                                            int64_t* out_len,
                                            char* out_str);

66
/*!
67
 * \brief Register a callback function for log redirecting.
68
69
70
71
72
 * \param callback The callback function to register
 * \return 0 when succeed, -1 when failure happens
 */
LIGHTGBM_C_EXPORT int LGBM_RegisterLogCallback(void (*callback)(const char*));

73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
/*!
 * \brief Get number of samples based on parameters and total number of rows of data.
 * \param num_total_row Number of total rows
 * \param parameters Additional parameters, namely, ``bin_construct_sample_cnt`` is used to calculate returned value
 * \param[out] out Number of samples. This value is used to pre-allocate memory to hold sample indices when calling ``LGBM_SampleIndices``
 * \return 0 when succeed, -1 when failure happens
 */
LIGHTGBM_C_EXPORT int LGBM_GetSampleCount(int32_t num_total_row,
                                          const char* parameters,
                                          int* out);

/*!
 * \brief Create sample indices for total number of rows.
 * \note
 * You should pre-allocate memory for ``out``, you can get its length by ``LGBM_GetSampleCount``.
 * \param num_total_row Number of total rows
 * \param parameters Additional parameters, namely, ``bin_construct_sample_cnt`` and ``data_random_seed`` are used to produce the output
 * \param[out] out Created indices, type is int32_t
91
 * \param[out] out_len Number of indices
92
93
94
95
96
97
98
 * \return 0 when succeed, -1 when failure happens
 */
LIGHTGBM_C_EXPORT int LGBM_SampleIndices(int32_t num_total_row,
                                         const char* parameters,
                                         void* out,
                                         int32_t* out_len);

99
/* --- start Dataset interface */
Guolin Ke's avatar
Guolin Ke committed
100
101

/*!
102
103
104
105
106
107
 * \brief Load dataset from file (like LightGBM CLI version does).
 * \param filename The name of the file
 * \param parameters Additional parameters
 * \param reference Used to align bin mapper with other dataset, nullptr means isn't used
 * \param[out] out A loaded dataset
 * \return 0 when succeed, -1 when failure happens
108
 */
109
LIGHTGBM_C_EXPORT int LGBM_DatasetCreateFromFile(const char* filename,
110
111
112
                                                 const char* parameters,
                                                 const DatasetHandle reference,
                                                 DatasetHandle* out);
Guolin Ke's avatar
Guolin Ke committed
113

114
/*!
115
116
 * \brief Allocate the space for dataset and bucket feature bins according to sampled data.
 * \param sample_data Sampled data, grouped by the column
117
118
119
120
 * \param sample_indices Indices of sampled data
 * \param ncol Number of columns
 * \param num_per_col Size of each sampling column
 * \param num_sample_row Number of sampled rows
121
122
 * \param num_local_row Total number of rows local to machine
 * \param num_dist_row Number of total distributed rows
123
124
125
 * \param parameters Additional parameters
 * \param[out] out Created dataset
 * \return 0 when succeed, -1 when failure happens
126
 */
127
128
129
130
131
LIGHTGBM_C_EXPORT int LGBM_DatasetCreateFromSampledColumn(double** sample_data,
                                                          int** sample_indices,
                                                          int32_t ncol,
                                                          const int* num_per_col,
                                                          int32_t num_sample_row,
132
133
                                                          int32_t num_local_row,
                                                          int64_t num_dist_row,
134
135
                                                          const char* parameters,
                                                          DatasetHandle* out);
Guolin Ke's avatar
Guolin Ke committed
136
137

/*!
138
 * \brief Allocate the space for dataset and bucket feature bins according to reference dataset.
139
140
141
142
 * \param reference Used to align bin mapper with other dataset
 * \param num_total_row Number of total rows
 * \param[out] out Created dataset
 * \return 0 when succeed, -1 when failure happens
143
 */
Guolin Ke's avatar
Guolin Ke committed
144
LIGHTGBM_C_EXPORT int LGBM_DatasetCreateByReference(const DatasetHandle reference,
145
146
                                                    int64_t num_total_row,
                                                    DatasetHandle* out);
Guolin Ke's avatar
Guolin Ke committed
147

148
149
150
151
152
153
154
155
/*!
 * \brief Initialize the Dataset for streaming.
 * \param dataset Handle of dataset
 * \param has_weights Whether the dataset has Metadata weights
 * \param has_init_scores Whether the dataset has Metadata initial scores
 * \param has_queries Whether the dataset has Metadata queries/groups
 * \param nclasses Number of initial score classes
 * \param nthreads Number of external threads that will use the PushRows APIs
156
 * \param omp_max_threads Maximum number of OpenMP threads (-1 for default)
157
158
159
160
161
162
163
 * \return 0 when succeed, -1 when failure happens
 */
LIGHTGBM_C_EXPORT int LGBM_DatasetInitStreaming(DatasetHandle dataset,
                                                int32_t has_weights,
                                                int32_t has_init_scores,
                                                int32_t has_queries,
                                                int32_t nclasses,
164
165
                                                int32_t nthreads,
                                                int32_t omp_max_threads);
166

Guolin Ke's avatar
Guolin Ke committed
167
/*!
168
 * \brief Push data to existing dataset, if ``nrow + start_row == num_total_row``, will call ``dataset->FinishLoad``.
169
170
 * \param dataset Handle of dataset
 * \param data Pointer to the data space
171
 * \param data_type Type of ``data`` pointer, can be ``C_API_DTYPE_FLOAT32`` or ``C_API_DTYPE_FLOAT64``
172
173
174
175
 * \param nrow Number of rows
 * \param ncol Number of columns
 * \param start_row Row start index
 * \return 0 when succeed, -1 when failure happens
176
 */
Guolin Ke's avatar
Guolin Ke committed
177
LIGHTGBM_C_EXPORT int LGBM_DatasetPushRows(DatasetHandle dataset,
178
179
180
181
182
                                           const void* data,
                                           int data_type,
                                           int32_t nrow,
                                           int32_t ncol,
                                           int32_t start_row);
Guolin Ke's avatar
Guolin Ke committed
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
/*!
 * \brief Push data to existing dataset.
 *        The general flow for a streaming scenario is:
 *        1. create Dataset "schema" (e.g. ``LGBM_DatasetCreateFromSampledColumn``)
 *        2. init them for thread-safe streaming (``LGBM_DatasetInitStreaming``)
 *        3. push data (``LGBM_DatasetPushRowsWithMetadata`` or ``LGBM_DatasetPushRowsByCSRWithMetadata``)
 *        4. call ``LGBM_DatasetMarkFinished``
 * \param dataset Handle of dataset
 * \param data Pointer to the data space
 * \param data_type Type of ``data`` pointer, can be ``C_API_DTYPE_FLOAT32`` or ``C_API_DTYPE_FLOAT64``
 * \param nrow Number of rows
 * \param ncol Number of feature columns
 * \param start_row Row start index, i.e., the index at which to start inserting data
 * \param label Pointer to array with nrow labels
 * \param weight Optional pointer to array with nrow weights
 * \param init_score Optional pointer to array with nrow*nclasses initial scores, in column format
 * \param query Optional pointer to array with nrow query values
 * \param tid The id of the calling thread, from 0...N-1 threads
 * \return 0 when succeed, -1 when failure happens
 */
LIGHTGBM_C_EXPORT int LGBM_DatasetPushRowsWithMetadata(DatasetHandle dataset,
                                                       const void* data,
                                                       int data_type,
                                                       int32_t nrow,
                                                       int32_t ncol,
                                                       int32_t start_row,
                                                       const float* label,
                                                       const float* weight,
                                                       const double* init_score,
                                                       const int32_t* query,
                                                       int32_t tid);

Guolin Ke's avatar
Guolin Ke committed
216
/*!
217
 * \brief Push data to existing dataset, if ``nrow + start_row == num_total_row``, will call ``dataset->FinishLoad``.
218
219
 * \param dataset Handle of dataset
 * \param indptr Pointer to row headers
220
 * \param indptr_type Type of ``indptr``, can be ``C_API_DTYPE_INT32`` or ``C_API_DTYPE_INT64``
221
222
 * \param indices Pointer to column indices
 * \param data Pointer to the data space
223
 * \param data_type Type of ``data`` pointer, can be ``C_API_DTYPE_FLOAT32`` or ``C_API_DTYPE_FLOAT64``
224
225
226
227
228
 * \param nindptr Number of rows in the matrix + 1
 * \param nelem Number of nonzero elements in the matrix
 * \param num_col Number of columns
 * \param start_row Row start index
 * \return 0 when succeed, -1 when failure happens
229
 */
Guolin Ke's avatar
Guolin Ke committed
230
LIGHTGBM_C_EXPORT int LGBM_DatasetPushRowsByCSR(DatasetHandle dataset,
231
232
233
234
235
236
237
238
239
                                                const void* indptr,
                                                int indptr_type,
                                                const int32_t* indices,
                                                const void* data,
                                                int data_type,
                                                int64_t nindptr,
                                                int64_t nelem,
                                                int64_t num_col,
                                                int64_t start_row);
Guolin Ke's avatar
Guolin Ke committed
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
287
288
289
/*!
 * \brief Push CSR data to existing dataset. (See ``LGBM_DatasetPushRowsWithMetadata`` for more details.)
 * \param dataset Handle of dataset
 * \param indptr Pointer to row headers
 * \param indptr_type Type of ``indptr``, can be ``C_API_DTYPE_INT32`` or ``C_API_DTYPE_INT64``
 * \param indices Pointer to column indices
 * \param data Pointer to the data space
 * \param data_type Type of ``data`` pointer, can be ``C_API_DTYPE_FLOAT32`` or ``C_API_DTYPE_FLOAT64``
 * \param nindptr Number of rows in the matrix + 1
 * \param nelem Number of nonzero elements in the matrix
 * \param start_row Row start index
 * \param label Pointer to array with nindptr-1 labels
 * \param weight Optional pointer to array with nindptr-1 weights
 * \param init_score Optional pointer to array with (nindptr-1)*nclasses initial scores, in column format
 * \param query Optional pointer to array with nindptr-1 query values
 * \param tid The id of the calling thread, from 0...N-1 threads
 * \return 0 when succeed, -1 when failure happens
 */
LIGHTGBM_C_EXPORT int LGBM_DatasetPushRowsByCSRWithMetadata(DatasetHandle dataset,
                                                            const void* indptr,
                                                            int indptr_type,
                                                            const int32_t* indices,
                                                            const void* data,
                                                            int data_type,
                                                            int64_t nindptr,
                                                            int64_t nelem,
                                                            int64_t start_row,
                                                            const float* label,
                                                            const float* weight,
                                                            const double* init_score,
                                                            const int32_t* query,
                                                            int32_t tid);

/*!
 * \brief Set whether or not the Dataset waits for a manual MarkFinished call or calls FinishLoad on itself automatically.
 *        Set to 1 for streaming scenario, and use ``LGBM_DatasetMarkFinished`` to manually finish the Dataset.
 * \param dataset Handle of dataset
 * \param wait Whether to wait or not (1 or 0)
 * \return 0 when succeed, -1 when failure happens
 */
LIGHTGBM_C_EXPORT int LGBM_DatasetSetWaitForManualFinish(DatasetHandle dataset, int wait);

/*!
 * \brief Mark the Dataset as complete by calling ``dataset->FinishLoad``.
 * \param dataset Handle of dataset
 * \return 0 when succeed, -1 when failure happens
 */
LIGHTGBM_C_EXPORT int LGBM_DatasetMarkFinished(DatasetHandle dataset);

Guolin Ke's avatar
Guolin Ke committed
290
/*!
291
292
 * \brief Create a dataset from CSR format.
 * \param indptr Pointer to row headers
293
 * \param indptr_type Type of ``indptr``, can be ``C_API_DTYPE_INT32`` or ``C_API_DTYPE_INT64``
294
295
 * \param indices Pointer to column indices
 * \param data Pointer to the data space
296
 * \param data_type Type of ``data`` pointer, can be ``C_API_DTYPE_FLOAT32`` or ``C_API_DTYPE_FLOAT64``
297
298
299
300
301
302
303
 * \param nindptr Number of rows in the matrix + 1
 * \param nelem Number of nonzero elements in the matrix
 * \param num_col Number of columns
 * \param parameters Additional parameters
 * \param reference Used to align bin mapper with other dataset, nullptr means isn't used
 * \param[out] out Created dataset
 * \return 0 when succeed, -1 when failure happens
304
 */
305
LIGHTGBM_C_EXPORT int LGBM_DatasetCreateFromCSR(const void* indptr,
306
307
308
309
310
311
312
313
314
315
                                                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);
Guolin Ke's avatar
Guolin Ke committed
316

317
/*!
318
 * \brief Create a dataset from CSR format through callbacks.
319
320
 * \param get_row_funptr Pointer to ``std::function<void(int idx, std::vector<std::pair<int, double>>& ret)>``
 *                       (called for every row and expected to clear and fill ``ret``)
321
322
323
324
325
326
 * \param num_rows Number of rows
 * \param num_col Number of columns
 * \param parameters Additional parameters
 * \param reference Used to align bin mapper with other dataset, nullptr means isn't used
 * \param[out] out Created dataset
 * \return 0 when succeed, -1 when failure happens
327
 */
328
LIGHTGBM_C_EXPORT int LGBM_DatasetCreateFromCSRFunc(void* get_row_funptr,
329
330
331
332
333
                                                    int num_rows,
                                                    int64_t num_col,
                                                    const char* parameters,
                                                    const DatasetHandle reference,
                                                    DatasetHandle* out);
334

Guolin Ke's avatar
Guolin Ke committed
335
/*!
336
337
 * \brief Create a dataset from CSC format.
 * \param col_ptr Pointer to column headers
338
 * \param col_ptr_type Type of ``col_ptr``, can be ``C_API_DTYPE_INT32`` or ``C_API_DTYPE_INT64``
339
340
 * \param indices Pointer to row indices
 * \param data Pointer to the data space
341
 * \param data_type Type of ``data`` pointer, can be ``C_API_DTYPE_FLOAT32`` or ``C_API_DTYPE_FLOAT64``
342
343
344
345
346
347
348
 * \param ncol_ptr Number of columns in the matrix + 1
 * \param nelem Number of nonzero elements in the matrix
 * \param num_row Number of rows
 * \param parameters Additional parameters
 * \param reference Used to align bin mapper with other dataset, nullptr means isn't used
 * \param[out] out Created dataset
 * \return 0 when succeed, -1 when failure happens
349
 */
350
LIGHTGBM_C_EXPORT int LGBM_DatasetCreateFromCSC(const void* col_ptr,
351
352
353
354
355
356
357
358
359
360
                                                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);
Guolin Ke's avatar
Guolin Ke committed
361
362

/*!
363
364
 * \brief Create dataset from dense matrix.
 * \param data Pointer to the data space
365
 * \param data_type Type of ``data`` pointer, can be ``C_API_DTYPE_FLOAT32`` or ``C_API_DTYPE_FLOAT64``
366
367
368
369
370
371
372
 * \param nrow Number of rows
 * \param ncol Number of columns
 * \param is_row_major 1 for row-major, 0 for column-major
 * \param parameters Additional parameters
 * \param reference Used to align bin mapper with other dataset, nullptr means isn't used
 * \param[out] out Created dataset
 * \return 0 when succeed, -1 when failure happens
373
 */
374
LIGHTGBM_C_EXPORT int LGBM_DatasetCreateFromMat(const void* data,
375
376
377
378
379
380
381
                                                int data_type,
                                                int32_t nrow,
                                                int32_t ncol,
                                                int is_row_major,
                                                const char* parameters,
                                                const DatasetHandle reference,
                                                DatasetHandle* out);
Guolin Ke's avatar
Guolin Ke committed
382

383
/*!
384
385
386
 * \brief Create dataset from array of dense matrices.
 * \param nmat Number of dense matrices
 * \param data Pointer to the data space
387
 * \param data_type Type of ``data`` pointer, can be ``C_API_DTYPE_FLOAT32`` or ``C_API_DTYPE_FLOAT64``
388
389
390
391
392
393
394
 * \param nrow Number of rows
 * \param ncol Number of columns
 * \param is_row_major 1 for row-major, 0 for column-major
 * \param parameters Additional parameters
 * \param reference Used to align bin mapper with other dataset, nullptr means isn't used
 * \param[out] out Created dataset
 * \return 0 when succeed, -1 when failure happens
395
 */
396
397
398
399
400
401
402
403
404
405
LIGHTGBM_C_EXPORT 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);

wxchan's avatar
wxchan committed
406
/*!
407
408
409
 * \brief Create subset of a data.
 * \param handle Handle of full dataset
 * \param used_row_indices Indices used in subset
410
 * \param num_used_row_indices Length of ``used_row_indices``
411
412
413
 * \param parameters Additional parameters
 * \param[out] out Subset of data
 * \return 0 when succeed, -1 when failure happens
414
 */
415
416
417
418
419
LIGHTGBM_C_EXPORT int LGBM_DatasetGetSubset(const DatasetHandle handle,
                                            const int32_t* used_row_indices,
                                            int32_t num_used_row_indices,
                                            const char* parameters,
                                            DatasetHandle* out);
wxchan's avatar
wxchan committed
420

Guolin Ke's avatar
Guolin Ke committed
421
/*!
422
423
424
425
426
 * \brief Save feature names to dataset.
 * \param handle Handle of dataset
 * \param feature_names Feature names
 * \param num_feature_names Number of feature names
 * \return 0 when succeed, -1 when failure happens
427
 */
428
429
430
LIGHTGBM_C_EXPORT int LGBM_DatasetSetFeatureNames(DatasetHandle handle,
                                                  const char** feature_names,
                                                  int num_feature_names);
Guolin Ke's avatar
Guolin Ke committed
431

432
/*!
433
434
 * \brief Get feature names of dataset.
 * \param handle Handle of dataset
435
436
 * \param len Number of ``char*`` pointers stored at ``out_strs``.
 *            If smaller than the max size, only this many strings are copied
437
 * \param[out] num_feature_names Number of feature names
438
439
440
441
 * \param buffer_len Size of pre-allocated strings.
 *                   Content is copied up to ``buffer_len - 1`` and null-terminated
 * \param[out] out_buffer_len String sizes required to do the full string copies
 * \param[out] feature_names Feature names, should pre-allocate memory
442
 * \return 0 when succeed, -1 when failure happens
443
 */
444
LIGHTGBM_C_EXPORT int LGBM_DatasetGetFeatureNames(DatasetHandle handle,
445
446
447
448
449
                                                  const int len,
                                                  int* num_feature_names,
                                                  const size_t buffer_len,
                                                  size_t* out_buffer_len,
                                                  char** feature_names);
450

Guolin Ke's avatar
Guolin Ke committed
451
/*!
452
453
454
 * \brief Free space for dataset.
 * \param handle Handle of dataset to be freed
 * \return 0 when succeed, -1 when failure happens
455
 */
456
LIGHTGBM_C_EXPORT int LGBM_DatasetFree(DatasetHandle handle);
Guolin Ke's avatar
Guolin Ke committed
457
458

/*!
459
460
 * \brief Save dataset to binary file.
 * \param handle Handle of dataset
461
 * \param filename The name of the file
462
 * \return 0 when succeed, -1 when failure happens
463
 */
464
LIGHTGBM_C_EXPORT int LGBM_DatasetSaveBinary(DatasetHandle handle,
465
                                             const char* filename);
Guolin Ke's avatar
Guolin Ke committed
466

467
/*!
468
469
 * \brief Save dataset to text file, intended for debugging use only.
 * \param handle Handle of dataset
470
 * \param filename The name of the file
471
 * \return 0 when succeed, -1 when failure happens
472
 */
473
474
475
LIGHTGBM_C_EXPORT int LGBM_DatasetDumpText(DatasetHandle handle,
                                           const char* filename);

Guolin Ke's avatar
Guolin Ke committed
476
/*!
477
 * \brief Set vector to a content in info.
478
479
480
 * \note
 * - \a group only works for ``C_API_DTYPE_INT32``;
 * - \a label and \a weight only work for ``C_API_DTYPE_FLOAT32``;
481
 * - \a init_score only works for ``C_API_DTYPE_FLOAT64``.
482
 * \param handle Handle of dataset
483
 * \param field_name Field name, can be \a label, \a weight, \a init_score, \a group
484
 * \param field_data Pointer to data vector
485
 * \param num_element Number of elements in ``field_data``
486
 * \param type Type of ``field_data`` pointer, can be ``C_API_DTYPE_INT32``, ``C_API_DTYPE_FLOAT32`` or ``C_API_DTYPE_FLOAT64``
487
 * \return 0 when succeed, -1 when failure happens
488
 */
489
LIGHTGBM_C_EXPORT int LGBM_DatasetSetField(DatasetHandle handle,
490
491
492
493
                                           const char* field_name,
                                           const void* field_data,
                                           int num_element,
                                           int type);
Guolin Ke's avatar
Guolin Ke committed
494
495

/*!
496
497
498
499
500
 * \brief Get info vector from dataset.
 * \param handle Handle of dataset
 * \param field_name Field name
 * \param[out] out_len Used to set result length
 * \param[out] out_ptr Pointer to the result
501
 * \param[out] out_type Type of result pointer, can be ``C_API_DTYPE_INT32``, ``C_API_DTYPE_FLOAT32`` or ``C_API_DTYPE_FLOAT64``
502
 * \return 0 when succeed, -1 when failure happens
503
 */
504
LIGHTGBM_C_EXPORT int LGBM_DatasetGetField(DatasetHandle handle,
505
506
507
508
                                           const char* field_name,
                                           int* out_len,
                                           const void** out_ptr,
                                           int* out_type);
Guolin Ke's avatar
Guolin Ke committed
509

510
/*!
511
512
513
514
 * \brief Raise errors for attempts to update dataset parameters.
 * \param old_parameters Current dataset parameters
 * \param new_parameters New dataset parameters
 * \return 0 when succeed, -1 when failure happens
515
 */
516
517
LIGHTGBM_C_EXPORT int LGBM_DatasetUpdateParamChecking(const char* old_parameters,
                                                      const char* new_parameters);
518

Guolin Ke's avatar
Guolin Ke committed
519
/*!
520
521
522
523
 * \brief Get number of data points.
 * \param handle Handle of dataset
 * \param[out] out The address to hold number of data points
 * \return 0 when succeed, -1 when failure happens
524
 */
525
LIGHTGBM_C_EXPORT int LGBM_DatasetGetNumData(DatasetHandle handle,
526
                                             int* out);
Guolin Ke's avatar
Guolin Ke committed
527
528

/*!
529
530
531
532
 * \brief Get number of features.
 * \param handle Handle of dataset
 * \param[out] out The address to hold number of features
 * \return 0 when succeed, -1 when failure happens
533
 */
534
LIGHTGBM_C_EXPORT int LGBM_DatasetGetNumFeature(DatasetHandle handle,
535
                                                int* out);
Guolin Ke's avatar
Guolin Ke committed
536

537
538
539
540
541
542
543
544
545
546
547
/*!
 * \brief Get number of bins for feature.
 * \param handle Handle of dataset
 * \param feature Index of the feature
 * \param[out] out The address to hold number of bins
 * \return 0 when succeed, -1 when failure happens
 */
LIGHTGBM_C_EXPORT int LGBM_DatasetGetFeatureNumBin(DatasetHandle handle,
                                                   int feature,
                                                   int* out);

548
/*!
549
 * \brief Add features from ``source`` to ``target``.
550
551
552
 * \param target The handle of the dataset to add features to
 * \param source The handle of the dataset to take features from
 * \return 0 when succeed, -1 when failure happens
553
 */
554
555
556
LIGHTGBM_C_EXPORT int LGBM_DatasetAddFeaturesFrom(DatasetHandle target,
                                                  DatasetHandle source);

557
/* --- start Booster interfaces */
Guolin Ke's avatar
Guolin Ke committed
558

559
/*!
560
* \brief Get int representing whether booster is fitting linear trees.
561
562
563
564
* \param handle Handle of booster
* \param[out] out The address to hold linear trees indicator
* \return 0 when succeed, -1 when failure happens
*/
565
LIGHTGBM_C_EXPORT int LGBM_BoosterGetLinear(BoosterHandle handle, int* out);
566

Guolin Ke's avatar
Guolin Ke committed
567
/*!
568
569
 * \brief Create a new boosting learner.
 * \param train_data Training dataset
570
 * \param parameters Parameters in format 'key1=value1 key2=value2'
571
 * \param[out] out Handle of created booster
572
573
 * \return 0 when succeed, -1 when failure happens
 */
574
LIGHTGBM_C_EXPORT int LGBM_BoosterCreate(const DatasetHandle train_data,
575
576
                                         const char* parameters,
                                         BoosterHandle* out);
Guolin Ke's avatar
Guolin Ke committed
577
578

/*!
579
580
581
582
583
 * \brief Load an existing booster from model file.
 * \param filename Filename of model
 * \param[out] out_num_iterations Number of iterations of this booster
 * \param[out] out Handle of created booster
 * \return 0 when succeed, -1 when failure happens
584
 */
585
586
587
LIGHTGBM_C_EXPORT int LGBM_BoosterCreateFromModelfile(const char* filename,
                                                      int* out_num_iterations,
                                                      BoosterHandle* out);
Guolin Ke's avatar
Guolin Ke committed
588

589
/*!
590
591
592
593
594
 * \brief Load an existing booster from string.
 * \param model_str Model string
 * \param[out] out_num_iterations Number of iterations of this booster
 * \param[out] out Handle of created booster
 * \return 0 when succeed, -1 when failure happens
595
 */
596
597
598
LIGHTGBM_C_EXPORT int LGBM_BoosterLoadModelFromString(const char* model_str,
                                                      int* out_num_iterations,
                                                      BoosterHandle* out);
wxchan's avatar
wxchan committed
599

600
601
/*!
 * \brief Get parameters as JSON string.
602
603
604
605
 * \param handle Handle of booster
 * \param buffer_len Allocated space for string
 * \param[out] out_len Actual size of string
 * \param[out] out_str JSON string containing parameters
606
607
608
609
610
611
612
613
 * \return 0 when succeed, -1 when failure happens
 */
LIGHTGBM_C_EXPORT int LGBM_BoosterGetLoadedParam(BoosterHandle handle,
                                                 int64_t buffer_len,
                                                 int64_t* out_len,
                                                 char* out_str);


Guolin Ke's avatar
Guolin Ke committed
614
/*!
615
616
617
 * \brief Free space for booster.
 * \param handle Handle of booster to be freed
 * \return 0 when succeed, -1 when failure happens
618
 */
619
LIGHTGBM_C_EXPORT int LGBM_BoosterFree(BoosterHandle handle);
Guolin Ke's avatar
Guolin Ke committed
620

621
/*!
622
623
624
625
626
 * \brief Shuffle models.
 * \param handle Handle of booster
 * \param start_iter The first iteration that will be shuffled
 * \param end_iter The last iteration that will be shuffled
 * \return 0 when succeed, -1 when failure happens
627
 */
628
629
630
LIGHTGBM_C_EXPORT int LGBM_BoosterShuffleModels(BoosterHandle handle,
                                                int start_iter,
                                                int end_iter);
631

wxchan's avatar
wxchan committed
632
/*!
633
 * \brief Merge model from ``other_handle`` into ``handle``.
634
635
636
 * \param handle Handle of booster, will merge another booster into this one
 * \param other_handle Other handle of booster
 * \return 0 when succeed, -1 when failure happens
637
 */
638
LIGHTGBM_C_EXPORT int LGBM_BoosterMerge(BoosterHandle handle,
639
                                        BoosterHandle other_handle);
wxchan's avatar
wxchan committed
640
641

/*!
642
643
644
645
 * \brief Add new validation data to booster.
 * \param handle Handle of booster
 * \param valid_data Validation dataset
 * \return 0 when succeed, -1 when failure happens
646
 */
647
LIGHTGBM_C_EXPORT int LGBM_BoosterAddValidData(BoosterHandle handle,
648
                                               const DatasetHandle valid_data);
wxchan's avatar
wxchan committed
649
650

/*!
651
652
653
654
 * \brief Reset training data for booster.
 * \param handle Handle of booster
 * \param train_data Training dataset
 * \return 0 when succeed, -1 when failure happens
655
 */
656
LIGHTGBM_C_EXPORT int LGBM_BoosterResetTrainingData(BoosterHandle handle,
657
                                                    const DatasetHandle train_data);
wxchan's avatar
wxchan committed
658
659

/*!
660
661
 * \brief Reset config for booster.
 * \param handle Handle of booster
662
 * \param parameters Parameters in format 'key1=value1 key2=value2'
663
 * \return 0 when succeed, -1 when failure happens
664
 */
665
666
LIGHTGBM_C_EXPORT int LGBM_BoosterResetParameter(BoosterHandle handle,
                                                 const char* parameters);
wxchan's avatar
wxchan committed
667
668

/*!
669
670
671
672
 * \brief Get number of classes.
 * \param handle Handle of booster
 * \param[out] out_len Number of classes
 * \return 0 when succeed, -1 when failure happens
673
 */
674
675
LIGHTGBM_C_EXPORT int LGBM_BoosterGetNumClasses(BoosterHandle handle,
                                                int* out_len);
wxchan's avatar
wxchan committed
676

Guolin Ke's avatar
Guolin Ke committed
677
/*!
678
679
 * \brief Update the model for one iteration.
 * \param handle Handle of booster
680
 * \param[out] is_finished 1 means the update was successfully finished (cannot split any more), 0 indicates failure
681
 * \return 0 when succeed, -1 when failure happens
682
 */
683
684
LIGHTGBM_C_EXPORT int LGBM_BoosterUpdateOneIter(BoosterHandle handle,
                                                int* is_finished);
Guolin Ke's avatar
Guolin Ke committed
685

Guolin Ke's avatar
Guolin Ke committed
686
/*!
687
688
689
 * \brief Refit the tree model using the new data (online learning).
 * \param handle Handle of booster
 * \param leaf_preds Pointer to predicted leaf indices
690
691
 * \param nrow Number of rows of ``leaf_preds``
 * \param ncol Number of columns of ``leaf_preds``
692
 * \return 0 when succeed, -1 when failure happens
693
 */
694
695
696
697
LIGHTGBM_C_EXPORT int LGBM_BoosterRefit(BoosterHandle handle,
                                        const int32_t* leaf_preds,
                                        int32_t nrow,
                                        int32_t ncol);
Guolin Ke's avatar
Guolin Ke committed
698

Guolin Ke's avatar
Guolin Ke committed
699
/*!
700
701
 * \brief Update the model by specifying gradient and Hessian directly
 *        (this can be used to support customized loss functions).
702
703
704
 * \note
 * The length of the arrays referenced by ``grad`` and ``hess`` must be equal to
 * ``num_class * num_train_data``, this is not verified by the library, the caller must ensure this.
705
706
707
 * \param handle Handle of booster
 * \param grad The first order derivative (gradient) statistics
 * \param hess The second order derivative (Hessian) statistics
708
 * \param[out] is_finished 1 means the update was successfully finished (cannot split any more), 0 indicates failure
709
 * \return 0 when succeed, -1 when failure happens
710
 */
711
LIGHTGBM_C_EXPORT int LGBM_BoosterUpdateOneIterCustom(BoosterHandle handle,
712
713
714
                                                      const float* grad,
                                                      const float* hess,
                                                      int* is_finished);
Guolin Ke's avatar
Guolin Ke committed
715
716

/*!
717
718
719
 * \brief Rollback one iteration.
 * \param handle Handle of booster
 * \return 0 when succeed, -1 when failure happens
720
 */
721
LIGHTGBM_C_EXPORT int LGBM_BoosterRollbackOneIter(BoosterHandle handle);
wxchan's avatar
wxchan committed
722
723

/*!
724
725
726
727
 * \brief Get index of the current boosting iteration.
 * \param handle Handle of booster
 * \param[out] out_iteration Index of the current boosting iteration
 * \return 0 when succeed, -1 when failure happens
728
 */
729
730
LIGHTGBM_C_EXPORT int LGBM_BoosterGetCurrentIteration(BoosterHandle handle,
                                                      int* out_iteration);
Guolin Ke's avatar
Guolin Ke committed
731

732
/*!
733
734
735
736
 * \brief Get number of trees per iteration.
 * \param handle Handle of booster
 * \param[out] out_tree_per_iteration Number of trees per iteration
 * \return 0 when succeed, -1 when failure happens
737
 */
738
739
LIGHTGBM_C_EXPORT int LGBM_BoosterNumModelPerIteration(BoosterHandle handle,
                                                       int* out_tree_per_iteration);
740
741

/*!
742
743
744
745
 * \brief Get number of weak sub-models.
 * \param handle Handle of booster
 * \param[out] out_models Number of weak sub-models
 * \return 0 when succeed, -1 when failure happens
746
 */
747
748
LIGHTGBM_C_EXPORT int LGBM_BoosterNumberOfTotalModel(BoosterHandle handle,
                                                     int* out_models);
749

Guolin Ke's avatar
Guolin Ke committed
750
/*!
751
 * \brief Get number of evaluation metrics.
752
 * \param handle Handle of booster
753
 * \param[out] out_len Total number of evaluation metrics
754
 * \return 0 when succeed, -1 when failure happens
755
 */
756
757
LIGHTGBM_C_EXPORT int LGBM_BoosterGetEvalCounts(BoosterHandle handle,
                                                int* out_len);
wxchan's avatar
wxchan committed
758
759

/*!
760
 * \brief Get names of evaluation metrics.
761
 * \param handle Handle of booster
762
763
 * \param len Number of ``char*`` pointers stored at ``out_strs``.
 *            If smaller than the max size, only this many strings are copied
764
 * \param[out] out_len Total number of evaluation metrics
765
 * \param buffer_len Size of pre-allocated strings.
766
767
 *                   Content is copied up to ``buffer_len - 1`` and null-terminated
 * \param[out] out_buffer_len String sizes required to do the full string copies
768
 * \param[out] out_strs Names of evaluation metrics, should pre-allocate memory
769
 * \return 0 when succeed, -1 when failure happens
770
 */
771
LIGHTGBM_C_EXPORT int LGBM_BoosterGetEvalNames(BoosterHandle handle,
772
                                               const int len,
773
                                               int* out_len,
774
775
                                               const size_t buffer_len,
                                               size_t* out_buffer_len,
776
                                               char** out_strs);
wxchan's avatar
wxchan committed
777

wxchan's avatar
wxchan committed
778
/*!
779
780
 * \brief Get names of features.
 * \param handle Handle of booster
781
782
 * \param len Number of ``char*`` pointers stored at ``out_strs``.
 *            If smaller than the max size, only this many strings are copied
783
 * \param[out] out_len Total number of features
784
785
786
 * \param buffer_len Size of pre-allocated strings.
 *                   Content is copied up to ``buffer_len - 1`` and null-terminated
 * \param[out] out_buffer_len String sizes required to do the full string copies
787
788
 * \param[out] out_strs Names of features, should pre-allocate memory
 * \return 0 when succeed, -1 when failure happens
789
 */
790
LIGHTGBM_C_EXPORT int LGBM_BoosterGetFeatureNames(BoosterHandle handle,
791
                                                  const int len,
792
                                                  int* out_len,
793
794
                                                  const size_t buffer_len,
                                                  size_t* out_buffer_len,
795
                                                  char** out_strs);
wxchan's avatar
wxchan committed
796

797
798
799
800
801
802
803
804
805
806
807
/*!
 * \brief Check that the feature names of the data match the ones used to train the booster.
 * \param handle Handle of booster
 * \param data_names Array with the feature names in the data
 * \param data_num_features Number of features in the data
 * \return 0 when succeed, -1 when failure happens
 */
LIGHTGBM_C_EXPORT int LGBM_BoosterValidateFeatureNames(BoosterHandle handle,
                                                       const char** data_names,
                                                       int data_num_features);

wxchan's avatar
wxchan committed
808
/*!
809
810
811
812
 * \brief Get number of features.
 * \param handle Handle of booster
 * \param[out] out_len Total number of features
 * \return 0 when succeed, -1 when failure happens
813
 */
814
815
LIGHTGBM_C_EXPORT int LGBM_BoosterGetNumFeature(BoosterHandle handle,
                                                int* out_len);
wxchan's avatar
wxchan committed
816

wxchan's avatar
wxchan committed
817
/*!
818
 * \brief Get evaluation for training data and validation data.
819
 * \note
820
 *   1. You should call ``LGBM_BoosterGetEvalNames`` first to get the names of evaluation metrics.
821
 *   2. You should pre-allocate memory for ``out_results``, you can get its length by ``LGBM_BoosterGetEvalCounts``.
822
823
824
 * \param handle Handle of booster
 * \param data_idx Index of data, 0: training data, 1: 1st validation data, 2: 2nd validation data and so on
 * \param[out] out_len Length of output result
825
 * \param[out] out_results Array with evaluation results
826
 * \return 0 when succeed, -1 when failure happens
827
 */
828
LIGHTGBM_C_EXPORT int LGBM_BoosterGetEval(BoosterHandle handle,
829
830
831
                                          int data_idx,
                                          int* out_len,
                                          double* out_results);
Guolin Ke's avatar
Guolin Ke committed
832
833

/*!
834
835
 * \brief Get number of predictions for training data and validation data
 *        (this can be used to support customized evaluation functions).
836
837
838
839
 * \param handle Handle of booster
 * \param data_idx Index of data, 0: training data, 1: 1st validation data, 2: 2nd validation data and so on
 * \param[out] out_len Number of predictions
 * \return 0 when succeed, -1 when failure happens
840
 */
841
LIGHTGBM_C_EXPORT int LGBM_BoosterGetNumPredict(BoosterHandle handle,
842
843
                                                int data_idx,
                                                int64_t* out_len);
Guolin Ke's avatar
Guolin Ke committed
844

Guolin Ke's avatar
Guolin Ke committed
845
/*!
846
 * \brief Get prediction for training data and validation data.
847
848
 * \note
 * You should pre-allocate memory for ``out_result``, its length is equal to ``num_class * num_data``.
849
850
851
852
853
 * \param handle Handle of booster
 * \param data_idx Index of data, 0: training data, 1: 1st validation data, 2: 2nd validation data and so on
 * \param[out] out_len Length of output result
 * \param[out] out_result Pointer to array with predictions
 * \return 0 when succeed, -1 when failure happens
854
 */
855
LIGHTGBM_C_EXPORT int LGBM_BoosterGetPredict(BoosterHandle handle,
856
857
858
                                             int data_idx,
                                             int64_t* out_len,
                                             double* out_result);
Guolin Ke's avatar
Guolin Ke committed
859

860
/*!
861
862
863
864
865
 * \brief Make prediction for file.
 * \param handle Handle of booster
 * \param data_filename Filename of file with data
 * \param data_has_header Whether file has header or not
 * \param predict_type What should be predicted
866
867
868
869
 *   - ``C_API_PREDICT_NORMAL``: normal prediction, with transform (if needed);
 *   - ``C_API_PREDICT_RAW_SCORE``: raw score;
 *   - ``C_API_PREDICT_LEAF_INDEX``: leaf index;
 *   - ``C_API_PREDICT_CONTRIB``: feature contributions (SHAP values)
870
 * \param start_iteration Start index of the iteration to predict
871
 * \param num_iteration Number of iterations for prediction, <= 0 means no limit
872
 * \param parameter Other parameters for prediction, e.g. early stopping for prediction
873
874
 * \param result_filename Filename of result file in which predictions will be written
 * \return 0 when succeed, -1 when failure happens
875
 */
876
LIGHTGBM_C_EXPORT int LGBM_BoosterPredictForFile(BoosterHandle handle,
877
878
879
                                                 const char* data_filename,
                                                 int data_has_header,
                                                 int predict_type,
880
                                                 int start_iteration,
881
                                                 int num_iteration,
882
                                                 const char* parameter,
883
                                                 const char* result_filename);
884

Guolin Ke's avatar
Guolin Ke committed
885
/*!
886
887
888
889
 * \brief Get number of predictions.
 * \param handle Handle of booster
 * \param num_row Number of rows
 * \param predict_type What should be predicted
890
891
892
893
 *   - ``C_API_PREDICT_NORMAL``: normal prediction, with transform (if needed);
 *   - ``C_API_PREDICT_RAW_SCORE``: raw score;
 *   - ``C_API_PREDICT_LEAF_INDEX``: leaf index;
 *   - ``C_API_PREDICT_CONTRIB``: feature contributions (SHAP values)
894
 * \param start_iteration Start index of the iteration to predict
895
896
897
 * \param num_iteration Number of iterations for prediction, <= 0 means no limit
 * \param[out] out_len Length of prediction
 * \return 0 when succeed, -1 when failure happens
898
 */
899
LIGHTGBM_C_EXPORT int LGBM_BoosterCalcNumPredict(BoosterHandle handle,
900
901
                                                 int num_row,
                                                 int predict_type,
902
                                                 int start_iteration,
903
904
                                                 int num_iteration,
                                                 int64_t* out_len);
Guolin Ke's avatar
Guolin Ke committed
905

906
907
908
909
910
911
912
913
/*!
 * \brief Release FastConfig object.
 *
 * \param fastConfig Handle to the FastConfig object acquired with a ``*FastInit()`` method.
 * \return 0 when it succeeds, -1 when failure happens
 */
LIGHTGBM_C_EXPORT int LGBM_FastConfigFree(FastConfigHandle fastConfig);

Guolin Ke's avatar
Guolin Ke committed
914
/*!
915
 * \brief Make prediction for a new dataset in CSR format.
916
917
918
919
920
 * \note
 * You should pre-allocate memory for ``out_result``:
 *   - for normal and raw score, its length is equal to ``num_class * num_data``;
 *   - for leaf index, its length is equal to ``num_class * num_data * num_iteration``;
 *   - for feature contributions, its length is equal to ``num_class * num_data * (num_feature + 1)``.
921
922
 * \param handle Handle of booster
 * \param indptr Pointer to row headers
923
 * \param indptr_type Type of ``indptr``, can be ``C_API_DTYPE_INT32`` or ``C_API_DTYPE_INT64``
924
925
 * \param indices Pointer to column indices
 * \param data Pointer to the data space
926
 * \param data_type Type of ``data`` pointer, can be ``C_API_DTYPE_FLOAT32`` or ``C_API_DTYPE_FLOAT64``
927
928
 * \param nindptr Number of rows in the matrix + 1
 * \param nelem Number of nonzero elements in the matrix
929
 * \param num_col Number of columns
930
 * \param predict_type What should be predicted
931
932
933
934
 *   - ``C_API_PREDICT_NORMAL``: normal prediction, with transform (if needed);
 *   - ``C_API_PREDICT_RAW_SCORE``: raw score;
 *   - ``C_API_PREDICT_LEAF_INDEX``: leaf index;
 *   - ``C_API_PREDICT_CONTRIB``: feature contributions (SHAP values)
935
 * \param start_iteration Start index of the iteration to predict
936
937
938
939
940
 * \param num_iteration Number of iterations for prediction, <= 0 means no limit
 * \param parameter Other parameters for prediction, e.g. early stopping for prediction
 * \param[out] out_len Length of output result
 * \param[out] out_result Pointer to array with predictions
 * \return 0 when succeed, -1 when failure happens
941
 */
942
LIGHTGBM_C_EXPORT int LGBM_BoosterPredictForCSR(BoosterHandle handle,
943
944
945
946
947
948
949
950
951
                                                const void* indptr,
                                                int indptr_type,
                                                const int32_t* indices,
                                                const void* data,
                                                int data_type,
                                                int64_t nindptr,
                                                int64_t nelem,
                                                int64_t num_col,
                                                int predict_type,
952
                                                int start_iteration,
953
                                                int num_iteration,
954
                                                const char* parameter,
955
956
                                                int64_t* out_len,
                                                double* out_result);
Guolin Ke's avatar
Guolin Ke committed
957

958
959
960
961
962
963
964
965
966
967
968
969
970
/*!
 * \brief Make sparse prediction for a new dataset in CSR or CSC format. Currently only used for feature contributions.
 * \note
 * The outputs are pre-allocated, as they can vary for each invocation, but the shape should be the same:
 *   - for feature contributions, the shape of sparse matrix will be ``num_class * num_data * (num_feature + 1)``.
 * The output indptr_type for the sparse matrix will be the same as the given input indptr_type.
 * Call ``LGBM_BoosterFreePredictSparse`` to deallocate resources.
 * \param handle Handle of booster
 * \param indptr Pointer to row headers for CSR or column headers for CSC
 * \param indptr_type Type of ``indptr``, can be ``C_API_DTYPE_INT32`` or ``C_API_DTYPE_INT64``
 * \param indices Pointer to column indices for CSR or row indices for CSC
 * \param data Pointer to the data space
 * \param data_type Type of ``data`` pointer, can be ``C_API_DTYPE_FLOAT32`` or ``C_API_DTYPE_FLOAT64``
971
 * \param nindptr Number of entries in ``indptr``
972
973
974
975
 * \param nelem Number of nonzero elements in the matrix
 * \param num_col_or_row Number of columns for CSR or number of rows for CSC
 * \param predict_type What should be predicted, only feature contributions supported currently
 *   - ``C_API_PREDICT_CONTRIB``: feature contributions (SHAP values)
976
 * \param start_iteration Start index of the iteration to predict
977
978
979
 * \param num_iteration Number of iterations for prediction, <= 0 means no limit
 * \param parameter Other parameters for prediction, e.g. early stopping for prediction
 * \param matrix_type Type of matrix input and output, can be ``C_API_MATRIX_TYPE_CSR`` or ``C_API_MATRIX_TYPE_CSC``
980
 * \param[out] out_len Length of output data and output indptr (pointer to an array with two entries where to write them)
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
 * \param[out] out_indptr Pointer to output row headers for CSR or column headers for CSC
 * \param[out] out_indices Pointer to sparse column indices for CSR or row indices for CSC
 * \param[out] out_data Pointer to sparse data space
 * \return 0 when succeed, -1 when failure happens
 */
LIGHTGBM_C_EXPORT int LGBM_BoosterPredictSparseOutput(BoosterHandle handle,
                                                      const void* indptr,
                                                      int indptr_type,
                                                      const int32_t* indices,
                                                      const void* data,
                                                      int data_type,
                                                      int64_t nindptr,
                                                      int64_t nelem,
                                                      int64_t num_col_or_row,
                                                      int predict_type,
996
                                                      int start_iteration,
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
                                                      int num_iteration,
                                                      const char* parameter,
                                                      int matrix_type,
                                                      int64_t* out_len,
                                                      void** out_indptr,
                                                      int32_t** out_indices,
                                                      void** out_data);

/*!
 * \brief Method corresponding to ``LGBM_BoosterPredictSparseOutput`` to free the allocated data.
 * \param indptr Pointer to output row headers or column headers to be deallocated
 * \param indices Pointer to sparse indices to be deallocated
 * \param data Pointer to sparse data space to be deallocated
 * \param indptr_type Type of ``indptr``, can be ``C_API_DTYPE_INT32`` or ``C_API_DTYPE_INT64``
 * \param data_type Type of ``data`` pointer, can be ``C_API_DTYPE_FLOAT32`` or ``C_API_DTYPE_FLOAT64``
 * \return 0 when succeed, -1 when failure happens
 */
LIGHTGBM_C_EXPORT int LGBM_BoosterFreePredictSparse(void* indptr, int32_t* indices, void* data, int indptr_type, int data_type);

1016
/*!
1017
 * \brief Make prediction for a new dataset in CSR format. This method re-uses the internal predictor structure
1018
 *        from previous calls and is optimized for single row invocation.
1019
1020
1021
1022
1023
 * \note
 * You should pre-allocate memory for ``out_result``:
 *   - for normal and raw score, its length is equal to ``num_class * num_data``;
 *   - for leaf index, its length is equal to ``num_class * num_data * num_iteration``;
 *   - for feature contributions, its length is equal to ``num_class * num_data * (num_feature + 1)``.
1024
1025
 * \param handle Handle of booster
 * \param indptr Pointer to row headers
1026
 * \param indptr_type Type of ``indptr``, can be ``C_API_DTYPE_INT32`` or ``C_API_DTYPE_INT64``
1027
1028
 * \param indices Pointer to column indices
 * \param data Pointer to the data space
1029
 * \param data_type Type of ``data`` pointer, can be ``C_API_DTYPE_FLOAT32`` or ``C_API_DTYPE_FLOAT64``
1030
1031
 * \param nindptr Number of rows in the matrix + 1
 * \param nelem Number of nonzero elements in the matrix
1032
 * \param num_col Number of columns
1033
 * \param predict_type What should be predicted
1034
1035
1036
1037
 *   - ``C_API_PREDICT_NORMAL``: normal prediction, with transform (if needed);
 *   - ``C_API_PREDICT_RAW_SCORE``: raw score;
 *   - ``C_API_PREDICT_LEAF_INDEX``: leaf index;
 *   - ``C_API_PREDICT_CONTRIB``: feature contributions (SHAP values)
1038
 * \param start_iteration Start index of the iteration to predict
1039
 * \param num_iteration Number of iterations for prediction, <= 0 means no limit
1040
 * \param parameter Other parameters for prediction, e.g. early stopping for prediction
1041
1042
1043
 * \param[out] out_len Length of output result
 * \param[out] out_result Pointer to array with predictions
 * \return 0 when succeed, -1 when failure happens
1044
 */
1045
LIGHTGBM_C_EXPORT int LGBM_BoosterPredictForCSRSingleRow(BoosterHandle handle,
1046
1047
1048
1049
1050
1051
1052
1053
1054
                                                         const void* indptr,
                                                         int indptr_type,
                                                         const int32_t* indices,
                                                         const void* data,
                                                         int data_type,
                                                         int64_t nindptr,
                                                         int64_t nelem,
                                                         int64_t num_col,
                                                         int predict_type,
1055
                                                         int start_iteration,
1056
1057
1058
1059
                                                         int num_iteration,
                                                         const char* parameter,
                                                         int64_t* out_len,
                                                         double* out_result);
1060

1061
1062
1063
1064
1065
1066
/*!
 * \brief Initialize and return a ``FastConfigHandle`` for use with ``LGBM_BoosterPredictForCSRSingleRowFast``.
 *
 * Release the ``FastConfig`` by passing its handle to ``LGBM_FastConfigFree`` when no longer needed.
 *
 * \param handle Booster handle
1067
1068
1069
1070
1071
 * \param predict_type What should be predicted
 *   - ``C_API_PREDICT_NORMAL``: normal prediction, with transform (if needed);
 *   - ``C_API_PREDICT_RAW_SCORE``: raw score;
 *   - ``C_API_PREDICT_LEAF_INDEX``: leaf index;
 *   - ``C_API_PREDICT_CONTRIB``: feature contributions (SHAP values)
1072
 * \param start_iteration Start index of the iteration to predict
1073
 * \param num_iteration Number of iterations for prediction, <= 0 means no limit
1074
1075
1076
1077
1078
1079
1080
 * \param data_type Type of ``data`` pointer, can be ``C_API_DTYPE_FLOAT32`` or ``C_API_DTYPE_FLOAT64``
 * \param num_col Number of columns
 * \param parameter Other parameters for prediction, e.g. early stopping for prediction
 * \param[out] out_fastConfig FastConfig object with which you can call ``LGBM_BoosterPredictForCSRSingleRowFast``
 * \return 0 when it succeeds, -1 when failure happens
 */
LIGHTGBM_C_EXPORT int LGBM_BoosterPredictForCSRSingleRowFastInit(BoosterHandle handle,
1081
                                                                 const int predict_type,
1082
                                                                 const int start_iteration,
1083
                                                                 const int num_iteration,
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
                                                                 const int data_type,
                                                                 const int64_t num_col,
                                                                 const char* parameter,
                                                                 FastConfigHandle *out_fastConfig);

/*!
 * \brief Faster variant of ``LGBM_BoosterPredictForCSRSingleRow``.
 *
 * Score single rows after setup with ``LGBM_BoosterPredictForCSRSingleRowFastInit``.
 *
 * By removing the setup steps from this call extra optimizations can be made like
 * initializing the config only once, instead of once per call.
 *
 * \note
 *   Setting up the number of threads is only done once at ``LGBM_BoosterPredictForCSRSingleRowFastInit``
 *   instead of at each prediction.
 *   If you use a different number of threads in other calls, you need to start the setup process over,
 *   or that number of threads will be used for these calls as well.
 *
 * \note
 * You should pre-allocate memory for ``out_result``:
 *   - for normal and raw score, its length is equal to ``num_class * num_data``;
 *   - for leaf index, its length is equal to ``num_class * num_data * num_iteration``;
 *   - for feature contributions, its length is equal to ``num_class * num_data * (num_feature + 1)``.
 *
 * \param fastConfig_handle FastConfig object handle returned by ``LGBM_BoosterPredictForCSRSingleRowFastInit``
 * \param indptr Pointer to row headers
 * \param indptr_type Type of ``indptr``, can be ``C_API_DTYPE_INT32`` or ``C_API_DTYPE_INT64``
 * \param indices Pointer to column indices
 * \param data Pointer to the data space
 * \param nindptr Number of rows in the matrix + 1
 * \param nelem Number of nonzero elements in the matrix
 * \param[out] out_len Length of output result
 * \param[out] out_result Pointer to array with predictions
 * \return 0 when succeed, -1 when failure happens
 */
LIGHTGBM_C_EXPORT int LGBM_BoosterPredictForCSRSingleRowFast(FastConfigHandle fastConfig_handle,
                                                             const void* indptr,
1122
                                                             const int indptr_type,
1123
1124
                                                             const int32_t* indices,
                                                             const void* data,
1125
1126
                                                             const int64_t nindptr,
                                                             const int64_t nelem,
1127
1128
1129
                                                             int64_t* out_len,
                                                             double* out_result);

Guolin Ke's avatar
Guolin Ke committed
1130
/*!
1131
 * \brief Make prediction for a new dataset in CSC format.
1132
1133
1134
1135
1136
 * \note
 * You should pre-allocate memory for ``out_result``:
 *   - for normal and raw score, its length is equal to ``num_class * num_data``;
 *   - for leaf index, its length is equal to ``num_class * num_data * num_iteration``;
 *   - for feature contributions, its length is equal to ``num_class * num_data * (num_feature + 1)``.
1137
1138
 * \param handle Handle of booster
 * \param col_ptr Pointer to column headers
1139
 * \param col_ptr_type Type of ``col_ptr``, can be ``C_API_DTYPE_INT32`` or ``C_API_DTYPE_INT64``
1140
1141
 * \param indices Pointer to row indices
 * \param data Pointer to the data space
1142
 * \param data_type Type of ``data`` pointer, can be ``C_API_DTYPE_FLOAT32`` or ``C_API_DTYPE_FLOAT64``
1143
1144
1145
1146
 * \param ncol_ptr Number of columns in the matrix + 1
 * \param nelem Number of nonzero elements in the matrix
 * \param num_row Number of rows
 * \param predict_type What should be predicted
1147
1148
1149
1150
 *   - ``C_API_PREDICT_NORMAL``: normal prediction, with transform (if needed);
 *   - ``C_API_PREDICT_RAW_SCORE``: raw score;
 *   - ``C_API_PREDICT_LEAF_INDEX``: leaf index;
 *   - ``C_API_PREDICT_CONTRIB``: feature contributions (SHAP values)
1151
 * \param start_iteration Start index of the iteration to predict
1152
 * \param num_iteration Number of iteration for prediction, <= 0 means no limit
1153
 * \param parameter Other parameters for prediction, e.g. early stopping for prediction
1154
1155
1156
 * \param[out] out_len Length of output result
 * \param[out] out_result Pointer to array with predictions
 * \return 0 when succeed, -1 when failure happens
1157
 */
1158
LIGHTGBM_C_EXPORT int LGBM_BoosterPredictForCSC(BoosterHandle handle,
1159
1160
1161
1162
1163
1164
1165
1166
1167
                                                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,
1168
                                                int start_iteration,
1169
                                                int num_iteration,
1170
                                                const char* parameter,
1171
1172
                                                int64_t* out_len,
                                                double* out_result);
Guolin Ke's avatar
Guolin Ke committed
1173
1174

/*!
1175
 * \brief Make prediction for a new dataset.
1176
1177
1178
1179
1180
 * \note
 * You should pre-allocate memory for ``out_result``:
 *   - for normal and raw score, its length is equal to ``num_class * num_data``;
 *   - for leaf index, its length is equal to ``num_class * num_data * num_iteration``;
 *   - for feature contributions, its length is equal to ``num_class * num_data * (num_feature + 1)``.
1181
1182
 * \param handle Handle of booster
 * \param data Pointer to the data space
1183
 * \param data_type Type of ``data`` pointer, can be ``C_API_DTYPE_FLOAT32`` or ``C_API_DTYPE_FLOAT64``
1184
1185
1186
1187
 * \param nrow Number of rows
 * \param ncol Number of columns
 * \param is_row_major 1 for row-major, 0 for column-major
 * \param predict_type What should be predicted
1188
1189
1190
1191
 *   - ``C_API_PREDICT_NORMAL``: normal prediction, with transform (if needed);
 *   - ``C_API_PREDICT_RAW_SCORE``: raw score;
 *   - ``C_API_PREDICT_LEAF_INDEX``: leaf index;
 *   - ``C_API_PREDICT_CONTRIB``: feature contributions (SHAP values)
1192
 * \param start_iteration Start index of the iteration to predict
1193
 * \param num_iteration Number of iteration for prediction, <= 0 means no limit
1194
 * \param parameter Other parameters for prediction, e.g. early stopping for prediction
1195
1196
1197
 * \param[out] out_len Length of output result
 * \param[out] out_result Pointer to array with predictions
 * \return 0 when succeed, -1 when failure happens
1198
 */
1199
LIGHTGBM_C_EXPORT int LGBM_BoosterPredictForMat(BoosterHandle handle,
1200
1201
1202
1203
1204
1205
                                                const void* data,
                                                int data_type,
                                                int32_t nrow,
                                                int32_t ncol,
                                                int is_row_major,
                                                int predict_type,
1206
                                                int start_iteration,
1207
                                                int num_iteration,
1208
                                                const char* parameter,
1209
1210
                                                int64_t* out_len,
                                                double* out_result);
Guolin Ke's avatar
Guolin Ke committed
1211

1212
/*!
1213
 * \brief Make prediction for a new dataset. This method re-uses the internal predictor structure
1214
 *        from previous calls and is optimized for single row invocation.
1215
1216
1217
1218
1219
 * \note
 * You should pre-allocate memory for ``out_result``:
 *   - for normal and raw score, its length is equal to ``num_class * num_data``;
 *   - for leaf index, its length is equal to ``num_class * num_data * num_iteration``;
 *   - for feature contributions, its length is equal to ``num_class * num_data * (num_feature + 1)``.
1220
1221
 * \param handle Handle of booster
 * \param data Pointer to the data space
1222
 * \param data_type Type of ``data`` pointer, can be ``C_API_DTYPE_FLOAT32`` or ``C_API_DTYPE_FLOAT64``
1223
 * \param ncol Number columns
1224
 * \param is_row_major 1 for row-major, 0 for column-major
1225
 * \param predict_type What should be predicted
1226
1227
1228
1229
 *   - ``C_API_PREDICT_NORMAL``: normal prediction, with transform (if needed);
 *   - ``C_API_PREDICT_RAW_SCORE``: raw score;
 *   - ``C_API_PREDICT_LEAF_INDEX``: leaf index;
 *   - ``C_API_PREDICT_CONTRIB``: feature contributions (SHAP values)
1230
 * \param start_iteration Start index of the iteration to predict
1231
 * \param num_iteration Number of iteration for prediction, <= 0 means no limit
1232
 * \param parameter Other parameters for prediction, e.g. early stopping for prediction
1233
1234
1235
 * \param[out] out_len Length of output result
 * \param[out] out_result Pointer to array with predictions
 * \return 0 when succeed, -1 when failure happens
1236
 */
1237
LIGHTGBM_C_EXPORT int LGBM_BoosterPredictForMatSingleRow(BoosterHandle handle,
1238
1239
1240
1241
1242
                                                         const void* data,
                                                         int data_type,
                                                         int ncol,
                                                         int is_row_major,
                                                         int predict_type,
1243
                                                         int start_iteration,
1244
1245
1246
1247
                                                         int num_iteration,
                                                         const char* parameter,
                                                         int64_t* out_len,
                                                         double* out_result);
1248

1249
1250
1251
1252
1253
1254
/*!
 * \brief Initialize and return a ``FastConfigHandle`` for use with ``LGBM_BoosterPredictForMatSingleRowFast``.
 *
 * Release the ``FastConfig`` by passing its handle to ``LGBM_FastConfigFree`` when no longer needed.
 *
 * \param handle Booster handle
1255
1256
1257
1258
1259
 * \param predict_type What should be predicted
 *   - ``C_API_PREDICT_NORMAL``: normal prediction, with transform (if needed);
 *   - ``C_API_PREDICT_RAW_SCORE``: raw score;
 *   - ``C_API_PREDICT_LEAF_INDEX``: leaf index;
 *   - ``C_API_PREDICT_CONTRIB``: feature contributions (SHAP values)
1260
 * \param start_iteration Start index of the iteration to predict
1261
 * \param num_iteration Number of iterations for prediction, <= 0 means no limit
1262
1263
1264
1265
1266
1267
1268
 * \param data_type Type of ``data`` pointer, can be ``C_API_DTYPE_FLOAT32`` or ``C_API_DTYPE_FLOAT64``
 * \param ncol Number of columns
 * \param parameter Other parameters for prediction, e.g. early stopping for prediction
 * \param[out] out_fastConfig FastConfig object with which you can call ``LGBM_BoosterPredictForMatSingleRowFast``
 * \return 0 when it succeeds, -1 when failure happens
 */
LIGHTGBM_C_EXPORT int LGBM_BoosterPredictForMatSingleRowFastInit(BoosterHandle handle,
1269
                                                                 const int predict_type,
1270
                                                                 const int start_iteration,
1271
1272
1273
                                                                 const int num_iteration,
                                                                 const int data_type,
                                                                 const int32_t ncol,
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
                                                                 const char* parameter,
                                                                 FastConfigHandle *out_fastConfig);

/*!
 * \brief Faster variant of ``LGBM_BoosterPredictForMatSingleRow``.
 *
 * Score a single row after setup with ``LGBM_BoosterPredictForMatSingleRowFastInit``.
 *
 * By removing the setup steps from this call extra optimizations can be made like
 * initializing the config only once, instead of once per call.
 *
 * \note
 *   Setting up the number of threads is only done once at ``LGBM_BoosterPredictForMatSingleRowFastInit``
 *   instead of at each prediction.
 *   If you use a different number of threads in other calls, you need to start the setup process over,
 *   or that number of threads will be used for these calls as well.
 *
 * \param fastConfig_handle FastConfig object handle returned by ``LGBM_BoosterPredictForMatSingleRowFastInit``
 * \param data Single-row array data (no other way than row-major form).
 * \param[out] out_len Length of output result
 * \param[out] out_result Pointer to array with predictions
 * \return 0 when it succeeds, -1 when failure happens
 */
LIGHTGBM_C_EXPORT int LGBM_BoosterPredictForMatSingleRowFast(FastConfigHandle fastConfig_handle,
                                                             const void* data,
                                                             int64_t* out_len,
                                                             double* out_result);

1302
1303
/*!
 * \brief Make prediction for a new dataset presented in a form of array of pointers to rows.
1304
1305
1306
1307
1308
 * \note
 * You should pre-allocate memory for ``out_result``:
 *   - for normal and raw score, its length is equal to ``num_class * num_data``;
 *   - for leaf index, its length is equal to ``num_class * num_data * num_iteration``;
 *   - for feature contributions, its length is equal to ``num_class * num_data * (num_feature + 1)``.
1309
1310
 * \param handle Handle of booster
 * \param data Pointer to the data space
1311
 * \param data_type Type of ``data`` pointer, can be ``C_API_DTYPE_FLOAT32`` or ``C_API_DTYPE_FLOAT64``
1312
1313
1314
 * \param nrow Number of rows
 * \param ncol Number columns
 * \param predict_type What should be predicted
1315
1316
1317
1318
 *   - ``C_API_PREDICT_NORMAL``: normal prediction, with transform (if needed);
 *   - ``C_API_PREDICT_RAW_SCORE``: raw score;
 *   - ``C_API_PREDICT_LEAF_INDEX``: leaf index;
 *   - ``C_API_PREDICT_CONTRIB``: feature contributions (SHAP values)
1319
 * \param start_iteration Start index of the iteration to predict
1320
 * \param num_iteration Number of iteration for prediction, <= 0 means no limit
1321
 * \param parameter Other parameters for prediction, e.g. early stopping for prediction
1322
1323
1324
 * \param[out] out_len Length of output result
 * \param[out] out_result Pointer to array with predictions
 * \return 0 when succeed, -1 when failure happens
1325
 */
1326
1327
1328
1329
1330
1331
LIGHTGBM_C_EXPORT int LGBM_BoosterPredictForMats(BoosterHandle handle,
                                                 const void** data,
                                                 int data_type,
                                                 int32_t nrow,
                                                 int32_t ncol,
                                                 int predict_type,
1332
                                                 int start_iteration,
1333
1334
1335
1336
                                                 int num_iteration,
                                                 const char* parameter,
                                                 int64_t* out_len,
                                                 double* out_result);
1337

Guolin Ke's avatar
Guolin Ke committed
1338
/*!
1339
1340
1341
1342
 * \brief Save model into file.
 * \param handle Handle of booster
 * \param start_iteration Start index of the iteration that should be saved
 * \param num_iteration Index of the iteration that should be saved, <= 0 means save all
1343
 * \param feature_importance_type Type of feature importance, can be ``C_API_FEATURE_IMPORTANCE_SPLIT`` or ``C_API_FEATURE_IMPORTANCE_GAIN``
1344
 * \param filename The name of the file
1345
 * \return 0 when succeed, -1 when failure happens
1346
 */
1347
LIGHTGBM_C_EXPORT int LGBM_BoosterSaveModel(BoosterHandle handle,
1348
                                            int start_iteration,
1349
                                            int num_iteration,
1350
                                            int feature_importance_type,
1351
                                            const char* filename);
Guolin Ke's avatar
Guolin Ke committed
1352

1353
/*!
1354
1355
1356
1357
 * \brief Save model to string.
 * \param handle Handle of booster
 * \param start_iteration Start index of the iteration that should be saved
 * \param num_iteration Index of the iteration that should be saved, <= 0 means save all
1358
 * \param feature_importance_type Type of feature importance, can be ``C_API_FEATURE_IMPORTANCE_SPLIT`` or ``C_API_FEATURE_IMPORTANCE_GAIN``
1359
 * \param buffer_len String buffer length, if ``buffer_len < out_len``, you should re-allocate buffer
1360
1361
1362
 * \param[out] out_len Actual output length
 * \param[out] out_str String of model, should pre-allocate memory
 * \return 0 when succeed, -1 when failure happens
1363
 */
1364
LIGHTGBM_C_EXPORT int LGBM_BoosterSaveModelToString(BoosterHandle handle,
1365
                                                    int start_iteration,
1366
                                                    int num_iteration,
1367
                                                    int feature_importance_type,
1368
1369
                                                    int64_t buffer_len,
                                                    int64_t* out_len,
1370
                                                    char* out_str);
1371

wxchan's avatar
wxchan committed
1372
/*!
1373
1374
1375
 * \brief Dump model to JSON.
 * \param handle Handle of booster
 * \param start_iteration Start index of the iteration that should be dumped
1376
 * \param num_iteration Index of the iteration that should be dumped, <= 0 means dump all
1377
 * \param feature_importance_type Type of feature importance, can be ``C_API_FEATURE_IMPORTANCE_SPLIT`` or ``C_API_FEATURE_IMPORTANCE_GAIN``
1378
 * \param buffer_len String buffer length, if ``buffer_len < out_len``, you should re-allocate buffer
1379
1380
1381
 * \param[out] out_len Actual output length
 * \param[out] out_str JSON format string of model, should pre-allocate memory
 * \return 0 when succeed, -1 when failure happens
1382
 */
1383
LIGHTGBM_C_EXPORT int LGBM_BoosterDumpModel(BoosterHandle handle,
1384
                                            int start_iteration,
1385
                                            int num_iteration,
1386
                                            int feature_importance_type,
1387
1388
                                            int64_t buffer_len,
                                            int64_t* out_len,
1389
                                            char* out_str);
1390

Guolin Ke's avatar
Guolin Ke committed
1391
/*!
1392
1393
1394
1395
1396
1397
 * \brief Get leaf value.
 * \param handle Handle of booster
 * \param tree_idx Index of tree
 * \param leaf_idx Index of leaf
 * \param[out] out_val Output result from the specified leaf
 * \return 0 when succeed, -1 when failure happens
1398
 */
1399
LIGHTGBM_C_EXPORT int LGBM_BoosterGetLeafValue(BoosterHandle handle,
1400
1401
1402
                                               int tree_idx,
                                               int leaf_idx,
                                               double* out_val);
Guolin Ke's avatar
Guolin Ke committed
1403
1404

/*!
1405
1406
1407
1408
1409
1410
 * \brief Set leaf value.
 * \param handle Handle of booster
 * \param tree_idx Index of tree
 * \param leaf_idx Index of leaf
 * \param val Leaf value
 * \return 0 when succeed, -1 when failure happens
1411
 */
1412
LIGHTGBM_C_EXPORT int LGBM_BoosterSetLeafValue(BoosterHandle handle,
1413
1414
1415
                                               int tree_idx,
                                               int leaf_idx,
                                               double val);
1416

1417
/*!
1418
1419
1420
1421
 * \brief Get model feature importance.
 * \param handle Handle of booster
 * \param num_iteration Number of iterations for which feature importance is calculated, <= 0 means use all
 * \param importance_type Method of importance calculation:
1422
1423
 *   - ``C_API_FEATURE_IMPORTANCE_SPLIT``: result contains numbers of times the feature is used in a model;
 *   - ``C_API_FEATURE_IMPORTANCE_GAIN``: result contains total gains of splits which use the feature
1424
1425
 * \param[out] out_results Result array with feature importance
 * \return 0 when succeed, -1 when failure happens
1426
 */
1427
1428
1429
1430
1431
LIGHTGBM_C_EXPORT int LGBM_BoosterFeatureImportance(BoosterHandle handle,
                                                    int num_iteration,
                                                    int importance_type,
                                                    double* out_results);

1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
/*!
 * \brief Get model upper bound value.
 * \param handle Handle of booster
 * \param[out] out_results Result pointing to max value
 * \return 0 when succeed, -1 when failure happens
 */
LIGHTGBM_C_EXPORT int LGBM_BoosterGetUpperBoundValue(BoosterHandle handle,
                                                     double* out_results);

/*!
 * \brief Get model lower bound value.
 * \param handle Handle of booster
 * \param[out] out_results Result pointing to min value
 * \return 0 when succeed, -1 when failure happens
 */
LIGHTGBM_C_EXPORT int LGBM_BoosterGetLowerBoundValue(BoosterHandle handle,
                                                     double* out_results);

1450
/*!
1451
1452
1453
1454
1455
1456
 * \brief Initialize the network.
 * \param machines List of machines in format 'ip1:port1,ip2:port2'
 * \param local_listen_port TCP listen port for local machines
 * \param listen_time_out Socket time-out in minutes
 * \param num_machines Total number of machines
 * \return 0 when succeed, -1 when failure happens
1457
 */
1458
1459
1460
1461
1462
1463
LIGHTGBM_C_EXPORT int LGBM_NetworkInit(const char* machines,
                                       int local_listen_port,
                                       int listen_time_out,
                                       int num_machines);

/*!
1464
1465
 * \brief Finalize the network.
 * \return 0 when succeed, -1 when failure happens
1466
 */
1467
1468
LIGHTGBM_C_EXPORT int LGBM_NetworkFree();

1469
1470
1471
1472
1473
1474
1475
/*!
 * \brief Initialize the network with external collective functions.
 * \param num_machines Total number of machines
 * \param rank Rank of local machine
 * \param reduce_scatter_ext_fun The external reduce-scatter function
 * \param allgather_ext_fun The external allgather function
 * \return 0 when succeed, -1 when failure happens
1476
1477
1478
 */
LIGHTGBM_C_EXPORT int LGBM_NetworkInitWithFunctions(int num_machines,
                                                    int rank,
1479
                                                    void* reduce_scatter_ext_fun,
1480
                                                    void* allgather_ext_fun);
1481

1482
#if !defined(__cplusplus) && (!defined(__STDC__) || (__STDC_VERSION__ < 199901L))
1483
1484
/*! \brief Inline specifier no-op in C using standards before C99. */
#define INLINE_FUNCTION
1485
#else
1486
1487
/*! \brief Inline specifier. */
#define INLINE_FUNCTION inline
1488
1489
1490
#endif

#if !defined(__cplusplus) && (!defined(__STDC__) || (__STDC_VERSION__ < 201112L))
1491
1492
/*! \brief Thread local specifier no-op in C using standards before C11. */
#define THREAD_LOCAL
1493
#elif !defined(__cplusplus)
1494
1495
/*! \brief Thread local specifier. */
#define THREAD_LOCAL _Thread_local
1496
#elif defined(_MSC_VER)
1497
1498
/*! \brief Thread local specifier. */
#define THREAD_LOCAL __declspec(thread)
Guolin Ke's avatar
Guolin Ke committed
1499
#else
1500
1501
/*! \brief Thread local specifier. */
#define THREAD_LOCAL thread_local
Guolin Ke's avatar
Guolin Ke committed
1502
#endif
1503
1504
1505
1506
1507

/*!
 * \brief Handle of error message.
 * \return Error message
 */
1508
static char* LastErrorMsg() { static THREAD_LOCAL char err_msg[512] = "Everything is fine"; return err_msg; }
1509

1510
1511
1512
#ifdef _MSC_VER
  #pragma warning(disable : 4996)
#endif
1513
1514
/*!
 * \brief Set string message of the last error.
1515
1516
 * \note
 * This will call unsafe ``sprintf`` when compiled using C standards before C99.
1517
1518
 * \param msg Error message
 */
1519
INLINE_FUNCTION void LGBM_SetLastError(const char* msg) {
1520
1521
1522
#if !defined(__cplusplus) && (!defined(__STDC__) || (__STDC_VERSION__ < 199901L))
  sprintf(LastErrorMsg(), "%s", msg);  /* NOLINT(runtime/printf) */
#else
1523
1524
  const int err_buf_len = 512;
  snprintf(LastErrorMsg(), err_buf_len, "%s", msg);
1525
#endif
1526
1527
}

1528
#endif  /* LIGHTGBM_C_API_H_ */