config_auto.cpp 22.9 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
10
#include<LightGBM/config.h>
namespace LightGBM {
std::unordered_map<std::string, std::string> Config::alias_table({
11
12
13
14
15
16
17
18
19
  {"config_file", "config"},
  {"task_type", "task"},
  {"objective_type", "objective"},
  {"app", "objective"},
  {"application", "objective"},
  {"boosting_type", "boosting"},
  {"boost", "boosting"},
  {"train", "data"},
  {"train_data", "data"},
20
  {"train_data_file", "data"},
21
22
23
24
25
  {"data_filename", "data"},
  {"test", "valid"},
  {"valid_data", "valid"},
  {"valid_data_file", "valid"},
  {"test_data", "valid"},
26
  {"test_data_file", "valid"},
27
28
  {"valid_filenames", "valid"},
  {"num_iteration", "num_iterations"},
29
  {"n_iter", "num_iterations"},
30
31
32
33
34
35
36
  {"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"},
37
  {"eta", "learning_rate"},
38
  {"num_leaf", "num_leaves"},
39
40
  {"max_leaves", "num_leaves"},
  {"max_leaf", "num_leaves"},
41
  {"tree", "tree_learner"},
42
  {"tree_type", "tree_learner"},
43
44
45
46
  {"tree_learner_type", "tree_learner"},
  {"num_thread", "num_threads"},
  {"nthread", "num_threads"},
  {"nthreads", "num_threads"},
47
  {"n_jobs", "num_threads"},
48
  {"device", "device_type"},
49
  {"random_seed", "seed"},
50
  {"random_state", "seed"},
51
52
53
54
55
56
57
58
59
60
  {"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
61
62
63
64
65
66
  {"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"},
67
68
69
70
71
72
73
74
75
76
  {"subsample_freq", "bagging_freq"},
  {"bagging_fraction_seed", "bagging_seed"},
  {"sub_feature", "feature_fraction"},
  {"colsample_bytree", "feature_fraction"},
  {"early_stopping_rounds", "early_stopping_round"},
  {"early_stopping", "early_stopping_round"},
  {"max_tree_output", "max_delta_step"},
  {"max_leaf_output", "max_delta_step"},
  {"reg_alpha", "lambda_l1"},
  {"reg_lambda", "lambda_l2"},
77
  {"lambda", "lambda_l2"},
78
  {"min_split_gain", "min_gain_to_split"},
79
  {"rate_drop", "drop_rate"},
80
81
82
  {"topk", "top_k"},
  {"mc", "monotone_constraints"},
  {"monotone_constraint", "monotone_constraints"},
83
  {"feature_contrib", "feature_contri"},
Guolin Ke's avatar
Guolin Ke committed
84
85
86
  {"fc", "feature_contri"},
  {"fp", "feature_contri"},
  {"feature_penalty", "feature_contri"},
87
88
89
90
91
92
  {"fs", "forcedsplits_filename"},
  {"forced_splits_filename", "forcedsplits_filename"},
  {"forced_splits_file", "forcedsplits_filename"},
  {"forced_splits", "forcedsplits_filename"},
  {"verbose", "verbosity"},
  {"subsample_for_bin", "bin_construct_sample_cnt"},
93
94
  {"hist_pool_size", "histogram_pool_size"},
  {"data_seed", "data_random_seed"},
95
96
  {"model_output", "output_model"},
  {"model_out", "output_model"},
97
  {"save_period", "snapshot_freq"},
98
99
100
101
  {"model_input", "input_model"},
  {"model_in", "input_model"},
  {"predict_result", "output_result"},
  {"prediction_result", "output_result"},
102
103
104
105
  {"predict_name", "output_result"},
  {"prediction_name", "output_result"},
  {"pred_name", "output_result"},
  {"name_pred", "output_result"},
106
107
108
109
110
111
112
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
142
143
144
  {"init_score_filename", "initscore_filename"},
  {"init_score_file", "initscore_filename"},
  {"init_score", "initscore_filename"},
  {"input_init_score", "initscore_filename"},
  {"valid_data_init_scores", "valid_data_initscores"},
  {"valid_init_score_file", "valid_data_initscores"},
  {"valid_init_score", "valid_data_initscores"},
  {"is_pre_partition", "pre_partition"},
  {"is_enable_bundle", "enable_bundle"},
  {"bundle", "enable_bundle"},
  {"is_sparse", "is_enable_sparse"},
  {"enable_sparse", "is_enable_sparse"},
  {"sparse", "is_enable_sparse"},
  {"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"},
145
  {"unbalance", "is_unbalance"},
146
147
148
149
150
151
152
153
154
  {"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"},
155
156
  {"map_eval_at", "eval_at"},
  {"map_at", "eval_at"},
157
158
159
160
161
162
163
164
  {"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"},
Guolin Ke's avatar
Guolin Ke committed
165
166
167
});

std::unordered_set<std::string> Config::parameter_set({
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
  "config",
  "task",
  "objective",
  "boosting",
  "data",
  "valid",
  "num_iterations",
  "learning_rate",
  "num_leaves",
  "tree_learner",
  "num_threads",
  "device_type",
  "seed",
  "max_depth",
  "min_data_in_leaf",
  "min_sum_hessian_in_leaf",
  "bagging_fraction",
Guolin Ke's avatar
Guolin Ke committed
185
186
  "pos_bagging_fraction",
  "neg_bagging_fraction",
187
188
189
190
191
  "bagging_freq",
  "bagging_seed",
  "feature_fraction",
  "feature_fraction_seed",
  "early_stopping_round",
192
  "first_metric_only",
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
  "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
212
  "feature_contri",
213
  "forcedsplits_filename",
Guolin Ke's avatar
Guolin Ke committed
214
  "refit_decay_rate",
215
216
217
218
  "cegb_tradeoff",
  "cegb_penalty_split",
  "cegb_penalty_feature_lazy",
  "cegb_penalty_feature_coupled",
219
220
  "verbosity",
  "max_bin",
Belinda Trotta's avatar
Belinda Trotta committed
221
  "max_bin_by_feature",
222
223
224
225
226
227
228
229
230
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
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
  "min_data_in_bin",
  "bin_construct_sample_cnt",
  "histogram_pool_size",
  "data_random_seed",
  "output_model",
  "snapshot_freq",
  "input_model",
  "output_result",
  "initscore_filename",
  "valid_data_initscores",
  "pre_partition",
  "enable_bundle",
  "max_conflict_rate",
  "is_enable_sparse",
  "sparse_threshold",
  "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",
  "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",
  "label_gain",
  "metric",
  "metric_freq",
  "is_provide_training_metric",
  "eval_at",
Belinda Trotta's avatar
Belinda Trotta committed
272
  "multi_error_top_k",
273
274
275
276
277
278
279
280
  "num_machines",
  "local_listen_port",
  "time_out",
  "machine_list_filename",
  "machines",
  "gpu_platform_id",
  "gpu_device_id",
  "gpu_use_dp",
Guolin Ke's avatar
Guolin Ke committed
281
282
283
284
285
286
287
288
289
290
291
292
293
294
});

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);
295
  CHECK(learning_rate >0.0);
Guolin Ke's avatar
Guolin Ke committed
296
297
298
299
300
301
302
303
304
305
306
307

  GetInt(params, "num_leaves", &num_leaves);
  CHECK(num_leaves >1);

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

  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);
308
  CHECK(min_sum_hessian_in_leaf >=0.0);
Guolin Ke's avatar
Guolin Ke committed
309
310

  GetDouble(params, "bagging_fraction", &bagging_fraction);
311
  CHECK(bagging_fraction >0.0);
Guolin Ke's avatar
Guolin Ke committed
312
313
  CHECK(bagging_fraction <=1.0);

Guolin Ke's avatar
Guolin Ke committed
314
315
316
317
318
319
320
321
  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
322
323
324
325
326
  GetInt(params, "bagging_freq", &bagging_freq);

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

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

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

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

334
335
  GetBool(params, "first_metric_only", &first_metric_only);

Guolin Ke's avatar
Guolin Ke committed
336
337
338
  GetDouble(params, "max_delta_step", &max_delta_step);

  GetDouble(params, "lambda_l1", &lambda_l1);
339
  CHECK(lambda_l1 >=0.0);
Guolin Ke's avatar
Guolin Ke committed
340
341

  GetDouble(params, "lambda_l2", &lambda_l2);
342
  CHECK(lambda_l2 >=0.0);
Guolin Ke's avatar
Guolin Ke committed
343
344

  GetDouble(params, "min_gain_to_split", &min_gain_to_split);
345
  CHECK(min_gain_to_split >=0.0);
Guolin Ke's avatar
Guolin Ke committed
346
347

  GetDouble(params, "drop_rate", &drop_rate);
348
  CHECK(drop_rate >=0.0);
Guolin Ke's avatar
Guolin Ke committed
349
350
351
352
353
  CHECK(drop_rate <=1.0);

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

  GetDouble(params, "skip_drop", &skip_drop);
354
  CHECK(skip_drop >=0.0);
Guolin Ke's avatar
Guolin Ke committed
355
356
357
358
359
360
361
362
363
  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);
364
  CHECK(top_rate >=0.0);
Guolin Ke's avatar
Guolin Ke committed
365
366
367
  CHECK(top_rate <=1.0);

  GetDouble(params, "other_rate", &other_rate);
368
  CHECK(other_rate >=0.0);
Guolin Ke's avatar
Guolin Ke committed
369
370
371
372
373
374
375
376
377
  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);
378
  CHECK(cat_l2 >=0.0);
Guolin Ke's avatar
Guolin Ke committed
379
380

  GetDouble(params, "cat_smooth", &cat_smooth);
381
  CHECK(cat_smooth >=0.0);
Guolin Ke's avatar
Guolin Ke committed
382
383
384
385
386

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

  GetInt(params, "top_k", &top_k);
387
  CHECK(top_k >0);
Guolin Ke's avatar
Guolin Ke committed
388
389
390
391
392

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

Guolin Ke's avatar
Guolin Ke committed
393
394
395
396
  if (GetString(params, "feature_contri", &tmp_str)) {
    feature_contri = Common::StringToArray<double>(tmp_str, ',');
  }

Guolin Ke's avatar
Guolin Ke committed
397
398
  GetString(params, "forcedsplits_filename", &forcedsplits_filename);

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

403
404
405
406
407
408
409
410
411
412
413
414
415
416
  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, ',');
  }

417
418
  GetInt(params, "verbosity", &verbosity);

Guolin Ke's avatar
Guolin Ke committed
419
420
421
  GetInt(params, "max_bin", &max_bin);
  CHECK(max_bin >1);

Belinda Trotta's avatar
Belinda Trotta committed
422
423
424
425
  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
426
427
428
  GetInt(params, "min_data_in_bin", &min_data_in_bin);
  CHECK(min_data_in_bin >0);

429
430
431
432
433
  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
434
435
436
437
  GetInt(params, "data_random_seed", &data_random_seed);

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

438
439
  GetInt(params, "snapshot_freq", &snapshot_freq);

Guolin Ke's avatar
Guolin Ke committed
440
441
442
443
  GetString(params, "input_model", &input_model);

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

444
445
446
447
448
449
  GetString(params, "initscore_filename", &initscore_filename);

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

Guolin Ke's avatar
Guolin Ke committed
450
451
  GetBool(params, "pre_partition", &pre_partition);

452
453
454
455
456
457
  GetBool(params, "enable_bundle", &enable_bundle);

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

Guolin Ke's avatar
Guolin Ke committed
458
459
460
  GetBool(params, "is_enable_sparse", &is_enable_sparse);

  GetDouble(params, "sparse_threshold", &sparse_threshold);
461
462
463
464
465
466
  CHECK(sparse_threshold >0.0);
  CHECK(sparse_threshold <=1.0);

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

  GetBool(params, "zero_as_missing", &zero_as_missing);
Guolin Ke's avatar
Guolin Ke committed
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502

  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);

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

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

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

505
  GetBool(params, "is_unbalance", &is_unbalance);
Guolin Ke's avatar
Guolin Ke committed
506

507
508
  GetDouble(params, "scale_pos_weight", &scale_pos_weight);
  CHECK(scale_pos_weight >0.0);
Guolin Ke's avatar
Guolin Ke committed
509

510
511
  GetDouble(params, "sigmoid", &sigmoid);
  CHECK(sigmoid >0.0);
Guolin Ke's avatar
Guolin Ke committed
512
513
514

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

515
  GetBool(params, "reg_sqrt", &reg_sqrt);
Guolin Ke's avatar
Guolin Ke committed
516

517
518
  GetDouble(params, "alpha", &alpha);
  CHECK(alpha >0.0);
Guolin Ke's avatar
Guolin Ke committed
519

520
521
522
523
524
  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
525
526

  GetDouble(params, "tweedie_variance_power", &tweedie_variance_power);
527
528
529
530
531
  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
532
533
534
535
536
537
538
539
540
541
542
543
544
545

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

  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
546
547
548
  GetInt(params, "multi_error_top_k", &multi_error_top_k);
  CHECK(multi_error_top_k >0);

Guolin Ke's avatar
Guolin Ke committed
549
  GetInt(params, "num_machines", &num_machines);
550
  CHECK(num_machines >0);
Guolin Ke's avatar
Guolin Ke committed
551
552

  GetInt(params, "local_listen_port", &local_listen_port);
553
  CHECK(local_listen_port >0);
Guolin Ke's avatar
Guolin Ke committed
554
555

  GetInt(params, "time_out", &time_out);
556
  CHECK(time_out >0);
Guolin Ke's avatar
Guolin Ke committed
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572

  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";
573
  str_buf << "[valid: " << Common::Join(valid, ",") << "]\n";
Guolin Ke's avatar
Guolin Ke committed
574
575
576
577
578
579
580
581
  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";
  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
582
583
  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
584
585
586
587
588
  str_buf << "[bagging_freq: " << bagging_freq << "]\n";
  str_buf << "[bagging_seed: " << bagging_seed << "]\n";
  str_buf << "[feature_fraction: " << feature_fraction << "]\n";
  str_buf << "[feature_fraction_seed: " << feature_fraction_seed << "]\n";
  str_buf << "[early_stopping_round: " << early_stopping_round << "]\n";
589
  str_buf << "[first_metric_only: " << first_metric_only << "]\n";
Guolin Ke's avatar
Guolin Ke committed
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
  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";
608
609
  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
610
  str_buf << "[forcedsplits_filename: " << forcedsplits_filename << "]\n";
Guolin Ke's avatar
Guolin Ke committed
611
  str_buf << "[refit_decay_rate: " << refit_decay_rate << "]\n";
612
613
614
615
  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";
616
  str_buf << "[verbosity: " << verbosity << "]\n";
Guolin Ke's avatar
Guolin Ke committed
617
  str_buf << "[max_bin: " << max_bin << "]\n";
Belinda Trotta's avatar
Belinda Trotta committed
618
  str_buf << "[max_bin_by_feature: " << Common::Join(max_bin_by_feature, ",") << "]\n";
Guolin Ke's avatar
Guolin Ke committed
619
  str_buf << "[min_data_in_bin: " << min_data_in_bin << "]\n";
620
621
  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
622
623
  str_buf << "[data_random_seed: " << data_random_seed << "]\n";
  str_buf << "[output_model: " << output_model << "]\n";
624
  str_buf << "[snapshot_freq: " << snapshot_freq << "]\n";
Guolin Ke's avatar
Guolin Ke committed
625
626
  str_buf << "[input_model: " << input_model << "]\n";
  str_buf << "[output_result: " << output_result << "]\n";
627
  str_buf << "[initscore_filename: " << initscore_filename << "]\n";
628
  str_buf << "[valid_data_initscores: " << Common::Join(valid_data_initscores, ",") << "]\n";
Guolin Ke's avatar
Guolin Ke committed
629
  str_buf << "[pre_partition: " << pre_partition << "]\n";
630
631
  str_buf << "[enable_bundle: " << enable_bundle << "]\n";
  str_buf << "[max_conflict_rate: " << max_conflict_rate << "]\n";
Guolin Ke's avatar
Guolin Ke committed
632
633
  str_buf << "[is_enable_sparse: " << is_enable_sparse << "]\n";
  str_buf << "[sparse_threshold: " << sparse_threshold << "]\n";
634
635
  str_buf << "[use_missing: " << use_missing << "]\n";
  str_buf << "[zero_as_missing: " << zero_as_missing << "]\n";
Guolin Ke's avatar
Guolin Ke committed
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
  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";
  str_buf << "[convert_model_language: " << convert_model_language << "]\n";
  str_buf << "[convert_model: " << convert_model << "]\n";
  str_buf << "[num_class: " << num_class << "]\n";
654
655
  str_buf << "[is_unbalance: " << is_unbalance << "]\n";
  str_buf << "[scale_pos_weight: " << scale_pos_weight << "]\n";
Guolin Ke's avatar
Guolin Ke committed
656
  str_buf << "[sigmoid: " << sigmoid << "]\n";
657
658
  str_buf << "[boost_from_average: " << boost_from_average << "]\n";
  str_buf << "[reg_sqrt: " << reg_sqrt << "]\n";
Guolin Ke's avatar
Guolin Ke committed
659
660
661
662
663
  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";
664
  str_buf << "[label_gain: " << Common::Join(label_gain, ",") << "]\n";
Guolin Ke's avatar
Guolin Ke committed
665
666
  str_buf << "[metric_freq: " << metric_freq << "]\n";
  str_buf << "[is_provide_training_metric: " << is_provide_training_metric << "]\n";
667
  str_buf << "[eval_at: " << Common::Join(eval_at, ",") << "]\n";
Belinda Trotta's avatar
Belinda Trotta committed
668
  str_buf << "[multi_error_top_k: " << multi_error_top_k << "]\n";
Guolin Ke's avatar
Guolin Ke committed
669
670
671
672
673
674
675
676
677
678
679
  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();
}

680
}  // namespace LightGBM