config_auto.cpp 23.8 KB
Newer Older
1
2
3
4
5
6
7
/*!
 * Copyright (c) 2018 Microsoft Corporation. All rights reserved.
 * Licensed under the MIT License. See LICENSE file in the project root for license information.
 *
 * \note
 * This file is auto generated by LightGBM\helpers\parameter_generator.py from LightGBM\include\LightGBM\config.h file.
 */
Guolin Ke's avatar
Guolin Ke committed
8
9
#include<LightGBM/config.h>
namespace LightGBM {
jcipar's avatar
jcipar committed
10
11
const std::unordered_map<std::string, std::string>& Config::alias_table() {
  static std::unordered_map<std::string, std::string> aliases({
12
13
14
15
16
17
18
19
20
  {"config_file", "config"},
  {"task_type", "task"},
  {"objective_type", "objective"},
  {"app", "objective"},
  {"application", "objective"},
  {"boosting_type", "boosting"},
  {"boost", "boosting"},
  {"train", "data"},
  {"train_data", "data"},
21
  {"train_data_file", "data"},
22
23
24
25
26
  {"data_filename", "data"},
  {"test", "valid"},
  {"valid_data", "valid"},
  {"valid_data_file", "valid"},
  {"test_data", "valid"},
27
  {"test_data_file", "valid"},
28
29
  {"valid_filenames", "valid"},
  {"num_iteration", "num_iterations"},
30
  {"n_iter", "num_iterations"},
31
32
33
34
35
36
37
  {"num_tree", "num_iterations"},
  {"num_trees", "num_iterations"},
  {"num_round", "num_iterations"},
  {"num_rounds", "num_iterations"},
  {"num_boost_round", "num_iterations"},
  {"n_estimators", "num_iterations"},
  {"shrinkage_rate", "learning_rate"},
38
  {"eta", "learning_rate"},
39
  {"num_leaf", "num_leaves"},
40
41
  {"max_leaves", "num_leaves"},
  {"max_leaf", "num_leaves"},
42
  {"tree", "tree_learner"},
43
  {"tree_type", "tree_learner"},
44
45
46
47
  {"tree_learner_type", "tree_learner"},
  {"num_thread", "num_threads"},
  {"nthread", "num_threads"},
  {"nthreads", "num_threads"},
48
  {"n_jobs", "num_threads"},
49
  {"device", "device_type"},
50
  {"random_seed", "seed"},
51
  {"random_state", "seed"},
52
53
54
55
56
57
58
59
60
61
  {"min_data_per_leaf", "min_data_in_leaf"},
  {"min_data", "min_data_in_leaf"},
  {"min_child_samples", "min_data_in_leaf"},
  {"min_sum_hessian_per_leaf", "min_sum_hessian_in_leaf"},
  {"min_sum_hessian", "min_sum_hessian_in_leaf"},
  {"min_hessian", "min_sum_hessian_in_leaf"},
  {"min_child_weight", "min_sum_hessian_in_leaf"},
  {"sub_row", "bagging_fraction"},
  {"subsample", "bagging_fraction"},
  {"bagging", "bagging_fraction"},
Guolin Ke's avatar
Guolin Ke committed
62
63
64
65
66
67
  {"pos_sub_row", "pos_bagging_fraction"},
  {"pos_subsample", "pos_bagging_fraction"},
  {"pos_bagging", "pos_bagging_fraction"},
  {"neg_sub_row", "neg_bagging_fraction"},
  {"neg_subsample", "neg_bagging_fraction"},
  {"neg_bagging", "neg_bagging_fraction"},
68
69
70
71
  {"subsample_freq", "bagging_freq"},
  {"bagging_fraction_seed", "bagging_seed"},
  {"sub_feature", "feature_fraction"},
  {"colsample_bytree", "feature_fraction"},
72
73
  {"sub_feature_bynode", "feature_fraction_bynode"},
  {"colsample_bynode", "feature_fraction_bynode"},
74
75
  {"early_stopping_rounds", "early_stopping_round"},
  {"early_stopping", "early_stopping_round"},
76
  {"n_iter_no_change", "early_stopping_round"},
77
78
79
80
  {"max_tree_output", "max_delta_step"},
  {"max_leaf_output", "max_delta_step"},
  {"reg_alpha", "lambda_l1"},
  {"reg_lambda", "lambda_l2"},
81
  {"lambda", "lambda_l2"},
82
  {"min_split_gain", "min_gain_to_split"},
83
  {"rate_drop", "drop_rate"},
84
85
86
  {"topk", "top_k"},
  {"mc", "monotone_constraints"},
  {"monotone_constraint", "monotone_constraints"},
87
  {"feature_contrib", "feature_contri"},
Guolin Ke's avatar
Guolin Ke committed
88
89
90
  {"fc", "feature_contri"},
  {"fp", "feature_contri"},
  {"feature_penalty", "feature_contri"},
91
92
93
94
95
  {"fs", "forcedsplits_filename"},
  {"forced_splits_filename", "forcedsplits_filename"},
  {"forced_splits_file", "forcedsplits_filename"},
  {"forced_splits", "forcedsplits_filename"},
  {"verbose", "verbosity"},
Guolin Ke's avatar
Guolin Ke committed
96
97
98
  {"is_sparse", "is_enable_sparse"},
  {"enable_sparse", "is_enable_sparse"},
  {"sparse", "is_enable_sparse"},
99
  {"subsample_for_bin", "bin_construct_sample_cnt"},
100
101
  {"hist_pool_size", "histogram_pool_size"},
  {"data_seed", "data_random_seed"},
102
103
  {"model_output", "output_model"},
  {"model_out", "output_model"},
104
  {"save_period", "snapshot_freq"},
105
106
107
108
  {"model_input", "input_model"},
  {"model_in", "input_model"},
  {"predict_result", "output_result"},
  {"prediction_result", "output_result"},
109
110
111
112
  {"predict_name", "output_result"},
  {"prediction_name", "output_result"},
  {"pred_name", "output_result"},
  {"name_pred", "output_result"},
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
  {"is_pre_partition", "pre_partition"},
  {"is_enable_bundle", "enable_bundle"},
  {"bundle", "enable_bundle"},
  {"two_round_loading", "two_round"},
  {"use_two_round_loading", "two_round"},
  {"is_save_binary", "save_binary"},
  {"is_save_binary_file", "save_binary"},
  {"has_header", "header"},
  {"label", "label_column"},
  {"weight", "weight_column"},
  {"group", "group_column"},
  {"group_id", "group_column"},
  {"query_column", "group_column"},
  {"query", "group_column"},
  {"query_id", "group_column"},
  {"ignore_feature", "ignore_column"},
  {"blacklist", "ignore_column"},
  {"cat_feature", "categorical_feature"},
  {"categorical_column", "categorical_feature"},
  {"cat_column", "categorical_feature"},
  {"is_predict_raw_score", "predict_raw_score"},
  {"predict_rawscore", "predict_raw_score"},
  {"raw_score", "predict_raw_score"},
  {"is_predict_leaf_index", "predict_leaf_index"},
  {"leaf_index", "predict_leaf_index"},
  {"is_predict_contrib", "predict_contrib"},
  {"contrib", "predict_contrib"},
  {"convert_model_file", "convert_model"},
  {"num_classes", "num_class"},
142
  {"unbalance", "is_unbalance"},
143
144
145
146
147
148
149
150
151
  {"unbalanced_sets", "is_unbalance"},
  {"metrics", "metric"},
  {"metric_types", "metric"},
  {"output_freq", "metric_freq"},
  {"training_metric", "is_provide_training_metric"},
  {"is_training_metric", "is_provide_training_metric"},
  {"train_metric", "is_provide_training_metric"},
  {"ndcg_eval_at", "eval_at"},
  {"ndcg_at", "eval_at"},
152
153
  {"map_eval_at", "eval_at"},
  {"map_at", "eval_at"},
154
155
156
157
158
159
160
161
  {"num_machine", "num_machines"},
  {"local_port", "local_listen_port"},
  {"port", "local_listen_port"},
  {"machine_list_file", "machine_list_filename"},
  {"machine_list", "machine_list_filename"},
  {"mlist", "machine_list_filename"},
  {"workers", "machines"},
  {"nodes", "machines"},
jcipar's avatar
jcipar committed
162
163
164
  });
  return aliases;
}
Guolin Ke's avatar
Guolin Ke committed
165

jcipar's avatar
jcipar committed
166
167
const std::unordered_set<std::string>& Config::parameter_set() {
  static std::unordered_set<std::string> params({
168
169
170
171
172
173
174
175
176
177
178
179
180
  "config",
  "task",
  "objective",
  "boosting",
  "data",
  "valid",
  "num_iterations",
  "learning_rate",
  "num_leaves",
  "tree_learner",
  "num_threads",
  "device_type",
  "seed",
181
182
  "force_col_wise",
  "force_row_wise",
183
184
185
186
  "max_depth",
  "min_data_in_leaf",
  "min_sum_hessian_in_leaf",
  "bagging_fraction",
Guolin Ke's avatar
Guolin Ke committed
187
188
  "pos_bagging_fraction",
  "neg_bagging_fraction",
189
190
191
  "bagging_freq",
  "bagging_seed",
  "feature_fraction",
192
  "feature_fraction_bynode",
193
  "feature_fraction_seed",
194
195
  "extra_trees",
  "extra_seed",
196
  "early_stopping_round",
197
  "first_metric_only",
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
  "max_delta_step",
  "lambda_l1",
  "lambda_l2",
  "min_gain_to_split",
  "drop_rate",
  "max_drop",
  "skip_drop",
  "xgboost_dart_mode",
  "uniform_drop",
  "drop_seed",
  "top_rate",
  "other_rate",
  "min_data_per_group",
  "max_cat_threshold",
  "cat_l2",
  "cat_smooth",
  "max_cat_to_onehot",
  "top_k",
  "monotone_constraints",
Guolin Ke's avatar
Guolin Ke committed
217
  "feature_contri",
218
  "forcedsplits_filename",
219
  "forcedbins_filename",
Guolin Ke's avatar
Guolin Ke committed
220
  "refit_decay_rate",
221
222
223
224
  "cegb_tradeoff",
  "cegb_penalty_split",
  "cegb_penalty_feature_lazy",
  "cegb_penalty_feature_coupled",
225
226
  "verbosity",
  "max_bin",
Guolin Ke's avatar
Guolin Ke committed
227
  "is_enable_sparse",
Belinda Trotta's avatar
Belinda Trotta committed
228
  "max_bin_by_feature",
229
  "min_data_in_bin",
230
  "feature_pre_filter",
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
  "bin_construct_sample_cnt",
  "histogram_pool_size",
  "data_random_seed",
  "output_model",
  "snapshot_freq",
  "input_model",
  "output_result",
  "pre_partition",
  "enable_bundle",
  "use_missing",
  "zero_as_missing",
  "two_round",
  "save_binary",
  "header",
  "label_column",
  "weight_column",
  "group_column",
  "ignore_column",
  "categorical_feature",
  "predict_raw_score",
  "predict_leaf_index",
  "predict_contrib",
  "num_iteration_predict",
  "pred_early_stop",
  "pred_early_stop_freq",
  "pred_early_stop_margin",
257
  "predict_disable_shape_check",
258
259
260
261
262
263
264
265
266
267
268
269
270
  "convert_model_language",
  "convert_model",
  "num_class",
  "is_unbalance",
  "scale_pos_weight",
  "sigmoid",
  "boost_from_average",
  "reg_sqrt",
  "alpha",
  "fair_c",
  "poisson_max_delta_step",
  "tweedie_variance_power",
  "max_position",
271
  "lambdamart_norm",
272
  "label_gain",
273
  "objective_seed",
274
275
276
277
  "metric",
  "metric_freq",
  "is_provide_training_metric",
  "eval_at",
Belinda Trotta's avatar
Belinda Trotta committed
278
  "multi_error_top_k",
Belinda Trotta's avatar
Belinda Trotta committed
279
  "auc_mu_weights",
280
281
282
283
284
285
286
287
  "num_machines",
  "local_listen_port",
  "time_out",
  "machine_list_filename",
  "machines",
  "gpu_platform_id",
  "gpu_device_id",
  "gpu_use_dp",
jcipar's avatar
jcipar committed
288
289
290
  });
  return params;
}
Guolin Ke's avatar
Guolin Ke committed
291
292
293
294
295
296
297
298
299
300
301
302
303

void Config::GetMembersFromString(const std::unordered_map<std::string, std::string>& params) {
  std::string tmp_str = "";
  GetString(params, "data", &data);

  if (GetString(params, "valid", &tmp_str)) {
    valid = Common::Split(tmp_str.c_str(), ',');
  }

  GetInt(params, "num_iterations", &num_iterations);
  CHECK(num_iterations >=0);

  GetDouble(params, "learning_rate", &learning_rate);
304
  CHECK(learning_rate >0.0);
Guolin Ke's avatar
Guolin Ke committed
305
306
307

  GetInt(params, "num_leaves", &num_leaves);
  CHECK(num_leaves >1);
308
  CHECK(num_leaves <=131072);
Guolin Ke's avatar
Guolin Ke committed
309
310
311

  GetInt(params, "num_threads", &num_threads);

312
313
314
315
  GetBool(params, "force_col_wise", &force_col_wise);

  GetBool(params, "force_row_wise", &force_row_wise);

Guolin Ke's avatar
Guolin Ke committed
316
317
318
319
320
321
  GetInt(params, "max_depth", &max_depth);

  GetInt(params, "min_data_in_leaf", &min_data_in_leaf);
  CHECK(min_data_in_leaf >=0);

  GetDouble(params, "min_sum_hessian_in_leaf", &min_sum_hessian_in_leaf);
322
  CHECK(min_sum_hessian_in_leaf >=0.0);
Guolin Ke's avatar
Guolin Ke committed
323
324

  GetDouble(params, "bagging_fraction", &bagging_fraction);
325
  CHECK(bagging_fraction >0.0);
Guolin Ke's avatar
Guolin Ke committed
326
327
  CHECK(bagging_fraction <=1.0);

Guolin Ke's avatar
Guolin Ke committed
328
329
330
331
332
333
334
335
  GetDouble(params, "pos_bagging_fraction", &pos_bagging_fraction);
  CHECK(pos_bagging_fraction >0.0);
  CHECK(pos_bagging_fraction <=1.0);

  GetDouble(params, "neg_bagging_fraction", &neg_bagging_fraction);
  CHECK(neg_bagging_fraction >0.0);
  CHECK(neg_bagging_fraction <=1.0);

Guolin Ke's avatar
Guolin Ke committed
336
337
338
339
340
  GetInt(params, "bagging_freq", &bagging_freq);

  GetInt(params, "bagging_seed", &bagging_seed);

  GetDouble(params, "feature_fraction", &feature_fraction);
341
  CHECK(feature_fraction >0.0);
Guolin Ke's avatar
Guolin Ke committed
342
343
  CHECK(feature_fraction <=1.0);

344
345
346
347
  GetDouble(params, "feature_fraction_bynode", &feature_fraction_bynode);
  CHECK(feature_fraction_bynode >0.0);
  CHECK(feature_fraction_bynode <=1.0);

Guolin Ke's avatar
Guolin Ke committed
348
349
  GetInt(params, "feature_fraction_seed", &feature_fraction_seed);

350
351
352
353
  GetBool(params, "extra_trees", &extra_trees);

  GetInt(params, "extra_seed", &extra_seed);

Guolin Ke's avatar
Guolin Ke committed
354
355
  GetInt(params, "early_stopping_round", &early_stopping_round);

356
357
  GetBool(params, "first_metric_only", &first_metric_only);

Guolin Ke's avatar
Guolin Ke committed
358
359
360
  GetDouble(params, "max_delta_step", &max_delta_step);

  GetDouble(params, "lambda_l1", &lambda_l1);
361
  CHECK(lambda_l1 >=0.0);
Guolin Ke's avatar
Guolin Ke committed
362
363

  GetDouble(params, "lambda_l2", &lambda_l2);
364
  CHECK(lambda_l2 >=0.0);
Guolin Ke's avatar
Guolin Ke committed
365
366

  GetDouble(params, "min_gain_to_split", &min_gain_to_split);
367
  CHECK(min_gain_to_split >=0.0);
Guolin Ke's avatar
Guolin Ke committed
368
369

  GetDouble(params, "drop_rate", &drop_rate);
370
  CHECK(drop_rate >=0.0);
Guolin Ke's avatar
Guolin Ke committed
371
372
373
374
375
  CHECK(drop_rate <=1.0);

  GetInt(params, "max_drop", &max_drop);

  GetDouble(params, "skip_drop", &skip_drop);
376
  CHECK(skip_drop >=0.0);
Guolin Ke's avatar
Guolin Ke committed
377
378
379
380
381
382
383
384
385
  CHECK(skip_drop <=1.0);

  GetBool(params, "xgboost_dart_mode", &xgboost_dart_mode);

  GetBool(params, "uniform_drop", &uniform_drop);

  GetInt(params, "drop_seed", &drop_seed);

  GetDouble(params, "top_rate", &top_rate);
386
  CHECK(top_rate >=0.0);
Guolin Ke's avatar
Guolin Ke committed
387
388
389
  CHECK(top_rate <=1.0);

  GetDouble(params, "other_rate", &other_rate);
390
  CHECK(other_rate >=0.0);
Guolin Ke's avatar
Guolin Ke committed
391
392
393
394
395
396
397
398
399
  CHECK(other_rate <=1.0);

  GetInt(params, "min_data_per_group", &min_data_per_group);
  CHECK(min_data_per_group >0);

  GetInt(params, "max_cat_threshold", &max_cat_threshold);
  CHECK(max_cat_threshold >0);

  GetDouble(params, "cat_l2", &cat_l2);
400
  CHECK(cat_l2 >=0.0);
Guolin Ke's avatar
Guolin Ke committed
401
402

  GetDouble(params, "cat_smooth", &cat_smooth);
403
  CHECK(cat_smooth >=0.0);
Guolin Ke's avatar
Guolin Ke committed
404
405
406
407
408

  GetInt(params, "max_cat_to_onehot", &max_cat_to_onehot);
  CHECK(max_cat_to_onehot >0);

  GetInt(params, "top_k", &top_k);
409
  CHECK(top_k >0);
Guolin Ke's avatar
Guolin Ke committed
410
411
412
413
414

  if (GetString(params, "monotone_constraints", &tmp_str)) {
    monotone_constraints = Common::StringToArray<int8_t>(tmp_str, ',');
  }

Guolin Ke's avatar
Guolin Ke committed
415
416
417
418
  if (GetString(params, "feature_contri", &tmp_str)) {
    feature_contri = Common::StringToArray<double>(tmp_str, ',');
  }

Guolin Ke's avatar
Guolin Ke committed
419
420
  GetString(params, "forcedsplits_filename", &forcedsplits_filename);

421
422
  GetString(params, "forcedbins_filename", &forcedbins_filename);

Guolin Ke's avatar
Guolin Ke committed
423
424
425
426
  GetDouble(params, "refit_decay_rate", &refit_decay_rate);
  CHECK(refit_decay_rate >=0.0);
  CHECK(refit_decay_rate <=1.0);

427
428
429
430
431
432
433
434
435
436
437
438
439
440
  GetDouble(params, "cegb_tradeoff", &cegb_tradeoff);
  CHECK(cegb_tradeoff >=0.0);

  GetDouble(params, "cegb_penalty_split", &cegb_penalty_split);
  CHECK(cegb_penalty_split >=0.0);

  if (GetString(params, "cegb_penalty_feature_lazy", &tmp_str)) {
    cegb_penalty_feature_lazy = Common::StringToArray<double>(tmp_str, ',');
  }

  if (GetString(params, "cegb_penalty_feature_coupled", &tmp_str)) {
    cegb_penalty_feature_coupled = Common::StringToArray<double>(tmp_str, ',');
  }

441
442
  GetInt(params, "verbosity", &verbosity);

Guolin Ke's avatar
Guolin Ke committed
443
444
445
  GetInt(params, "max_bin", &max_bin);
  CHECK(max_bin >1);

Guolin Ke's avatar
Guolin Ke committed
446
447
  GetBool(params, "is_enable_sparse", &is_enable_sparse);

Belinda Trotta's avatar
Belinda Trotta committed
448
449
450
451
  if (GetString(params, "max_bin_by_feature", &tmp_str)) {
    max_bin_by_feature = Common::StringToArray<int32_t>(tmp_str, ',');
  }

Guolin Ke's avatar
Guolin Ke committed
452
453
454
  GetInt(params, "min_data_in_bin", &min_data_in_bin);
  CHECK(min_data_in_bin >0);

455
456
  GetBool(params, "feature_pre_filter", &feature_pre_filter);

457
458
459
460
461
  GetInt(params, "bin_construct_sample_cnt", &bin_construct_sample_cnt);
  CHECK(bin_construct_sample_cnt >0);

  GetDouble(params, "histogram_pool_size", &histogram_pool_size);

Guolin Ke's avatar
Guolin Ke committed
462
463
464
465
  GetInt(params, "data_random_seed", &data_random_seed);

  GetString(params, "output_model", &output_model);

466
467
  GetInt(params, "snapshot_freq", &snapshot_freq);

Guolin Ke's avatar
Guolin Ke committed
468
469
470
471
472
473
  GetString(params, "input_model", &input_model);

  GetString(params, "output_result", &output_result);

  GetBool(params, "pre_partition", &pre_partition);

474
475
476
477
478
  GetBool(params, "enable_bundle", &enable_bundle);

  GetBool(params, "use_missing", &use_missing);

  GetBool(params, "zero_as_missing", &zero_as_missing);
Guolin Ke's avatar
Guolin Ke committed
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509

  GetBool(params, "two_round", &two_round);

  GetBool(params, "save_binary", &save_binary);

  GetBool(params, "header", &header);

  GetString(params, "label_column", &label_column);

  GetString(params, "weight_column", &weight_column);

  GetString(params, "group_column", &group_column);

  GetString(params, "ignore_column", &ignore_column);

  GetString(params, "categorical_feature", &categorical_feature);

  GetBool(params, "predict_raw_score", &predict_raw_score);

  GetBool(params, "predict_leaf_index", &predict_leaf_index);

  GetBool(params, "predict_contrib", &predict_contrib);

  GetInt(params, "num_iteration_predict", &num_iteration_predict);

  GetBool(params, "pred_early_stop", &pred_early_stop);

  GetInt(params, "pred_early_stop_freq", &pred_early_stop_freq);

  GetDouble(params, "pred_early_stop_margin", &pred_early_stop_margin);

510
511
  GetBool(params, "predict_disable_shape_check", &predict_disable_shape_check);

Guolin Ke's avatar
Guolin Ke committed
512
513
514
515
516
  GetString(params, "convert_model_language", &convert_model_language);

  GetString(params, "convert_model", &convert_model);

  GetInt(params, "num_class", &num_class);
517
  CHECK(num_class >0);
Guolin Ke's avatar
Guolin Ke committed
518

519
  GetBool(params, "is_unbalance", &is_unbalance);
Guolin Ke's avatar
Guolin Ke committed
520

521
522
  GetDouble(params, "scale_pos_weight", &scale_pos_weight);
  CHECK(scale_pos_weight >0.0);
Guolin Ke's avatar
Guolin Ke committed
523

524
525
  GetDouble(params, "sigmoid", &sigmoid);
  CHECK(sigmoid >0.0);
Guolin Ke's avatar
Guolin Ke committed
526
527
528

  GetBool(params, "boost_from_average", &boost_from_average);

529
  GetBool(params, "reg_sqrt", &reg_sqrt);
Guolin Ke's avatar
Guolin Ke committed
530

531
532
  GetDouble(params, "alpha", &alpha);
  CHECK(alpha >0.0);
Guolin Ke's avatar
Guolin Ke committed
533

534
535
536
537
538
  GetDouble(params, "fair_c", &fair_c);
  CHECK(fair_c >0.0);

  GetDouble(params, "poisson_max_delta_step", &poisson_max_delta_step);
  CHECK(poisson_max_delta_step >0.0);
Guolin Ke's avatar
Guolin Ke committed
539
540

  GetDouble(params, "tweedie_variance_power", &tweedie_variance_power);
541
542
543
544
545
  CHECK(tweedie_variance_power >=1.0);
  CHECK(tweedie_variance_power <2.0);

  GetInt(params, "max_position", &max_position);
  CHECK(max_position >0);
Guolin Ke's avatar
Guolin Ke committed
546

547
548
  GetBool(params, "lambdamart_norm", &lambdamart_norm);

Guolin Ke's avatar
Guolin Ke committed
549
550
551
552
  if (GetString(params, "label_gain", &tmp_str)) {
    label_gain = Common::StringToArray<double>(tmp_str, ',');
  }

553
554
  GetInt(params, "objective_seed", &objective_seed);

Guolin Ke's avatar
Guolin Ke committed
555
556
557
558
559
560
561
562
563
  GetInt(params, "metric_freq", &metric_freq);
  CHECK(metric_freq >0);

  GetBool(params, "is_provide_training_metric", &is_provide_training_metric);

  if (GetString(params, "eval_at", &tmp_str)) {
    eval_at = Common::StringToArray<int>(tmp_str, ',');
  }

Belinda Trotta's avatar
Belinda Trotta committed
564
565
566
  GetInt(params, "multi_error_top_k", &multi_error_top_k);
  CHECK(multi_error_top_k >0);

Belinda Trotta's avatar
Belinda Trotta committed
567
568
569
570
  if (GetString(params, "auc_mu_weights", &tmp_str)) {
    auc_mu_weights = Common::StringToArray<double>(tmp_str, ',');
  }

Guolin Ke's avatar
Guolin Ke committed
571
  GetInt(params, "num_machines", &num_machines);
572
  CHECK(num_machines >0);
Guolin Ke's avatar
Guolin Ke committed
573
574

  GetInt(params, "local_listen_port", &local_listen_port);
575
  CHECK(local_listen_port >0);
Guolin Ke's avatar
Guolin Ke committed
576
577

  GetInt(params, "time_out", &time_out);
578
  CHECK(time_out >0);
Guolin Ke's avatar
Guolin Ke committed
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593

  GetString(params, "machine_list_filename", &machine_list_filename);

  GetString(params, "machines", &machines);

  GetInt(params, "gpu_platform_id", &gpu_platform_id);

  GetInt(params, "gpu_device_id", &gpu_device_id);

  GetBool(params, "gpu_use_dp", &gpu_use_dp);
}

std::string Config::SaveMembersToString() const {
  std::stringstream str_buf;
  str_buf << "[data: " << data << "]\n";
594
  str_buf << "[valid: " << Common::Join(valid, ",") << "]\n";
Guolin Ke's avatar
Guolin Ke committed
595
596
597
598
  str_buf << "[num_iterations: " << num_iterations << "]\n";
  str_buf << "[learning_rate: " << learning_rate << "]\n";
  str_buf << "[num_leaves: " << num_leaves << "]\n";
  str_buf << "[num_threads: " << num_threads << "]\n";
599
600
  str_buf << "[force_col_wise: " << force_col_wise << "]\n";
  str_buf << "[force_row_wise: " << force_row_wise << "]\n";
Guolin Ke's avatar
Guolin Ke committed
601
602
603
604
  str_buf << "[max_depth: " << max_depth << "]\n";
  str_buf << "[min_data_in_leaf: " << min_data_in_leaf << "]\n";
  str_buf << "[min_sum_hessian_in_leaf: " << min_sum_hessian_in_leaf << "]\n";
  str_buf << "[bagging_fraction: " << bagging_fraction << "]\n";
Guolin Ke's avatar
Guolin Ke committed
605
606
  str_buf << "[pos_bagging_fraction: " << pos_bagging_fraction << "]\n";
  str_buf << "[neg_bagging_fraction: " << neg_bagging_fraction << "]\n";
Guolin Ke's avatar
Guolin Ke committed
607
608
609
  str_buf << "[bagging_freq: " << bagging_freq << "]\n";
  str_buf << "[bagging_seed: " << bagging_seed << "]\n";
  str_buf << "[feature_fraction: " << feature_fraction << "]\n";
610
  str_buf << "[feature_fraction_bynode: " << feature_fraction_bynode << "]\n";
Guolin Ke's avatar
Guolin Ke committed
611
  str_buf << "[feature_fraction_seed: " << feature_fraction_seed << "]\n";
612
613
  str_buf << "[extra_trees: " << extra_trees << "]\n";
  str_buf << "[extra_seed: " << extra_seed << "]\n";
Guolin Ke's avatar
Guolin Ke committed
614
  str_buf << "[early_stopping_round: " << early_stopping_round << "]\n";
615
  str_buf << "[first_metric_only: " << first_metric_only << "]\n";
Guolin Ke's avatar
Guolin Ke committed
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
  str_buf << "[max_delta_step: " << max_delta_step << "]\n";
  str_buf << "[lambda_l1: " << lambda_l1 << "]\n";
  str_buf << "[lambda_l2: " << lambda_l2 << "]\n";
  str_buf << "[min_gain_to_split: " << min_gain_to_split << "]\n";
  str_buf << "[drop_rate: " << drop_rate << "]\n";
  str_buf << "[max_drop: " << max_drop << "]\n";
  str_buf << "[skip_drop: " << skip_drop << "]\n";
  str_buf << "[xgboost_dart_mode: " << xgboost_dart_mode << "]\n";
  str_buf << "[uniform_drop: " << uniform_drop << "]\n";
  str_buf << "[drop_seed: " << drop_seed << "]\n";
  str_buf << "[top_rate: " << top_rate << "]\n";
  str_buf << "[other_rate: " << other_rate << "]\n";
  str_buf << "[min_data_per_group: " << min_data_per_group << "]\n";
  str_buf << "[max_cat_threshold: " << max_cat_threshold << "]\n";
  str_buf << "[cat_l2: " << cat_l2 << "]\n";
  str_buf << "[cat_smooth: " << cat_smooth << "]\n";
  str_buf << "[max_cat_to_onehot: " << max_cat_to_onehot << "]\n";
  str_buf << "[top_k: " << top_k << "]\n";
634
635
  str_buf << "[monotone_constraints: " << Common::Join(Common::ArrayCast<int8_t, int>(monotone_constraints), ",") << "]\n";
  str_buf << "[feature_contri: " << Common::Join(feature_contri, ",") << "]\n";
Guolin Ke's avatar
Guolin Ke committed
636
  str_buf << "[forcedsplits_filename: " << forcedsplits_filename << "]\n";
637
  str_buf << "[forcedbins_filename: " << forcedbins_filename << "]\n";
Guolin Ke's avatar
Guolin Ke committed
638
  str_buf << "[refit_decay_rate: " << refit_decay_rate << "]\n";
639
640
641
642
  str_buf << "[cegb_tradeoff: " << cegb_tradeoff << "]\n";
  str_buf << "[cegb_penalty_split: " << cegb_penalty_split << "]\n";
  str_buf << "[cegb_penalty_feature_lazy: " << Common::Join(cegb_penalty_feature_lazy, ",") << "]\n";
  str_buf << "[cegb_penalty_feature_coupled: " << Common::Join(cegb_penalty_feature_coupled, ",") << "]\n";
643
  str_buf << "[verbosity: " << verbosity << "]\n";
Guolin Ke's avatar
Guolin Ke committed
644
  str_buf << "[max_bin: " << max_bin << "]\n";
Guolin Ke's avatar
Guolin Ke committed
645
  str_buf << "[is_enable_sparse: " << is_enable_sparse << "]\n";
Belinda Trotta's avatar
Belinda Trotta committed
646
  str_buf << "[max_bin_by_feature: " << Common::Join(max_bin_by_feature, ",") << "]\n";
Guolin Ke's avatar
Guolin Ke committed
647
  str_buf << "[min_data_in_bin: " << min_data_in_bin << "]\n";
648
  str_buf << "[feature_pre_filter: " << feature_pre_filter << "]\n";
649
650
  str_buf << "[bin_construct_sample_cnt: " << bin_construct_sample_cnt << "]\n";
  str_buf << "[histogram_pool_size: " << histogram_pool_size << "]\n";
Guolin Ke's avatar
Guolin Ke committed
651
652
  str_buf << "[data_random_seed: " << data_random_seed << "]\n";
  str_buf << "[output_model: " << output_model << "]\n";
653
  str_buf << "[snapshot_freq: " << snapshot_freq << "]\n";
Guolin Ke's avatar
Guolin Ke committed
654
655
656
  str_buf << "[input_model: " << input_model << "]\n";
  str_buf << "[output_result: " << output_result << "]\n";
  str_buf << "[pre_partition: " << pre_partition << "]\n";
657
658
659
  str_buf << "[enable_bundle: " << enable_bundle << "]\n";
  str_buf << "[use_missing: " << use_missing << "]\n";
  str_buf << "[zero_as_missing: " << zero_as_missing << "]\n";
Guolin Ke's avatar
Guolin Ke committed
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
  str_buf << "[two_round: " << two_round << "]\n";
  str_buf << "[save_binary: " << save_binary << "]\n";
  str_buf << "[header: " << header << "]\n";
  str_buf << "[label_column: " << label_column << "]\n";
  str_buf << "[weight_column: " << weight_column << "]\n";
  str_buf << "[group_column: " << group_column << "]\n";
  str_buf << "[ignore_column: " << ignore_column << "]\n";
  str_buf << "[categorical_feature: " << categorical_feature << "]\n";
  str_buf << "[predict_raw_score: " << predict_raw_score << "]\n";
  str_buf << "[predict_leaf_index: " << predict_leaf_index << "]\n";
  str_buf << "[predict_contrib: " << predict_contrib << "]\n";
  str_buf << "[num_iteration_predict: " << num_iteration_predict << "]\n";
  str_buf << "[pred_early_stop: " << pred_early_stop << "]\n";
  str_buf << "[pred_early_stop_freq: " << pred_early_stop_freq << "]\n";
  str_buf << "[pred_early_stop_margin: " << pred_early_stop_margin << "]\n";
675
  str_buf << "[predict_disable_shape_check: " << predict_disable_shape_check << "]\n";
Guolin Ke's avatar
Guolin Ke committed
676
677
678
  str_buf << "[convert_model_language: " << convert_model_language << "]\n";
  str_buf << "[convert_model: " << convert_model << "]\n";
  str_buf << "[num_class: " << num_class << "]\n";
679
680
  str_buf << "[is_unbalance: " << is_unbalance << "]\n";
  str_buf << "[scale_pos_weight: " << scale_pos_weight << "]\n";
Guolin Ke's avatar
Guolin Ke committed
681
  str_buf << "[sigmoid: " << sigmoid << "]\n";
682
683
  str_buf << "[boost_from_average: " << boost_from_average << "]\n";
  str_buf << "[reg_sqrt: " << reg_sqrt << "]\n";
Guolin Ke's avatar
Guolin Ke committed
684
685
686
687
688
  str_buf << "[alpha: " << alpha << "]\n";
  str_buf << "[fair_c: " << fair_c << "]\n";
  str_buf << "[poisson_max_delta_step: " << poisson_max_delta_step << "]\n";
  str_buf << "[tweedie_variance_power: " << tweedie_variance_power << "]\n";
  str_buf << "[max_position: " << max_position << "]\n";
689
  str_buf << "[lambdamart_norm: " << lambdamart_norm << "]\n";
690
  str_buf << "[label_gain: " << Common::Join(label_gain, ",") << "]\n";
691
  str_buf << "[objective_seed: " << objective_seed << "]\n";
Guolin Ke's avatar
Guolin Ke committed
692
693
  str_buf << "[metric_freq: " << metric_freq << "]\n";
  str_buf << "[is_provide_training_metric: " << is_provide_training_metric << "]\n";
694
  str_buf << "[eval_at: " << Common::Join(eval_at, ",") << "]\n";
Belinda Trotta's avatar
Belinda Trotta committed
695
  str_buf << "[multi_error_top_k: " << multi_error_top_k << "]\n";
Belinda Trotta's avatar
Belinda Trotta committed
696
  str_buf << "[auc_mu_weights: " << Common::Join(auc_mu_weights, ",") << "]\n";
Guolin Ke's avatar
Guolin Ke committed
697
698
699
700
701
702
703
704
705
706
707
  str_buf << "[num_machines: " << num_machines << "]\n";
  str_buf << "[local_listen_port: " << local_listen_port << "]\n";
  str_buf << "[time_out: " << time_out << "]\n";
  str_buf << "[machine_list_filename: " << machine_list_filename << "]\n";
  str_buf << "[machines: " << machines << "]\n";
  str_buf << "[gpu_platform_id: " << gpu_platform_id << "]\n";
  str_buf << "[gpu_device_id: " << gpu_device_id << "]\n";
  str_buf << "[gpu_use_dp: " << gpu_use_dp << "]\n";
  return str_buf.str();
}

708
}  // namespace LightGBM