config.h 54.5 KB
Newer Older
1
2
3
4
5
6
7
/*!
 * Copyright (c) 2016 Microsoft Corporation. All rights reserved.
 * Licensed under the MIT License. See LICENSE file in the project root for license information.
 *
 * \note
 * desc and descl2 fields must be written in reStructuredText format
 */
Guolin Ke's avatar
Guolin Ke committed
8
9
10
#ifndef LIGHTGBM_CONFIG_H_
#define LIGHTGBM_CONFIG_H_

11
12
#include <LightGBM/export.h>
#include <LightGBM/meta.h>
Guolin Ke's avatar
Guolin Ke committed
13
14
15
16
17
#include <LightGBM/utils/common.h>
#include <LightGBM/utils/log.h>

#include <string>
#include <algorithm>
Guolin Ke's avatar
Guolin Ke committed
18
#include <memory>
19
20
21
#include <unordered_map>
#include <unordered_set>
#include <vector>
Guolin Ke's avatar
Guolin Ke committed
22
23
24

namespace LightGBM {

Guolin Ke's avatar
Guolin Ke committed
25
26
27
28
/*! \brief Types of tasks */
enum TaskType {
  kTrain, kPredict, kConvertModel, KRefitTree
};
29
const int kDefaultNumLeaves = 31;
Guolin Ke's avatar
Guolin Ke committed
30

Guolin Ke's avatar
Guolin Ke committed
31
struct Config {
Nikita Titov's avatar
Nikita Titov committed
32
 public:
Guolin Ke's avatar
Guolin Ke committed
33
  std::string ToString() const;
Guolin Ke's avatar
Guolin Ke committed
34
35
36
37
  /*!
  * \brief Get string value by specific name of key
  * \param params Store the key and value for params
  * \param name Name of key
Hui Xue's avatar
Hui Xue committed
38
  * \param out Value will assign to out if key exists
Guolin Ke's avatar
Guolin Ke committed
39
40
  * \return True if key exists
  */
Guolin Ke's avatar
Guolin Ke committed
41
  inline static bool GetString(
Guolin Ke's avatar
Guolin Ke committed
42
43
44
45
46
47
48
    const std::unordered_map<std::string, std::string>& params,
    const std::string& name, std::string* out);

  /*!
  * \brief Get int value by specific name of key
  * \param params Store the key and value for params
  * \param name Name of key
Hui Xue's avatar
Hui Xue committed
49
  * \param out Value will assign to out if key exists
Guolin Ke's avatar
Guolin Ke committed
50
51
  * \return True if key exists
  */
Guolin Ke's avatar
Guolin Ke committed
52
  inline static bool GetInt(
Guolin Ke's avatar
Guolin Ke committed
53
54
55
56
    const std::unordered_map<std::string, std::string>& params,
    const std::string& name, int* out);

  /*!
57
  * \brief Get double value by specific name of key
Guolin Ke's avatar
Guolin Ke committed
58
59
  * \param params Store the key and value for params
  * \param name Name of key
Hui Xue's avatar
Hui Xue committed
60
  * \param out Value will assign to out if key exists
Guolin Ke's avatar
Guolin Ke committed
61
62
  * \return True if key exists
  */
Guolin Ke's avatar
Guolin Ke committed
63
  inline static bool GetDouble(
Guolin Ke's avatar
Guolin Ke committed
64
    const std::unordered_map<std::string, std::string>& params,
65
    const std::string& name, double* out);
Guolin Ke's avatar
Guolin Ke committed
66
67
68
69
70

  /*!
  * \brief Get bool value by specific name of key
  * \param params Store the key and value for params
  * \param name Name of key
Hui Xue's avatar
Hui Xue committed
71
  * \param out Value will assign to out if key exists
Guolin Ke's avatar
Guolin Ke committed
72
73
  * \return True if key exists
  */
Guolin Ke's avatar
Guolin Ke committed
74
  inline static bool GetBool(
Guolin Ke's avatar
Guolin Ke committed
75
76
    const std::unordered_map<std::string, std::string>& params,
    const std::string& name, bool* out);
77

Guolin Ke's avatar
Guolin Ke committed
78
  static void KV2Map(std::unordered_map<std::string, std::string>* params, const char* kv);
79
  static std::unordered_map<std::string, std::string> Str2Map(const char* parameters);
Guolin Ke's avatar
Guolin Ke committed
80

Guolin Ke's avatar
Guolin Ke committed
81
  #pragma region Parameters
82

Guolin Ke's avatar
Guolin Ke committed
83
84
85
  #pragma region Core Parameters

  // [doc-only]
86
87
  // alias = config_file
  // desc = path of config file
88
  // desc = **Note**: can be used only in CLI version
Guolin Ke's avatar
Guolin Ke committed
89
90
91
  std::string config = "";

  // [doc-only]
92
93
94
95
96
97
98
99
  // type = enum
  // default = train
  // options = train, predict, convert_model, refit
  // alias = task_type
  // desc = ``train``, for training, aliases: ``training``
  // desc = ``predict``, for prediction, aliases: ``prediction``, ``test``
  // desc = ``convert_model``, for converting model file into if-else format, see more information in `IO Parameters <#io-parameters>`__
  // desc = ``refit``, for refitting existing models with new data, aliases: ``refit_tree``
Guolin Ke's avatar
Guolin Ke committed
100
  // desc = **Note**: can be used only in CLI version; for language-specific packages you can use the correspondent functions
Guolin Ke's avatar
Guolin Ke committed
101
102
103
  TaskType task = TaskType::kTrain;

  // [doc-only]
104
  // type = enum
105
  // options = regression, regression_l1, huber, fair, poisson, quantile, mape, gamma, tweedie, binary, multiclass, multiclassova, cross_entropy, cross_entropy_lambda, lambdarank, rank_xendcg
106
107
  // alias = objective_type, app, application
  // desc = regression application
Guolin Ke's avatar
Guolin Ke committed
108
109
  // descl2 = ``regression``, L2 loss, aliases: ``regression_l2``, ``l2``, ``mean_squared_error``, ``mse``, ``l2_root``, ``root_mean_squared_error``, ``rmse``
  // descl2 = ``regression_l1``, L1 loss, aliases: ``l1``, ``mean_absolute_error``, ``mae``
110
111
112
113
114
  // descl2 = ``huber``, `Huber loss <https://en.wikipedia.org/wiki/Huber_loss>`__
  // descl2 = ``fair``, `Fair loss <https://www.kaggle.com/c/allstate-claims-severity/discussion/24520>`__
  // descl2 = ``poisson``, `Poisson regression <https://en.wikipedia.org/wiki/Poisson_regression>`__
  // descl2 = ``quantile``, `Quantile regression <https://en.wikipedia.org/wiki/Quantile_regression>`__
  // descl2 = ``mape``, `MAPE loss <https://en.wikipedia.org/wiki/Mean_absolute_percentage_error>`__, aliases: ``mean_absolute_percentage_error``
115
  // descl2 = ``gamma``, Gamma regression with log-link. It might be useful, e.g., for modeling insurance claims severity, or for any target that might be `gamma-distributed <https://en.wikipedia.org/wiki/Gamma_distribution#Occurrence_and_applications>`__
116
  // descl2 = ``tweedie``, Tweedie regression with log-link. It might be useful, e.g., for modeling total loss in insurance, or for any target that might be `tweedie-distributed <https://en.wikipedia.org/wiki/Tweedie_distribution#Occurrence_and_applications>`__
117
118
119
  // desc = binary classification application
  // descl2 = ``binary``, binary `log loss <https://en.wikipedia.org/wiki/Cross_entropy>`__ classification (or logistic regression)
  // descl2 = requires labels in {0, 1}; see ``cross-entropy`` application for general probability labels in [0, 1]
120
121
122
123
124
  // desc = multi-class classification application
  // descl2 = ``multiclass``, `softmax <https://en.wikipedia.org/wiki/Softmax_function>`__ objective function, aliases: ``softmax``
  // descl2 = ``multiclassova``, `One-vs-All <https://en.wikipedia.org/wiki/Multiclass_classification#One-vs.-rest>`__ binary objective function, aliases: ``multiclass_ova``, ``ova``, ``ovr``
  // descl2 = ``num_class`` should be set as well
  // desc = cross-entropy application
Guolin Ke's avatar
Guolin Ke committed
125
126
  // descl2 = ``cross_entropy``, objective function for cross-entropy (with optional linear weights), aliases: ``xentropy``
  // descl2 = ``cross_entropy_lambda``, alternative parameterization of cross-entropy, aliases: ``xentlambda``
127
  // descl2 = label is anything in interval [0, 1]
128
  // desc = ranking application
129
  // descl2 = ``lambdarank``, `lambdarank <https://papers.nips.cc/paper/2971-learning-to-rank-with-nonsmooth-cost-functions.pdf>`__ objective. `label_gain <#label_gain>`__ can be used to set the gain (weight) of ``int`` label and all values in ``label`` must be smaller than number of elements in ``label_gain``
130
131
  // descl2 = ``rank_xendcg``, `XE_NDCG_MART <https://arxiv.org/abs/1911.09798>`__ ranking objective function. To obtain reproducible results, you should disable parallelism by setting ``num_threads`` to 1, aliases: ``xendcg``, ``xe_ndcg``, ``xe_ndcg_mart``, ``xendcg_mart``
  // descl2 = label should be ``int`` type, and larger number represents the higher relevance (e.g. 0:bad, 1:fair, 2:good, 3:perfect)
Guolin Ke's avatar
Guolin Ke committed
132
133
134
  std::string objective = "regression";

  // [doc-only]
135
136
  // type = enum
  // alias = boosting_type, boost
137
  // options = gbdt, rf, dart, goss
138
139
  // desc = ``gbdt``, traditional Gradient Boosting Decision Tree, aliases: ``gbrt``
  // desc = ``rf``, Random Forest, aliases: ``random_forest``
140
141
  // desc = ``dart``, `Dropouts meet Multiple Additive Regression Trees <https://arxiv.org/abs/1505.01866>`__
  // desc = ``goss``, Gradient-based One-Side Sampling
Guolin Ke's avatar
Guolin Ke committed
142
143
  std::string boosting = "gbdt";

144
  // alias = train, train_data, train_data_file, data_filename
145
  // desc = path of training data, LightGBM will train from this data
146
  // desc = **Note**: can be used only in CLI version
Guolin Ke's avatar
Guolin Ke committed
147
148
  std::string data = "";

149
  // alias = test, valid_data, valid_data_file, test_data, test_data_file, valid_filenames
150
  // default = ""
151
  // desc = path(s) of validation/test data, LightGBM will output metrics for these data
152
  // desc = support multiple validation data, separated by ``,``
153
  // desc = **Note**: can be used only in CLI version
Guolin Ke's avatar
Guolin Ke committed
154
155
  std::vector<std::string> valid;

156
  // alias = num_iteration, n_iter, num_tree, num_trees, num_round, num_rounds, num_boost_round, n_estimators
157
158
159
  // check = >=0
  // desc = number of boosting iterations
  // desc = **Note**: internally, LightGBM constructs ``num_class * num_iterations`` trees for multi-class classification problems
Guolin Ke's avatar
Guolin Ke committed
160
  int num_iterations = 100;
Guolin Ke's avatar
Guolin Ke committed
161

162
  // alias = shrinkage_rate, eta
163
  // check = >0.0
164
165
  // desc = shrinkage rate
  // desc = in ``dart``, it also affects on normalization weights of dropped trees
Guolin Ke's avatar
Guolin Ke committed
166
167
  double learning_rate = 0.1;

168
  // default = 31
169
  // alias = num_leaf, max_leaves, max_leaf
170
  // check = >1
171
  // check = <=131072
172
  // desc = max number of leaves in one tree
Guolin Ke's avatar
Guolin Ke committed
173
174
175
  int num_leaves = kDefaultNumLeaves;

  // [doc-only]
176
177
  // type = enum
  // options = serial, feature, data, voting
178
  // alias = tree, tree_type, tree_learner_type
179
180
181
182
183
  // desc = ``serial``, single machine tree learner
  // desc = ``feature``, feature parallel tree learner, aliases: ``feature_parallel``
  // desc = ``data``, data parallel tree learner, aliases: ``data_parallel``
  // desc = ``voting``, voting parallel tree learner, aliases: ``voting_parallel``
  // desc = refer to `Parallel Learning Guide <./Parallel-Learning-Guide.rst>`__ to get more details
Guolin Ke's avatar
Guolin Ke committed
184
185
  std::string tree_learner = "serial";

186
  // alias = num_thread, nthread, nthreads, n_jobs
Guolin Ke's avatar
Guolin Ke committed
187
  // desc = number of threads for LightGBM
188
189
190
191
192
  // desc = ``0`` means default number of threads in OpenMP
  // desc = for the best speed, set this to the number of **real CPU cores**, not the number of threads (most CPUs use `hyper-threading <https://en.wikipedia.org/wiki/Hyper-threading>`__ to generate 2 threads per CPU core)
  // desc = do not set it too large if your dataset is small (for instance, do not use 64 threads for a dataset with 10,000 rows)
  // desc = be aware a task manager or any similar CPU monitoring tool might report that cores not being fully utilized. **This is normal**
  // desc = for parallel learning, do not use all CPU cores because this will cause poor performance for the network communication
Guolin Ke's avatar
Guolin Ke committed
193
194
195
  int num_threads = 0;

  // [doc-only]
196
197
  // type = enum
  // options = cpu, gpu
198
  // alias = device
199
200
201
202
  // desc = device for the tree learning, you can use GPU to achieve the faster learning
  // desc = **Note**: it is recommended to use the smaller ``max_bin`` (e.g. 63) to get the better speed up
  // desc = **Note**: for the faster speed, GPU uses 32-bit float point to sum up by default, so this may affect the accuracy for some tasks. You can set ``gpu_use_dp=true`` to enable 64-bit float point, but it will slow down the training
  // desc = **Note**: refer to `Installation Guide <./Installation-Guide.rst#build-gpu-version>`__ to build LightGBM with GPU support
Guolin Ke's avatar
Guolin Ke committed
203
204
205
  std::string device_type = "cpu";

  // [doc-only]
206
  // alias = random_seed, random_state
207
208
209
210
  // default = None
  // desc = this seed is used to generate other seeds, e.g. ``data_random_seed``, ``feature_fraction_seed``, etc.
  // desc = by default, this seed is unused in favor of default values of other seeds
  // desc = this seed has lower priority in comparison with other seeds, which means that it will be overridden, if you set other seeds explicitly
Guolin Ke's avatar
Guolin Ke committed
211
212
213
214
215
216
  int seed = 0;

  #pragma endregion

  #pragma region Learning Control Parameters

217
218
219
220
221
222
223
224
225
  // desc = used only with ``cpu`` device type
  // desc = set this to ``true`` to force col-wise histogram building
  // desc = enabling this is recommended when:
  // descl2 = the number of columns is large, or the total number of bins is large
  // descl2 = ``num_threads`` is large, e.g. ``>20``
  // descl2 = you want to use small ``feature_fraction`` (e.g. ``0.5``) to speed up
  // descl2 = you want to reduce memory cost
  // desc = **Note**: when both ``force_col_wise`` and ``force_row_wise`` are ``false``, LightGBM will firstly try them both, and then use the faster one. To remove the overhead of testing set the faster one to ``true`` manually
  // desc = **Note**: this parameter cannot be used at the same time with ``force_row_wise``, choose only one of them
226
227
  bool force_col_wise = false;

228
229
230
231
232
233
234
235
236
  // desc = used only with ``cpu`` device type
  // desc = set this to ``true`` to force row-wise histogram building
  // desc = enabling this is recommended when:
  // descl2 = the number of data points is large, and the total number of bins is relatively small
  // descl2 = ``num_threads`` is relatively small, e.g. ``<=16``
  // descl2 = you want to use small ``bagging_fraction`` or ``goss`` boosting to speed up
  // desc = **Note**: setting this to ``true`` will double the memory cost for Dataset object. If you have not enough memory, you can try setting ``force_col_wise=true``
  // desc = **Note**: when both ``force_col_wise`` and ``force_row_wise`` are ``false``, LightGBM will firstly try them both, and then use the faster one. To remove the overhead of testing set the faster one to ``true`` manually
  // desc = **Note**: this parameter cannot be used at the same time with ``force_col_wise``, choose only one of them
237
238
  bool force_row_wise = false;

239
  // desc = limit the max depth for tree model. This is used to deal with over-fitting when ``#data`` is small. Tree still grows leaf-wise
240
  // desc = ``<= 0`` means no limit
Guolin Ke's avatar
Guolin Ke committed
241
242
243
  int max_depth = -1;

  // alias = min_data_per_leaf, min_data, min_child_samples
244
245
  // check = >=0
  // desc = minimal number of data in one leaf. Can be used to deal with over-fitting
Guolin Ke's avatar
Guolin Ke committed
246
247
  int min_data_in_leaf = 20;

248
249
250
  // alias = min_sum_hessian_per_leaf, min_sum_hessian, min_hessian, min_child_weight
  // check = >=0.0
  // desc = minimal sum hessian in one leaf. Like ``min_data_in_leaf``, it can be used to deal with over-fitting
Guolin Ke's avatar
Guolin Ke committed
251
252
  double min_sum_hessian_in_leaf = 1e-3;

253
254
255
256
257
258
259
  // alias = sub_row, subsample, bagging
  // check = >0.0
  // check = <=1.0
  // desc = like ``feature_fraction``, but this will randomly select part of data without resampling
  // desc = can be used to speed up training
  // desc = can be used to deal with over-fitting
  // desc = **Note**: to enable bagging, ``bagging_freq`` should be set to a non zero value as well
Guolin Ke's avatar
Guolin Ke committed
260
261
  double bagging_fraction = 1.0;

Guolin Ke's avatar
Guolin Ke committed
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
  // alias = pos_sub_row, pos_subsample, pos_bagging
  // check = >0.0
  // check = <=1.0
  // desc = used only in ``binary`` application
  // desc = used for imbalanced binary classification problem, will randomly sample ``#pos_samples * pos_bagging_fraction`` positive samples in bagging
  // desc = should be used together with ``neg_bagging_fraction``
  // desc = set this to ``1.0`` to disable
  // desc = **Note**: to enable this, you need to set ``bagging_freq`` and ``neg_bagging_fraction`` as well
  // desc = **Note**: if both ``pos_bagging_fraction`` and ``neg_bagging_fraction`` are set to ``1.0``,  balanced bagging is disabled
  // desc = **Note**: if balanced bagging is enabled, ``bagging_fraction`` will be ignored
  double pos_bagging_fraction = 1.0;

  // alias = neg_sub_row, neg_subsample, neg_bagging
  // check = >0.0
  // check = <=1.0
  // desc = used only in ``binary`` application
  // desc = used for imbalanced binary classification problem, will randomly sample ``#neg_samples * neg_bagging_fraction`` negative samples in bagging
  // desc = should be used together with ``pos_bagging_fraction``
  // desc = set this to ``1.0`` to disable
  // desc = **Note**: to enable this, you need to set ``bagging_freq`` and ``pos_bagging_fraction`` as well
  // desc = **Note**: if both ``pos_bagging_fraction`` and ``neg_bagging_fraction`` are set to ``1.0``,  balanced bagging is disabled
  // desc = **Note**: if balanced bagging is enabled, ``bagging_fraction`` will be ignored
  double neg_bagging_fraction = 1.0;

286
287
288
289
  // alias = subsample_freq
  // desc = frequency for bagging
  // desc = ``0`` means disable bagging; ``k`` means perform bagging at every ``k`` iteration
  // desc = **Note**: to enable bagging, ``bagging_fraction`` should be set to value smaller than ``1.0`` as well
Guolin Ke's avatar
Guolin Ke committed
290
291
292
293
294
295
296
  int bagging_freq = 0;

  // alias = bagging_fraction_seed
  // desc = random seed for bagging
  int bagging_seed = 3;

  // alias = sub_feature, colsample_bytree
297
298
  // check = >0.0
  // check = <=1.0
299
  // desc = LightGBM will randomly select part of features on each iteration (tree) if ``feature_fraction`` smaller than ``1.0``. For example, if you set it to ``0.8``, LightGBM will select 80% of features before training each tree
300
301
  // desc = can be used to speed up training
  // desc = can be used to deal with over-fitting
Guolin Ke's avatar
Guolin Ke committed
302
303
  double feature_fraction = 1.0;

304
305
306
  // alias = sub_feature_bynode, colsample_bynode
  // check = >0.0
  // check = <=1.0
Nikita Titov's avatar
Nikita Titov committed
307
  // desc = LightGBM will randomly select part of features on each tree node if ``feature_fraction_bynode`` smaller than ``1.0``. For example, if you set it to ``0.8``, LightGBM will select 80% of features at each tree node
308
309
310
311
312
  // desc = can be used to deal with over-fitting
  // desc = **Note**: unlike ``feature_fraction``, this cannot speed up training
  // desc = **Note**: if both ``feature_fraction`` and ``feature_fraction_bynode`` are smaller than ``1.0``, the final fraction of each node is ``feature_fraction * feature_fraction_bynode``
  double feature_fraction_bynode = 1.0;

313
  // desc = random seed for ``feature_fraction``
Guolin Ke's avatar
Guolin Ke committed
314
315
  int feature_fraction_seed = 2;

316
317
318
319
320
321
322
323
  // desc = use extremely randomized trees
  // desc = if set to ``true``, when evaluating node splits LightGBM will check only one randomly-chosen threshold for each feature
  // desc = can be used to deal with over-fitting
  bool extra_trees = false;

  // desc = random seed for selecting thresholds when ``extra_trees`` is true
  int extra_seed = 6;

324
  // alias = early_stopping_rounds, early_stopping, n_iter_no_change
325
326
  // desc = will stop training if one metric of one validation data doesn't improve in last ``early_stopping_round`` rounds
  // desc = ``<= 0`` means disable
Guolin Ke's avatar
Guolin Ke committed
327
328
  int early_stopping_round = 0;

329
330
331
  // desc = set this to ``true``, if you want to use only the first metric for early stopping
  bool first_metric_only = false;

332
333
334
335
  // alias = max_tree_output, max_leaf_output
  // desc = used to limit the max output of tree leaves
  // desc = ``<= 0`` means no constraint
  // desc = the final max output of leaves is ``learning_rate * max_delta_step``
Guolin Ke's avatar
Guolin Ke committed
336
337
  double max_delta_step = 0.0;

338
339
340
  // alias = reg_alpha
  // check = >=0.0
  // desc = L1 regularization
Guolin Ke's avatar
Guolin Ke committed
341
342
  double lambda_l1 = 0.0;

343
  // alias = reg_lambda, lambda
344
  // check = >=0.0
Guolin Ke's avatar
Guolin Ke committed
345
346
347
  // desc = L2 regularization
  double lambda_l2 = 0.0;

348
349
350
  // alias = min_split_gain
  // check = >=0.0
  // desc = the minimal gain to perform split
Guolin Ke's avatar
Guolin Ke committed
351
352
  double min_gain_to_split = 0.0;

353
  // alias = rate_drop
354
355
356
  // check = >=0.0
  // check = <=1.0
  // desc = used only in ``dart``
357
  // desc = dropout rate: a fraction of previous trees to drop during the dropout
Guolin Ke's avatar
Guolin Ke committed
358
359
  double drop_rate = 0.1;

360
  // desc = used only in ``dart``
361
  // desc = max number of dropped trees during one boosting iteration
362
  // desc = ``<=0`` means no limit
Guolin Ke's avatar
Guolin Ke committed
363
364
  int max_drop = 50;

365
366
367
  // check = >=0.0
  // check = <=1.0
  // desc = used only in ``dart``
368
  // desc = probability of skipping the dropout procedure during a boosting iteration
Guolin Ke's avatar
Guolin Ke committed
369
370
  double skip_drop = 0.5;

371
372
  // desc = used only in ``dart``
  // desc = set this to ``true``, if you want to use xgboost dart mode
Guolin Ke's avatar
Guolin Ke committed
373
374
  bool xgboost_dart_mode = false;

375
376
  // desc = used only in ``dart``
  // desc = set this to ``true``, if you want to use uniform drop
Guolin Ke's avatar
Guolin Ke committed
377
378
  bool uniform_drop = false;

379
380
  // desc = used only in ``dart``
  // desc = random seed to choose dropping models
Guolin Ke's avatar
Guolin Ke committed
381
382
  int drop_seed = 4;

383
384
385
386
  // check = >=0.0
  // check = <=1.0
  // desc = used only in ``goss``
  // desc = the retain ratio of large gradient data
Guolin Ke's avatar
Guolin Ke committed
387
388
  double top_rate = 0.2;

389
390
391
392
  // check = >=0.0
  // check = <=1.0
  // desc = used only in ``goss``
  // desc = the retain ratio of small gradient data
Guolin Ke's avatar
Guolin Ke committed
393
394
  double other_rate = 0.1;

395
396
  // check = >0
  // desc = minimal number of data per categorical group
Guolin Ke's avatar
Guolin Ke committed
397
398
  int min_data_per_group = 100;

399
400
401
  // check = >0
  // desc = used for the categorical features
  // desc = limit the max threshold points in categorical features
Guolin Ke's avatar
Guolin Ke committed
402
403
  int max_cat_threshold = 32;

404
405
  // check = >=0.0
  // desc = used for the categorical features
406
  // desc = L2 regularization in categorical split
407
  double cat_l2 = 10.0;
Guolin Ke's avatar
Guolin Ke committed
408

409
410
411
412
  // check = >=0.0
  // desc = used for the categorical features
  // desc = this can reduce the effect of noises in categorical features, especially for categories with few data
  double cat_smooth = 10.0;
413

414
415
  // check = >0
  // desc = when number of categories of one feature smaller than or equal to ``max_cat_to_onehot``, one-vs-other split algorithm will be used
Guolin Ke's avatar
Guolin Ke committed
416
417
418
  int max_cat_to_onehot = 4;

  // alias = topk
419
  // check = >0
420
  // desc = used only in ``voting`` tree learner, refer to `Voting parallel <./Parallel-Learning-Guide.rst#choose-appropriate-parallel-algorithm>`__
421
  // desc = set this to larger value for more accurate result, but it will slow down the training speed
Guolin Ke's avatar
Guolin Ke committed
422
423
424
  int top_k = 20;

  // type = multi-int
425
426
427
428
429
  // alias = mc, monotone_constraint
  // default = None
  // desc = used for constraints of monotonic features
  // desc = ``1`` means increasing, ``-1`` means decreasing, ``0`` means non-constraint
  // desc = you need to specify all features in order. For example, ``mc=-1,0,1`` means decreasing for 1st feature, non-constraint for 2nd feature and increasing for the 3rd feature
Guolin Ke's avatar
Guolin Ke committed
430
  std::vector<int8_t> monotone_constraints;
Guolin Ke's avatar
Guolin Ke committed
431
432

  // type = multi-double
433
  // alias = feature_contrib, fc, fp, feature_penalty
Guolin Ke's avatar
Guolin Ke committed
434
435
436
437
  // default = None
  // desc = used to control feature's split gain, will use ``gain[i] = max(0, feature_contri[i]) * gain[i]`` to replace the split gain of i-th feature
  // desc = you need to specify all features in order
  std::vector<double> feature_contri;
438

439
440
441
442
  // alias = fs, forced_splits_filename, forced_splits_file, forced_splits
  // desc = path to a ``.json`` file that specifies splits to force at the top of every decision tree before best-first learning commences
  // desc = ``.json`` file can be arbitrarily nested, and each split contains ``feature``, ``threshold`` fields, as well as ``left`` and ``right`` fields representing subsplits
  // desc = categorical splits are forced in a one-hot fashion, with ``left`` representing the split containing the feature value and ``right`` representing other values
443
  // desc = **Note**: the forced split logic will be ignored, if the split makes gain worse
444
  // desc = see `this file <https://github.com/microsoft/LightGBM/tree/master/examples/binary_classification/forced_splits.json>`__ as an example
Guolin Ke's avatar
Guolin Ke committed
445
446
  std::string forcedsplits_filename = "";

447
448
449
450
451
  // desc = path to a ``.json`` file that specifies bin upper bounds for some or all features
  // desc = ``.json`` file should contain an array of objects, each containing the word ``feature`` (integer feature index) and ``bin_upper_bound`` (array of thresholds for binning)
  // desc = see `this file <https://github.com/microsoft/LightGBM/tree/master/examples/regression/forced_bins.json>`__ as an example
  std::string forcedbins_filename = "";

Guolin Ke's avatar
Guolin Ke committed
452
453
454
455
456
457
  // check = >=0.0
  // check = <=1.0
  // desc = decay rate of ``refit`` task, will use ``leaf_output = refit_decay_rate * old_leaf_output + (1.0 - refit_decay_rate) * new_leaf_output`` to refit trees
  // desc = used only in ``refit`` task in CLI version or as argument in ``refit`` function in language-specific package
  double refit_decay_rate = 0.9;

458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
  // check = >=0.0
  // desc = cost-effective gradient boosting multiplier for all penalties
  double cegb_tradeoff = 1.0;

  // check = >=0.0
  // desc = cost-effective gradient-boosting penalty for splitting a node
  double cegb_penalty_split = 0.0;

  // type = multi-double
  // default = 0,0,...,0
  // desc = cost-effective gradient boosting penalty for using a feature
  // desc = applied per data point
  std::vector<double> cegb_penalty_feature_lazy;

  // type = multi-double
  // default = 0,0,...,0
  // desc = cost-effective gradient boosting penalty for using a feature
  // desc = applied once per forest
476
  std::vector<double> cegb_penalty_feature_coupled;
477

Guolin Ke's avatar
Guolin Ke committed
478
479
480
481
  #pragma endregion

  #pragma region IO Parameters

482
483
  // alias = verbose
  // desc = controls the level of LightGBM's verbosity
484
  // desc = ``< 0``: Fatal, ``= 0``: Error (Warning), ``= 1``: Info, ``> 1``: Debug
485
486
487
488
489
490
  int verbosity = 1;

  // check = >1
  // desc = max number of bins that feature values will be bucketed in
  // desc = small number of bins may reduce training accuracy but may increase general power (deal with over-fitting)
  // desc = LightGBM will auto compress memory according to ``max_bin``. For example, LightGBM will use ``uint8_t`` for feature value if ``max_bin=255``
491
  int max_bin = 255;
Guolin Ke's avatar
Guolin Ke committed
492

Guolin Ke's avatar
Guolin Ke committed
493
494
495
496
497

  // alias = is_sparse, enable_sparse, sparse
  // desc = used to enable/disable sparse optimization
  bool is_enable_sparse = true;

Belinda Trotta's avatar
Belinda Trotta committed
498
499
500
501
  // type = multi-int
  // default = None
  // desc = max number of bins for each feature
  // desc = if not specified, will use ``max_bin`` for all features
502
  std::vector<int32_t> max_bin_by_feature;
Belinda Trotta's avatar
Belinda Trotta committed
503

504
505
506
  // check = >0
  // desc = minimal number of data inside one bin
  // desc = use this to avoid one-data-one-bin (potential over-fitting)
Guolin Ke's avatar
Guolin Ke committed
507
508
  int min_data_in_bin = 3;

509
510
511
512
513
514
515
  // alias = subsample_for_bin
  // check = >0
  // desc = number of data that sampled to construct histogram bins
  // desc = setting this to larger value will give better training result, but will increase data loading time
  // desc = set this to larger value if data is very sparse
  int bin_construct_sample_cnt = 200000;

516
  // alias = hist_pool_size
517
518
519
520
  // desc = max cache size in MB for historical histogram
  // desc = ``< 0`` means no limit
  double histogram_pool_size = -1.0;

521
  // alias = data_seed
522
  // desc = random seed for data partition in parallel learning (excluding the ``feature_parallel`` mode)
Guolin Ke's avatar
Guolin Ke committed
523
  int data_random_seed = 1;
Guolin Ke's avatar
Guolin Ke committed
524

525
526
  // alias = model_output, model_out
  // desc = filename of output model in training
527
  // desc = **Note**: can be used only in CLI version
Guolin Ke's avatar
Guolin Ke committed
528
  std::string output_model = "LightGBM_model.txt";
Guolin Ke's avatar
Guolin Ke committed
529

530
  // alias = save_period
531
532
  // desc = frequency of saving model file snapshot
  // desc = set this to positive value to enable this function. For example, the model file will be snapshotted at each iteration if ``snapshot_freq=1``
533
  // desc = **Note**: can be used only in CLI version
534
535
  int snapshot_freq = -1;

Guolin Ke's avatar
Guolin Ke committed
536
  // alias = model_input, model_in
537
538
539
540
  // desc = filename of input model
  // desc = for ``prediction`` task, this model will be applied to prediction data
  // desc = for ``train`` task, training will be continued from this model
  // desc = **Note**: can be used only in CLI version
Guolin Ke's avatar
Guolin Ke committed
541
  std::string input_model = "";
542

543
  // alias = predict_result, prediction_result, predict_name, prediction_name, pred_name, name_pred
544
  // desc = filename of prediction result in ``prediction`` task
545
  // desc = **Note**: can be used only in CLI version
Guolin Ke's avatar
Guolin Ke committed
546
547
  std::string output_result = "LightGBM_predict_result.txt";

548
  // alias = init_score_filename, init_score_file, init_score, input_init_score
549
  // desc = path of file with training initial scores
550
  // desc = if ``""``, will use ``train_data_file`` + ``.init`` (if exists)
551
  // desc = **Note**: works only in case of loading data directly from file
552
553
554
555
  std::string initscore_filename = "";

  // alias = valid_data_init_scores, valid_init_score_file, valid_init_score
  // default = ""
556
  // desc = path(s) of file(s) with validation initial scores
557
558
  // desc = if ``""``, will use ``valid_data_file`` + ``.init`` (if exists)
  // desc = separate by ``,`` for multi-validation data
559
  // desc = **Note**: works only in case of loading data directly from file
560
561
  std::vector<std::string> valid_data_initscores;

Guolin Ke's avatar
Guolin Ke committed
562
  // alias = is_pre_partition
563
564
  // desc = used for parallel learning (excluding the ``feature_parallel`` mode)
  // desc = ``true`` if training data are pre-partitioned, and different machines use different partitions
Guolin Ke's avatar
Guolin Ke committed
565
566
  bool pre_partition = false;

567
568
569
570
571
572
573
574
  // alias = is_enable_bundle, bundle
  // desc = set this to ``false`` to disable Exclusive Feature Bundling (EFB), which is described in `LightGBM: A Highly Efficient Gradient Boosting Decision Tree <https://papers.nips.cc/paper/6907-lightgbm-a-highly-efficient-gradient-boosting-decision-tree>`__
  // desc = **Note**: disabling this may cause the slow training speed for sparse datasets
  bool enable_bundle = true;

  // desc = set this to ``false`` to disable the special handle of missing value
  bool use_missing = true;

575
  // desc = set this to ``true`` to treat all zero as missing values (including the unshown values in LibSVM / sparse matrices)
576
577
578
579
580
581
  // desc = set this to ``false`` to use ``na`` for representing missing values
  bool zero_as_missing = false;

  // alias = two_round_loading, use_two_round_loading
  // desc = set this to ``true`` if data file is too big to fit in memory
  // desc = by default, LightGBM will map data file to memory and load features from memory. This will provide faster data loading speed, but may cause run out of memory error when the data file is very big
582
  // desc = **Note**: works only in case of loading data directly from file
Guolin Ke's avatar
Guolin Ke committed
583
584
585
  bool two_round = false;

  // alias = is_save_binary, is_save_binary_file
586
  // desc = if ``true``, LightGBM will save the dataset (including validation data) to a binary file. This speed ups the data loading for the next time
587
  // desc = **Note**: ``init_score`` is not saved in binary file
588
  // desc = **Note**: can be used only in CLI version; for language-specific packages you can use the correspondent function
Guolin Ke's avatar
Guolin Ke committed
589
590
591
  bool save_binary = false;

  // alias = has_header
592
  // desc = set this to ``true`` if input data has header
593
  // desc = **Note**: works only in case of loading data directly from file
Guolin Ke's avatar
Guolin Ke committed
594
595
  bool header = false;

596
597
598
599
600
  // type = int or string
  // alias = label
  // desc = used to specify the label column
  // desc = use number for index, e.g. ``label=0`` means column\_0 is the label
  // desc = add a prefix ``name:`` for column name, e.g. ``label=name:is_click``
601
  // desc = **Note**: works only in case of loading data directly from file
Guolin Ke's avatar
Guolin Ke committed
602
  std::string label_column = "";
Guolin Ke's avatar
Guolin Ke committed
603

604
605
606
607
608
  // type = int or string
  // alias = weight
  // desc = used to specify the weight column
  // desc = use number for index, e.g. ``weight=0`` means column\_0 is the weight
  // desc = add a prefix ``name:`` for column name, e.g. ``weight=name:weight``
609
  // desc = **Note**: works only in case of loading data directly from file
610
  // desc = **Note**: index starts from ``0`` and it doesn't count the label column when passing type is ``int``, e.g. when label is column\_0, and weight is column\_1, the correct parameter is ``weight=0``
Guolin Ke's avatar
Guolin Ke committed
611
  std::string weight_column = "";
Guolin Ke's avatar
Guolin Ke committed
612

613
614
615
616
617
  // type = int or string
  // alias = group, group_id, query_column, query, query_id
  // desc = used to specify the query/group id column
  // desc = use number for index, e.g. ``query=0`` means column\_0 is the query id
  // desc = add a prefix ``name:`` for column name, e.g. ``query=name:query_id``
618
  // desc = **Note**: works only in case of loading data directly from file
619
620
  // desc = **Note**: data should be grouped by query\_id
  // desc = **Note**: index starts from ``0`` and it doesn't count the label column when passing type is ``int``, e.g. when label is column\_0 and query\_id is column\_1, the correct parameter is ``query=0``
Guolin Ke's avatar
Guolin Ke committed
621
  std::string group_column = "";
Guolin Ke's avatar
Guolin Ke committed
622

623
  // type = multi-int or string
Guolin Ke's avatar
Guolin Ke committed
624
  // alias = ignore_feature, blacklist
625
626
627
628
629
  // desc = used to specify some ignoring columns in training
  // desc = use number for index, e.g. ``ignore_column=0,1,2`` means column\_0, column\_1 and column\_2 will be ignored
  // desc = add a prefix ``name:`` for column name, e.g. ``ignore_column=name:c1,c2,c3`` means c1, c2 and c3 will be ignored
  // desc = **Note**: works only in case of loading data directly from file
  // desc = **Note**: index starts from ``0`` and it doesn't count the label column when passing type is ``int``
630
  // desc = **Note**: despite the fact that specified columns will be completely ignored during the training, they still should have a valid format allowing LightGBM to load file successfully
Guolin Ke's avatar
Guolin Ke committed
631
  std::string ignore_column = "";
632

633
634
635
636
637
  // type = multi-int or string
  // alias = cat_feature, categorical_column, cat_column
  // desc = used to specify categorical features
  // desc = use number for index, e.g. ``categorical_feature=0,1,2`` means column\_0, column\_1 and column\_2 are categorical features
  // desc = add a prefix ``name:`` for column name, e.g. ``categorical_feature=name:c1,c2,c3`` means c1, c2 and c3 are categorical features
638
  // desc = **Note**: only supports categorical with ``int`` type (not applicable for data represented as pandas DataFrame in Python-package)
639
640
  // desc = **Note**: index starts from ``0`` and it doesn't count the label column when passing type is ``int``
  // desc = **Note**: all values should be less than ``Int32.MaxValue`` (2147483647)
641
  // desc = **Note**: using large values could be memory consuming. Tree decision rule works best when categorical features are presented by consecutive integers starting from zero
642
  // desc = **Note**: all negative values will be treated as **missing values**
643
  // desc = **Note**: the output cannot be monotonically constrained with respect to a categorical feature
Guolin Ke's avatar
Guolin Ke committed
644
645
  std::string categorical_feature = "";

646
647
648
649
  // alias = is_predict_raw_score, predict_rawscore, raw_score
  // desc = used only in ``prediction`` task
  // desc = set this to ``true`` to predict only the raw scores
  // desc = set this to ``false`` to predict transformed scores
Guolin Ke's avatar
Guolin Ke committed
650
651
  bool predict_raw_score = false;

652
653
654
  // alias = is_predict_leaf_index, leaf_index
  // desc = used only in ``prediction`` task
  // desc = set this to ``true`` to predict with leaf index of all trees
Guolin Ke's avatar
Guolin Ke committed
655
656
  bool predict_leaf_index = false;

657
658
  // alias = is_predict_contrib, contrib
  // desc = used only in ``prediction`` task
659
  // desc = set this to ``true`` to estimate `SHAP values <https://arxiv.org/abs/1706.06060>`__, which represent how each feature contributes to each prediction
660
  // desc = produces ``#features + 1`` values where the last value is the expected value of the model output over the training data
661
  // desc = **Note**: if you want to get more explanation for your model's predictions using SHAP values like SHAP interaction values, you can install `shap package <https://github.com/slundberg/shap>`__
Nikita Titov's avatar
Nikita Titov committed
662
  // desc = **Note**: unlike the shap package, with ``predict_contrib`` we return a matrix with an extra column, where the last column is the expected value
Guolin Ke's avatar
Guolin Ke committed
663
664
  bool predict_contrib = false;

665
666
667
  // desc = used only in ``prediction`` task
  // desc = used to specify how many trained iterations will be used in prediction
  // desc = ``<= 0`` means no limit
Guolin Ke's avatar
Guolin Ke committed
668
669
  int num_iteration_predict = -1;

670
671
  // desc = used only in ``prediction`` task
  // desc = if ``true``, will use early-stopping to speed up the prediction. May affect the accuracy
672
  bool pred_early_stop = false;
673
674
675

  // desc = used only in ``prediction`` task
  // desc = the frequency of checking early-stopping prediction
676
  int pred_early_stop_freq = 10;
Guolin Ke's avatar
Guolin Ke committed
677

678
679
  // desc = used only in ``prediction`` task
  // desc = the threshold of margin in early-stopping prediction
Guolin Ke's avatar
Guolin Ke committed
680
  double pred_early_stop_margin = 10.0;
Guolin Ke's avatar
Guolin Ke committed
681

682
683
684
685
686
687
688
  // desc = used only in ``prediction`` task
  // desc = control whether or not LightGBM raises an error when you try to predict on data with a different number of features than the training data
  // desc = if ``false`` (the default), a fatal error will be raised if the number of features in the dataset you predict on differs from the number seen during training
  // desc = if ``true``, LightGBM will attempt to predict on whatever data you provide. This is dangerous because you might get incorrect predictions, but you could use it in situations where it is difficult or expensive to generate some features and you are very confident that they were never chosen for splits in the model
  // desc = **Note**: be very careful setting this parameter to ``true``
  bool predict_disable_shape_check = false;

689
  // desc = used only in ``convert_model`` task
690
  // desc = only ``cpp`` is supported yet; for conversion model to other languages consider using `m2cgen <https://github.com/BayesWitnesses/m2cgen>`__ utility
691
  // desc = if ``convert_model_language`` is set and ``task=train``, the model will be also converted
692
  // desc = **Note**: can be used only in CLI version
Guolin Ke's avatar
Guolin Ke committed
693
694
  std::string convert_model_language = "";

695
696
697
  // alias = convert_model_file
  // desc = used only in ``convert_model`` task
  // desc = output filename of converted model
698
  // desc = **Note**: can be used only in CLI version
Guolin Ke's avatar
Guolin Ke committed
699
700
  std::string convert_model = "gbdt_prediction.cpp";

701
  #pragma endregion
Guolin Ke's avatar
Guolin Ke committed
702
703
704

  #pragma region Objective Parameters

705
706
707
708
  // check = >0
  // alias = num_classes
  // desc = used only in ``multi-class`` classification application
  int num_class = 1;
Guolin Ke's avatar
Guolin Ke committed
709

710
  // alias = unbalance, unbalanced_sets
711
  // desc = used only in ``binary`` and ``multiclassova`` applications
712
  // desc = set this to ``true`` if training data are unbalanced
713
  // desc = **Note**: while enabling this should increase the overall performance metric of your model, it will also result in poor estimates of the individual class probabilities
714
715
  // desc = **Note**: this parameter cannot be used at the same time with ``scale_pos_weight``, choose only **one** of them
  bool is_unbalance = false;
Guolin Ke's avatar
Guolin Ke committed
716

717
  // check = >0.0
718
  // desc = used only in ``binary`` and ``multiclassova`` applications
719
  // desc = weight of labels with positive class
720
  // desc = **Note**: while enabling this should increase the overall performance metric of your model, it will also result in poor estimates of the individual class probabilities
721
722
  // desc = **Note**: this parameter cannot be used at the same time with ``is_unbalance``, choose only **one** of them
  double scale_pos_weight = 1.0;
Guolin Ke's avatar
Guolin Ke committed
723

724
725
726
727
  // check = >0.0
  // desc = used only in ``binary`` and ``multiclassova`` classification and in ``lambdarank`` applications
  // desc = parameter for the sigmoid function
  double sigmoid = 1.0;
Guolin Ke's avatar
Guolin Ke committed
728

729
  // desc = used only in ``regression``, ``binary``, ``multiclassova`` and ``cross-entropy`` applications
730
  // desc = adjusts initial score to the mean of labels for faster convergence
Guolin Ke's avatar
Guolin Ke committed
731
732
  bool boost_from_average = true;

733
734
735
736
  // desc = used only in ``regression`` application
  // desc = used to fit ``sqrt(label)`` instead of original values and prediction result will be also automatically converted to ``prediction^2``
  // desc = might be useful in case of large-range labels
  bool reg_sqrt = false;
Guolin Ke's avatar
Guolin Ke committed
737

738
739
740
741
  // check = >0.0
  // desc = used only in ``huber`` and ``quantile`` ``regression`` applications
  // desc = parameter for `Huber loss <https://en.wikipedia.org/wiki/Huber_loss>`__ and `Quantile regression <https://en.wikipedia.org/wiki/Quantile_regression>`__
  double alpha = 0.9;
Guolin Ke's avatar
Guolin Ke committed
742

743
744
745
746
  // check = >0.0
  // desc = used only in ``fair`` ``regression`` application
  // desc = parameter for `Fair loss <https://www.kaggle.com/c/allstate-claims-severity/discussion/24520>`__
  double fair_c = 1.0;
Guolin Ke's avatar
Guolin Ke committed
747

748
749
750
751
  // check = >0.0
  // desc = used only in ``poisson`` ``regression`` application
  // desc = parameter for `Poisson regression <https://en.wikipedia.org/wiki/Poisson_regression>`__ to safeguard optimization
  double poisson_max_delta_step = 0.7;
Guolin Ke's avatar
Guolin Ke committed
752

753
754
755
756
757
758
759
  // check = >=1.0
  // check = <2.0
  // desc = used only in ``tweedie`` ``regression`` application
  // desc = used to control the variance of the tweedie distribution
  // desc = set this closer to ``2`` to shift towards a **Gamma** distribution
  // desc = set this closer to ``1`` to shift towards a **Poisson** distribution
  double tweedie_variance_power = 1.5;
Guolin Ke's avatar
Guolin Ke committed
760

761
762
763
  // check = >0
  // desc = used only in ``lambdarank`` application
  // desc = optimizes `NDCG <https://en.wikipedia.org/wiki/Discounted_cumulative_gain#Normalized_DCG>`__ at this position
Guolin Ke's avatar
Guolin Ke committed
764
  int max_position = 20;
Guolin Ke's avatar
Guolin Ke committed
765

766
767
768
769
770
  // desc = used only in ``lambdarank`` application
  // desc = set this to ``true`` to normalize the lambdas for different queries, and improve the performance for unbalanced data
  // desc = set this to ``false`` to enforce the original lambdamart algorithm
  bool lambdamart_norm = true;

771
772
773
774
775
776
777
  // type = multi-double
  // default = 0,1,3,7,15,31,63,...,2^30-1
  // desc = used only in ``lambdarank`` application
  // desc = relevant gain for labels. For example, the gain of label ``2`` is ``3`` in case of default label gains
  // desc = separate by ``,``
  std::vector<double> label_gain;

778
  // desc = used only in the ``rank_xendcg`` objective
779
  // desc = random seed for objectives
780
781
  int objective_seed = 5;

Guolin Ke's avatar
Guolin Ke committed
782
783
784
  #pragma endregion

  #pragma region Metric Parameters
785

Guolin Ke's avatar
Guolin Ke committed
786
  // [doc-only]
787
788
789
  // alias = metrics, metric_types
  // default = ""
  // type = multi-enum
790
  // desc = metric(s) to be evaluated on the evaluation set(s)
791
  // descl2 = ``""`` (empty string or not specified) means that metric corresponding to specified ``objective`` will be used (this is possible only for pre-defined objective functions, otherwise no evaluation metric will be added)
792
  // descl2 = ``"None"`` (string, **not** a ``None`` value) means that no metric will be registered, aliases: ``na``, ``null``, ``custom``
793
794
  // descl2 = ``l1``, absolute loss, aliases: ``mean_absolute_error``, ``mae``, ``regression_l1``
  // descl2 = ``l2``, square loss, aliases: ``mean_squared_error``, ``mse``, ``regression_l2``, ``regression``
795
  // descl2 = ``rmse``, root square loss, aliases: ``root_mean_squared_error``, ``l2_root``
796
797
798
799
800
801
802
803
  // descl2 = ``quantile``, `Quantile regression <https://en.wikipedia.org/wiki/Quantile_regression>`__
  // descl2 = ``mape``, `MAPE loss <https://en.wikipedia.org/wiki/Mean_absolute_percentage_error>`__, aliases: ``mean_absolute_percentage_error``
  // descl2 = ``huber``, `Huber loss <https://en.wikipedia.org/wiki/Huber_loss>`__
  // descl2 = ``fair``, `Fair loss <https://www.kaggle.com/c/allstate-claims-severity/discussion/24520>`__
  // descl2 = ``poisson``, negative log-likelihood for `Poisson regression <https://en.wikipedia.org/wiki/Poisson_regression>`__
  // descl2 = ``gamma``, negative log-likelihood for **Gamma** regression
  // descl2 = ``gamma_deviance``, residual deviance for **Gamma** regression
  // descl2 = ``tweedie``, negative log-likelihood for **Tweedie** regression
804
  // descl2 = ``ndcg``, `NDCG <https://en.wikipedia.org/wiki/Discounted_cumulative_gain#Normalized_DCG>`__, aliases: ``lambdarank``, ``rank_xendcg``, ``xendcg``, ``xe_ndcg``, ``xe_ndcg_mart``, ``xendcg_mart``
805
806
807
808
  // descl2 = ``map``, `MAP <https://makarandtapaswi.wordpress.com/2012/07/02/intuition-behind-average-precision-and-map/>`__, aliases: ``mean_average_precision``
  // descl2 = ``auc``, `AUC <https://en.wikipedia.org/wiki/Receiver_operating_characteristic#Area_under_the_curve>`__
  // descl2 = ``binary_logloss``, `log loss <https://en.wikipedia.org/wiki/Cross_entropy>`__, aliases: ``binary``
  // descl2 = ``binary_error``, for one sample: ``0`` for correct classification, ``1`` for error classification
Belinda Trotta's avatar
Belinda Trotta committed
809
  // descl2 = ``auc_mu``, `AUC-mu <http://proceedings.mlr.press/v97/kleiman19a/kleiman19a.pdf>`__
810
811
  // descl2 = ``multi_logloss``, log loss for multi-class classification, aliases: ``multiclass``, ``softmax``, ``multiclassova``, ``multiclass_ova``, ``ova``, ``ovr``
  // descl2 = ``multi_error``, error rate for multi-class classification
Guolin Ke's avatar
Guolin Ke committed
812
813
814
  // descl2 = ``cross_entropy``, cross-entropy (with optional linear weights), aliases: ``xentropy``
  // descl2 = ``cross_entropy_lambda``, "intensity-weighted" cross-entropy, aliases: ``xentlambda``
  // descl2 = ``kullback_leibler``, `Kullback-Leibler divergence <https://en.wikipedia.org/wiki/Kullback%E2%80%93Leibler_divergence>`__, aliases: ``kldiv``
815
  // desc = support multiple metrics, separated by ``,``
Guolin Ke's avatar
Guolin Ke committed
816
817
  std::vector<std::string> metric;

818
  // check = >0
Guolin Ke's avatar
Guolin Ke committed
819
820
821
822
  // alias = output_freq
  // desc = frequency for metric output
  int metric_freq = 1;

823
824
  // alias = training_metric, is_training_metric, train_metric
  // desc = set this to ``true`` to output metric result over training dataset
825
  // desc = **Note**: can be used only in CLI version
826
  bool is_provide_training_metric = false;
827

828
829
  // type = multi-int
  // default = 1,2,3,4,5
830
  // alias = ndcg_eval_at, ndcg_at, map_eval_at, map_at
831
  // desc = used only with ``ndcg`` and ``map`` metrics
832
  // desc = `NDCG <https://en.wikipedia.org/wiki/Discounted_cumulative_gain#Normalized_DCG>`__ and `MAP <https://makarandtapaswi.wordpress.com/2012/07/02/intuition-behind-average-precision-and-map/>`__ evaluation positions, separated by ``,``
Guolin Ke's avatar
Guolin Ke committed
833
  std::vector<int> eval_at;
Guolin Ke's avatar
Guolin Ke committed
834

Belinda Trotta's avatar
Belinda Trotta committed
835
836
837
838
839
840
841
842
  // check = >0
  // desc = used only with ``multi_error`` metric
  // desc = threshold for top-k multi-error metric
  // desc = the error on each sample is ``0`` if the true class is among the top ``multi_error_top_k`` predictions, and ``1`` otherwise
  // descl2 = more precisely, the error on a sample is ``0`` if there are at least ``num_classes - multi_error_top_k`` predictions strictly less than the prediction on the true class
  // desc = when ``multi_error_top_k=1`` this is equivalent to the usual multi-error metric
  int multi_error_top_k = 1;

Belinda Trotta's avatar
Belinda Trotta committed
843
844
845
846
847
848
849
850
851
  // type = multi-double
  // default = None
  // desc = used only with ``auc_mu`` metric
  // desc = list representing flattened matrix (in row-major order) giving loss weights for classification errors
  // desc = list should have ``n * n`` elements, where ``n`` is the number of classes
  // desc = the matrix co-ordinate ``[i, j]`` should correspond to the ``i * n + j``-th element of the list
  // desc = if not specified, will use equal weights for all classes
  std::vector<double> auc_mu_weights;

Guolin Ke's avatar
Guolin Ke committed
852
853
854
855
  #pragma endregion

  #pragma region Network Parameters

856
857
858
859
  // check = >0
  // alias = num_machine
  // desc = the number of machines for parallel learning application
  // desc = this parameter is needed to be set in both **socket** and **mpi** versions
Guolin Ke's avatar
Guolin Ke committed
860
  int num_machines = 1;
Guolin Ke's avatar
Guolin Ke committed
861

862
863
864
865
  // check = >0
  // alias = local_port, port
  // desc = TCP listen port for local machines
  // desc = **Note**: don't forget to allow this port in firewall settings before training
Guolin Ke's avatar
Guolin Ke committed
866
  int local_listen_port = 12400;
Guolin Ke's avatar
Guolin Ke committed
867

868
869
870
  // check = >0
  // desc = socket time-out in minutes
  int time_out = 120;
Guolin Ke's avatar
Guolin Ke committed
871

872
873
874
  // alias = machine_list_file, machine_list, mlist
  // desc = path of file that lists machines for this parallel learning application
  // desc = each line contains one IP and one port for one machine. The format is ``ip port`` (space as a separator)
Guolin Ke's avatar
Guolin Ke committed
875
  std::string machine_list_filename = "";
Guolin Ke's avatar
Guolin Ke committed
876

877
878
  // alias = workers, nodes
  // desc = list of machines in the following format: ``ip1:port1,ip2:port2``
879
  std::string machines = "";
Guolin Ke's avatar
Guolin Ke committed
880

Guolin Ke's avatar
Guolin Ke committed
881
882
883
884
  #pragma endregion

  #pragma region GPU Parameters

885
886
  // desc = OpenCL platform ID. Usually each GPU vendor exposes one OpenCL platform
  // desc = ``-1`` means the system-wide default platform
887
  // desc = **Note**: refer to `GPU Targets <./GPU-Targets.rst#query-opencl-devices-in-your-system>`__ for more details
Guolin Ke's avatar
Guolin Ke committed
888
889
  int gpu_platform_id = -1;

890
891
  // desc = OpenCL device ID in the specified platform. Each GPU in the selected platform has a unique device ID
  // desc = ``-1`` means the default device in the selected platform
892
  // desc = **Note**: refer to `GPU Targets <./GPU-Targets.rst#query-opencl-devices-in-your-system>`__ for more details
Guolin Ke's avatar
Guolin Ke committed
893
894
  int gpu_device_id = -1;

895
  // desc = set this to ``true`` to use double precision math on GPU (by default single precision is used)
Guolin Ke's avatar
Guolin Ke committed
896
897
898
899
900
  bool gpu_use_dp = false;

  #pragma endregion

  #pragma endregion
Guolin Ke's avatar
Guolin Ke committed
901

902
903
  size_t file_load_progress_interval_bytes = size_t(10) * 1024 * 1024 * 1024;

Guolin Ke's avatar
Guolin Ke committed
904
905
  bool is_parallel = false;
  bool is_parallel_find_bin = false;
Guolin Ke's avatar
Guolin Ke committed
906
  LIGHTGBM_EXPORT void Set(const std::unordered_map<std::string, std::string>& params);
jcipar's avatar
jcipar committed
907
908
  static const std::unordered_map<std::string, std::string>& alias_table();
  static const std::unordered_set<std::string>& parameter_set();
Belinda Trotta's avatar
Belinda Trotta committed
909
  std::vector<std::vector<double>> auc_mu_weights_matrix;
910

Nikita Titov's avatar
Nikita Titov committed
911
 private:
Guolin Ke's avatar
Guolin Ke committed
912
  void CheckParamConflict();
Guolin Ke's avatar
Guolin Ke committed
913
914
  void GetMembersFromString(const std::unordered_map<std::string, std::string>& params);
  std::string SaveMembersToString() const;
Belinda Trotta's avatar
Belinda Trotta committed
915
  void GetAucMuWeights();
Guolin Ke's avatar
Guolin Ke committed
916
917
};

Guolin Ke's avatar
Guolin Ke committed
918
inline bool Config::GetString(
Guolin Ke's avatar
Guolin Ke committed
919
920
  const std::unordered_map<std::string, std::string>& params,
  const std::string& name, std::string* out) {
921
  if (params.count(name) > 0 && !params.at(name).empty()) {
Guolin Ke's avatar
Guolin Ke committed
922
923
924
925
926
927
    *out = params.at(name);
    return true;
  }
  return false;
}

Guolin Ke's avatar
Guolin Ke committed
928
inline bool Config::GetInt(
Guolin Ke's avatar
Guolin Ke committed
929
930
  const std::unordered_map<std::string, std::string>& params,
  const std::string& name, int* out) {
931
  if (params.count(name) > 0 && !params.at(name).empty()) {
932
    if (!Common::AtoiAndCheck(params.at(name).c_str(), out)) {
933
      Log::Fatal("Parameter %s should be of type int, got \"%s\"",
Guolin Ke's avatar
Guolin Ke committed
934
                 name.c_str(), params.at(name).c_str());
935
    }
Guolin Ke's avatar
Guolin Ke committed
936
937
938
939
940
    return true;
  }
  return false;
}

Guolin Ke's avatar
Guolin Ke committed
941
inline bool Config::GetDouble(
Guolin Ke's avatar
Guolin Ke committed
942
  const std::unordered_map<std::string, std::string>& params,
943
  const std::string& name, double* out) {
944
  if (params.count(name) > 0 && !params.at(name).empty()) {
945
    if (!Common::AtofAndCheck(params.at(name).c_str(), out)) {
946
      Log::Fatal("Parameter %s should be of type double, got \"%s\"",
Guolin Ke's avatar
Guolin Ke committed
947
                 name.c_str(), params.at(name).c_str());
948
    }
Guolin Ke's avatar
Guolin Ke committed
949
950
951
952
953
    return true;
  }
  return false;
}

Guolin Ke's avatar
Guolin Ke committed
954
inline bool Config::GetBool(
Guolin Ke's avatar
Guolin Ke committed
955
956
  const std::unordered_map<std::string, std::string>& params,
  const std::string& name, bool* out) {
957
  if (params.count(name) > 0 && !params.at(name).empty()) {
Guolin Ke's avatar
Guolin Ke committed
958
    std::string value = params.at(name);
Guolin Ke's avatar
Guolin Ke committed
959
    std::transform(value.begin(), value.end(), value.begin(), Common::tolower);
960
    if (value == std::string("false") || value == std::string("-")) {
Guolin Ke's avatar
Guolin Ke committed
961
      *out = false;
962
    } else if (value == std::string("true") || value == std::string("+")) {
Guolin Ke's avatar
Guolin Ke committed
963
      *out = true;
964
    } else {
965
      Log::Fatal("Parameter %s should be \"true\"/\"+\" or \"false\"/\"-\", got \"%s\"",
Guolin Ke's avatar
Guolin Ke committed
966
                 name.c_str(), params.at(name).c_str());
Guolin Ke's avatar
Guolin Ke committed
967
968
969
970
971
972
973
974
975
976
    }
    return true;
  }
  return false;
}

struct ParameterAlias {
  static void KeyAliasTransform(std::unordered_map<std::string, std::string>* params) {
    std::unordered_map<std::string, std::string> tmp_map;
    for (const auto& pair : *params) {
jcipar's avatar
jcipar committed
977
978
      auto alias = Config::alias_table().find(pair.first);
      if (alias != Config::alias_table().end()) {  // found alias
Guolin Ke's avatar
Guolin Ke committed
979
        auto alias_set = tmp_map.find(alias->second);
980
981
        if (alias_set != tmp_map.end()) {  // alias already set
                                           // set priority by length & alphabetically to ensure reproducible behavior
wxchan's avatar
wxchan committed
982
983
          if (alias_set->second.size() < pair.first.size() ||
            (alias_set->second.size() == pair.first.size() && alias_set->second < pair.first)) {
984
            Log::Warning("%s is set with %s=%s, %s=%s will be ignored. Current value: %s=%s",
Guolin Ke's avatar
Guolin Ke committed
985
986
                         alias->second.c_str(), alias_set->second.c_str(), params->at(alias_set->second).c_str(),
                         pair.first.c_str(), pair.second.c_str(), alias->second.c_str(), params->at(alias_set->second).c_str());
wxchan's avatar
wxchan committed
987
          } else {
988
            Log::Warning("%s is set with %s=%s, will be overridden by %s=%s. Current value: %s=%s",
Guolin Ke's avatar
Guolin Ke committed
989
990
                         alias->second.c_str(), alias_set->second.c_str(), params->at(alias_set->second).c_str(),
                         pair.first.c_str(), pair.second.c_str(), alias->second.c_str(), pair.second.c_str());
wxchan's avatar
wxchan committed
991
992
            tmp_map[alias->second] = pair.first;
          }
993
        } else {  // alias not set
wxchan's avatar
wxchan committed
994
995
          tmp_map.emplace(alias->second, pair.first);
        }
jcipar's avatar
jcipar committed
996
      } else if (Config::parameter_set().find(pair.first) == Config::parameter_set().end()) {
wxchan's avatar
wxchan committed
997
        Log::Warning("Unknown parameter: %s", pair.first.c_str());
Guolin Ke's avatar
Guolin Ke committed
998
999
1000
      }
    }
    for (const auto& pair : tmp_map) {
wxchan's avatar
wxchan committed
1001
      auto alias = params->find(pair.first);
1002
      if (alias == params->end()) {  // not find
wxchan's avatar
wxchan committed
1003
1004
1005
        params->emplace(pair.first, params->at(pair.second));
        params->erase(pair.second);
      } else {
Guolin Ke's avatar
Guolin Ke committed
1006
1007
1008
        Log::Warning("%s is set=%s, %s=%s will be ignored. Current value: %s=%s",
                     pair.first.c_str(), alias->second.c_str(), pair.second.c_str(), params->at(pair.second).c_str(),
                     pair.first.c_str(), alias->second.c_str());
Guolin Ke's avatar
Guolin Ke committed
1009
1010
1011
1012
1013
      }
    }
  }
};

1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
inline std::string ParseObjectiveAlias(const std::string& type) {
  if (type == std::string("regression") || type == std::string("regression_l2")
    || type == std::string("mean_squared_error") || type == std::string("mse") || type == std::string("l2")
    || type == std::string("l2_root") || type == std::string("root_mean_squared_error") || type == std::string("rmse")) {
    return "regression";
  } else if (type == std::string("regression_l1") || type == std::string("mean_absolute_error")
    || type == std::string("l1") || type == std::string("mae")) {
    return "regression_l1";
  } else if (type == std::string("multiclass") || type == std::string("softmax")) {
    return "multiclass";
  } else if (type == std::string("multiclassova") || type == std::string("multiclass_ova") || type == std::string("ova") || type == std::string("ovr")) {
    return "multiclassova";
  } else if (type == std::string("xentropy") || type == std::string("cross_entropy")) {
    return "cross_entropy";
  } else if (type == std::string("xentlambda") || type == std::string("cross_entropy_lambda")) {
    return "cross_entropy_lambda";
  } else if (type == std::string("mean_absolute_percentage_error") || type == std::string("mape")) {
    return "mape";
1032
1033
1034
  } else if (type == std::string("rank_xendcg") || type == std::string("xendcg") || type == std::string("xe_ndcg")
             || type == std::string("xe_ndcg_mart") || type == std::string("xendcg_mart")) {
    return "rank_xendcg";
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
  } else if (type == std::string("none") || type == std::string("null") || type == std::string("custom") || type == std::string("na")) {
    return "custom";
  }
  return type;
}

inline std::string ParseMetricAlias(const std::string& type) {
  if (type == std::string("regression") || type == std::string("regression_l2") || type == std::string("l2") || type == std::string("mean_squared_error") || type == std::string("mse")) {
    return "l2";
  } else if (type == std::string("l2_root") || type == std::string("root_mean_squared_error") || type == std::string("rmse")) {
    return "rmse";
  } else if (type == std::string("regression_l1") || type == std::string("l1") || type == std::string("mean_absolute_error") || type == std::string("mae")) {
    return "l1";
  } else if (type == std::string("binary_logloss") || type == std::string("binary")) {
    return "binary_logloss";
1050
1051
  } else if (type == std::string("ndcg") || type == std::string("lambdarank") || type == std::string("rank_xendcg")
             || type == std::string("xendcg") || type == std::string("xe_ndcg") || type == std::string("xe_ndcg_mart") || type == std::string("xendcg_mart")) {
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
    return "ndcg";
  } else if (type == std::string("map") || type == std::string("mean_average_precision")) {
    return "map";
  } else if (type == std::string("multi_logloss") || type == std::string("multiclass") || type == std::string("softmax") || type == std::string("multiclassova") || type == std::string("multiclass_ova") || type == std::string("ova") || type == std::string("ovr")) {
    return "multi_logloss";
  } else if (type == std::string("xentropy") || type == std::string("cross_entropy")) {
    return "cross_entropy";
  } else if (type == std::string("xentlambda") || type == std::string("cross_entropy_lambda")) {
    return "cross_entropy_lambda";
  } else if (type == std::string("kldiv") || type == std::string("kullback_leibler")) {
    return "kullback_leibler";
  } else if (type == std::string("mean_absolute_percentage_error") || type == std::string("mape")) {
    return "mape";
Belinda Trotta's avatar
Belinda Trotta committed
1065
1066
  } else if (type == std::string("auc_mu")) {
    return "auc_mu";
1067
1068
1069
1070
1071
1072
  } else if (type == std::string("none") || type == std::string("null") || type == std::string("custom") || type == std::string("na")) {
    return "custom";
  }
  return type;
}

Guolin Ke's avatar
Guolin Ke committed
1073
1074
}   // namespace LightGBM

Belinda Trotta's avatar
Belinda Trotta committed
1075
#endif   // LightGBM_CONFIG_H_