config.h 17.5 KB
Newer Older
Guolin Ke's avatar
Guolin Ke committed
1
2
3
4
5
6
#ifndef LIGHTGBM_CONFIG_H_
#define LIGHTGBM_CONFIG_H_

#include <LightGBM/utils/common.h>
#include <LightGBM/utils/log.h>

Guolin Ke's avatar
Guolin Ke committed
7
#include <LightGBM/meta.h>
8
#include <LightGBM/export.h>
Guolin Ke's avatar
Guolin Ke committed
9

Guolin Ke's avatar
Guolin Ke committed
10
11
12
#include <vector>
#include <string>
#include <unordered_map>
wxchan's avatar
wxchan committed
13
#include <unordered_set>
Guolin Ke's avatar
Guolin Ke committed
14
#include <algorithm>
Guolin Ke's avatar
Guolin Ke committed
15
#include <memory>
Guolin Ke's avatar
Guolin Ke committed
16
17
18
19
20
21
22
23
24
25
26
27

namespace LightGBM {

/*!
* \brief The interface for Config
*/
struct ConfigBase {
public:
  /*! \brief virtual destructor */
  virtual ~ConfigBase() {}

  /*!
Hui Xue's avatar
Hui Xue committed
28
  * \brief Set current config object by params
Guolin Ke's avatar
Guolin Ke committed
29
30
31
32
33
34
35
36
37
  * \param params Store the key and value for params
  */
  virtual void Set(
    const std::unordered_map<std::string, std::string>& params) = 0;

  /*!
  * \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
41
42
43
44
45
46
47
48
  * \return True if key exists
  */
  inline bool GetString(
    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
52
53
54
55
56
  * \return True if key exists
  */
  inline bool GetInt(
    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
  */
63
  inline 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
74
75
76
  * \return True if key exists
  */
  inline bool GetBool(
    const std::unordered_map<std::string, std::string>& params,
    const std::string& name, bool* out);
77
78

  static std::unordered_map<std::string, std::string> Str2Map(const char* parameters);
Guolin Ke's avatar
Guolin Ke committed
79
80
81
82
};

/*! \brief Types of tasks */
enum TaskType {
83
  kTrain, kPredict, kConvertModel
Guolin Ke's avatar
Guolin Ke committed
84
85
86
87
88
};

/*! \brief Config for input and output files */
struct IOConfig: public ConfigBase {
public:
89
  int max_bin = 255;
90
  int num_class = 1;
Guolin Ke's avatar
Guolin Ke committed
91
92
93
  int data_random_seed = 1;
  std::string data_filename = "";
  std::vector<std::string> valid_data_filenames;
94
  int snapshot_freq = -1;
Guolin Ke's avatar
Guolin Ke committed
95
96
  std::string output_model = "LightGBM_model.txt";
  std::string output_result = "LightGBM_predict_result.txt";
97
  std::string convert_model = "gbdt_prediction.cpp";
Guolin Ke's avatar
Guolin Ke committed
98
  std::string input_model = "";
Guolin Ke's avatar
Guolin Ke committed
99
  int verbosity = 1;
100
  int num_iteration_predict = -1;
Guolin Ke's avatar
Guolin Ke committed
101
102
  bool is_pre_partition = false;
  bool is_enable_sparse = true;
103
104
105
106
107
  /*! \brief The threshold of zero elements precentage for treating a feature as a sparse feature.
   *  Default is 0.8, where a feature is treated as a sparse feature when there are over 80% zeros.
   *  When setting to 1.0, all features are processed as dense features.
   */
  double sparse_threshold = 0.8;
Guolin Ke's avatar
Guolin Ke committed
108
109
  bool use_two_round_loading = false;
  bool is_save_binary_file = false;
Guolin Ke's avatar
Guolin Ke committed
110
  bool enable_load_from_binary_file = true;
Guolin Ke's avatar
Guolin Ke committed
111
  int bin_construct_sample_cnt = 200000;
Guolin Ke's avatar
Guolin Ke committed
112
113
  bool is_predict_leaf_index = false;
  bool is_predict_raw_score = false;
114
  int min_data_in_leaf = 20;
Guolin Ke's avatar
Guolin Ke committed
115
  int min_data_in_bin = 5;
116
  double max_conflict_rate = 0.0f;
Guolin Ke's avatar
Guolin Ke committed
117
  bool enable_bundle = true;
Guolin Ke's avatar
Guolin Ke committed
118
119
120
121
122
  bool has_header = false;
  /*! \brief Index or column name of label, default is the first column
   * And add an prefix "name:" while using column name */
  std::string label_column = "";
  /*! \brief Index or column name of weight, < 0 means not used
Guolin Ke's avatar
Guolin Ke committed
123
  * And add an prefix "name:" while using column name 
124
  * Note: when using Index, it doesn't count the label index */
Guolin Ke's avatar
Guolin Ke committed
125
  std::string weight_column = "";
Guolin Ke's avatar
Guolin Ke committed
126
127
  /*! \brief Index or column name of group/query id, < 0 means not used
  * And add an prefix "name:" while using column name
128
  * Note: when using Index, it doesn't count the label index */
Guolin Ke's avatar
Guolin Ke committed
129
130
  std::string group_column = "";
  /*! \brief ignored features, separate by ','
Guolin Ke's avatar
Guolin Ke committed
131
  * And add an prefix "name:" while using column name
132
  * Note: when using Index, it doesn't count the label index */
Guolin Ke's avatar
Guolin Ke committed
133
  std::string ignore_column = "";
134
135
  /*! \brief specific categorical columns, Note:only support for integer type categorical
  * And add an prefix "name:" while using column name
136
  * Note: when using Index, it doesn't count the label index */
137
  std::string categorical_column = "";
Guolin Ke's avatar
Guolin Ke committed
138
  std::string device_type = "cpu";
139
140
141
142
143
144
145
146

  /*! \brief Set to true if want to use early stop for the prediction */
  bool pred_early_stop = false;
  /*! \brief Frequency of checking the pred_early_stop */
  int pred_early_stop_freq = 10;
  /*! \brief Threshold of margin of pred_early_stop */
  double pred_early_stop_margin = 10.0f;

147
  LIGHTGBM_EXPORT void Set(const std::unordered_map<std::string, std::string>& params) override;
Guolin Ke's avatar
Guolin Ke committed
148
149
150
private:
  void GetDeviceType(const std::unordered_map<std::string,
                     std::string>& params);
Guolin Ke's avatar
Guolin Ke committed
151
152
153
154
155
156
};

/*! \brief Config for objective function */
struct ObjectiveConfig: public ConfigBase {
public:
  virtual ~ObjectiveConfig() {}
157
  double sigmoid = 1.0f;
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
158
  double huber_delta = 1.0f;
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
159
  double fair_c = 1.0f;
160
  // for Approximate Hessian With Gaussian
161
  double gaussian_eta = 1.0f;
162
  double poisson_max_delta_step = 0.7f;
Guolin Ke's avatar
Guolin Ke committed
163
  // for lambdarank
164
  std::vector<double> label_gain;
Guolin Ke's avatar
Guolin Ke committed
165
166
167
168
  // for lambdarank
  int max_position = 20;
  // for binary
  bool is_unbalance = false;
169
170
  // for multiclass
  int num_class = 1;
Guolin Ke's avatar
Guolin Ke committed
171
172
  // Balancing of positive and negative weights
  double scale_pos_weight = 1.0f;
173
  LIGHTGBM_EXPORT void Set(const std::unordered_map<std::string, std::string>& params) override;
Guolin Ke's avatar
Guolin Ke committed
174
175
176
177
178
179
};

/*! \brief Config for metrics interface*/
struct MetricConfig: public ConfigBase {
public:
  virtual ~MetricConfig() {}
180
  int num_class = 1;
181
  double sigmoid = 1.0f;
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
182
  double huber_delta = 1.0f;
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
183
  double fair_c = 1.0f;
184
  std::vector<double> label_gain;
Guolin Ke's avatar
Guolin Ke committed
185
  std::vector<int> eval_at;
186
  LIGHTGBM_EXPORT void Set(const std::unordered_map<std::string, std::string>& params) override;
Guolin Ke's avatar
Guolin Ke committed
187
188
189
190
191
192
};


/*! \brief Config for tree model */
struct TreeConfig: public ConfigBase {
public:
193
194
  int min_data_in_leaf = 20;
  double min_sum_hessian_in_leaf = 1e-3f;
195
196
197
  double lambda_l1 = 0.0f;
  double lambda_l2 = 0.0f;
  double min_gain_to_split = 0.0f;
198
199
  // should > 1
  int num_leaves = 31;
Guolin Ke's avatar
Guolin Ke committed
200
  int feature_fraction_seed = 2;
201
  double feature_fraction = 1.0f;
tks's avatar
tks committed
202
  // max cache size(unit:MB) for historical histogram. < 0 means no limit
203
  double histogram_pool_size = -1.0f;
204
  // max depth of tree model.
Guolin Ke's avatar
Guolin Ke committed
205
  // Still grow tree by leaf-wise, but limit the max depth to avoid over-fitting
tks's avatar
tks committed
206
207
  // And the max leaves will be min(num_leaves, pow(2, max_depth))
  // max_depth < 0 means no limit
208
  int max_depth = -1;
Guolin Ke's avatar
Guolin Ke committed
209
  int top_k = 20;
210
211
212
213
214
215
216
217
218
219
  /*! \brief OpenCL platform ID. Usually each GPU vendor exposes one OpenCL platform.
   *  Default value is -1, using the system-wide default platform
   */
  int gpu_platform_id = -1;
  /*! \brief OpenCL device ID in the specified platform. Each GPU in the selected platform has a
   *  unique device ID. Default value is -1, using the default device in the selected platform
   */
  int gpu_device_id = -1;
  /*! \brief Set to true to use double precision math on GPU (default using single precision) */
  bool gpu_use_dp = false;
220
221
  /*! \brief Set to false to disable the handle of missing values */
  bool use_missing = true;
222
  LIGHTGBM_EXPORT void Set(const std::unordered_map<std::string, std::string>& params) override;
Guolin Ke's avatar
Guolin Ke committed
223
224
225
226
227
228
};

/*! \brief Config for Boosting */
struct BoostingConfig: public ConfigBase {
public:
  virtual ~BoostingConfig() {}
Guolin Ke's avatar
Guolin Ke committed
229
  double sigmoid = 1.0f;
230
231
  int output_freq = 1;
  bool is_provide_training_metric = false;
232
  int num_iterations = 100;
233
234
  double learning_rate = 0.1f;
  double bagging_fraction = 1.0f;
Guolin Ke's avatar
Guolin Ke committed
235
236
  int bagging_seed = 3;
  int bagging_freq = 0;
wxchan's avatar
wxchan committed
237
  int early_stopping_round = 0;
238
  int num_class = 1;
239
240
241
242
243
  double drop_rate = 0.1;
  int max_drop = 50;
  double skip_drop = 0.5;
  bool xgboost_dart_mode = false;
  bool uniform_drop = false;
Guolin Ke's avatar
Guolin Ke committed
244
  int drop_seed = 4;
Guolin Ke's avatar
Guolin Ke committed
245
246
  double top_rate = 0.2f;
  double other_rate = 0.1f;
247
  // only used for the regression. Will boost from the average labels.
248
  bool boost_from_average = true;
249
  std::string tree_learner_type = "serial";
250
  std::string device_type = "cpu";
Guolin Ke's avatar
Guolin Ke committed
251
  TreeConfig tree_config;
252
  LIGHTGBM_EXPORT void Set(const std::unordered_map<std::string, std::string>& params) override;
Guolin Ke's avatar
Guolin Ke committed
253
254
private:
  void GetTreeLearnerType(const std::unordered_map<std::string,
Guolin Ke's avatar
Guolin Ke committed
255
    std::string>& params);
256
257
  void GetDeviceType(const std::unordered_map<std::string,
    std::string>& params);
Guolin Ke's avatar
Guolin Ke committed
258
259
260
261
262
263
264
265
266
};

/*! \brief Config for Network */
struct NetworkConfig: public ConfigBase {
public:
  int num_machines = 1;
  int local_listen_port = 12400;
  int time_out = 120;  // in minutes
  std::string machine_list_filename = "";
267
  LIGHTGBM_EXPORT void Set(const std::unordered_map<std::string, std::string>& params) override;
Guolin Ke's avatar
Guolin Ke committed
268
269
270
271
272
273
274
275
};


/*! \brief Overall config, all configs will put on this class */
struct OverallConfig: public ConfigBase {
public:
  TaskType task_type = TaskType::kTrain;
  NetworkConfig network_config;
Guolin Ke's avatar
Guolin Ke committed
276
  int seed = 0;
Guolin Ke's avatar
Guolin Ke committed
277
278
279
280
  int num_threads = 0;
  bool is_parallel = false;
  bool is_parallel_find_bin = false;
  IOConfig io_config;
Guolin Ke's avatar
Guolin Ke committed
281
  std::string boosting_type = "gbdt";
Guolin Ke's avatar
Guolin Ke committed
282
  BoostingConfig boosting_config;
Guolin Ke's avatar
Guolin Ke committed
283
284
285
286
  std::string objective_type = "regression";
  ObjectiveConfig objective_config;
  std::vector<std::string> metric_types;
  MetricConfig metric_config;
287
  std::string convert_model_language = "";
Guolin Ke's avatar
Guolin Ke committed
288

289
  LIGHTGBM_EXPORT void Set(const std::unordered_map<std::string, std::string>& params) override;
290

Guolin Ke's avatar
Guolin Ke committed
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
private:
  void GetBoostingType(const std::unordered_map<std::string, std::string>& params);

  void GetObjectiveType(const std::unordered_map<std::string, std::string>& params);

  void GetMetricType(const std::unordered_map<std::string, std::string>& params);

  void GetTaskType(const std::unordered_map<std::string, std::string>& params);

  void CheckParamConflict();
};


inline bool ConfigBase::GetString(
  const std::unordered_map<std::string, std::string>& params,
  const std::string& name, std::string* out) {
  if (params.count(name) > 0) {
    *out = params.at(name);
    return true;
  }
  return false;
}

inline bool ConfigBase::GetInt(
  const std::unordered_map<std::string, std::string>& params,
  const std::string& name, int* out) {
  if (params.count(name) > 0) {
318
    if (!Common::AtoiAndCheck(params.at(name).c_str(), out)) {
319
      Log::Fatal("Parameter %s should be of type int, got \"%s\"",
320
321
        name.c_str(), params.at(name).c_str());
    }
Guolin Ke's avatar
Guolin Ke committed
322
323
324
325
326
    return true;
  }
  return false;
}

327
inline bool ConfigBase::GetDouble(
Guolin Ke's avatar
Guolin Ke committed
328
  const std::unordered_map<std::string, std::string>& params,
329
  const std::string& name, double* out) {
Guolin Ke's avatar
Guolin Ke committed
330
  if (params.count(name) > 0) {
331
    if (!Common::AtofAndCheck(params.at(name).c_str(), out)) {
332
      Log::Fatal("Parameter %s should be of type double, got \"%s\"",
333
334
        name.c_str(), params.at(name).c_str());
    }
Guolin Ke's avatar
Guolin Ke committed
335
336
337
338
339
340
341
342
343
344
    return true;
  }
  return false;
}

inline bool ConfigBase::GetBool(
  const std::unordered_map<std::string, std::string>& params,
  const std::string& name, bool* out) {
  if (params.count(name) > 0) {
    std::string value = params.at(name);
Guolin Ke's avatar
Guolin Ke committed
345
    std::transform(value.begin(), value.end(), value.begin(), Common::tolower);
346
    if (value == std::string("false") || value == std::string("-")) {
Guolin Ke's avatar
Guolin Ke committed
347
      *out = false;
348
    } else if (value == std::string("true") || value == std::string("+")) {
Guolin Ke's avatar
Guolin Ke committed
349
      *out = true;
350
    } else {
351
      Log::Fatal("Parameter %s should be \"true\"/\"+\" or \"false\"/\"-\", got \"%s\"",
352
        name.c_str(), params.at(name).c_str());
Guolin Ke's avatar
Guolin Ke committed
353
354
355
356
357
358
359
360
361
362
363
364
    }
    return true;
  }
  return false;
}

struct ParameterAlias {
  static void KeyAliasTransform(std::unordered_map<std::string, std::string>* params) {
    std::unordered_map<std::string, std::string> alias_table(
    {
      { "config", "config_file" },
      { "nthread", "num_threads" },
Guolin Ke's avatar
Guolin Ke committed
365
      { "random_seed", "seed" },
Guolin Ke's avatar
Guolin Ke committed
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
      { "num_thread", "num_threads" },
      { "boosting", "boosting_type" },
      { "boost", "boosting_type" },
      { "application", "objective" },
      { "app", "objective" },
      { "train_data", "data" },
      { "train", "data" },
      { "model_output", "output_model" },
      { "model_out", "output_model" },
      { "model_input", "input_model" },
      { "model_in", "input_model" },
      { "predict_result", "output_result" },
      { "prediction_result", "output_result" },
      { "valid", "valid_data" },
      { "test_data", "valid_data" },
      { "test", "valid_data" },
      { "is_sparse", "is_enable_sparse" },
Guolin Ke's avatar
Guolin Ke committed
383
384
      { "enable_sparse", "is_enable_sparse" },
      { "pre_partition", "is_pre_partition" },
Guolin Ke's avatar
Guolin Ke committed
385
386
387
      { "tranining_metric", "is_training_metric" },
      { "train_metric", "is_training_metric" },
      { "ndcg_at", "ndcg_eval_at" },
Guolin Ke's avatar
Guolin Ke committed
388
      { "eval_at", "ndcg_eval_at" },
Guolin Ke's avatar
Guolin Ke committed
389
390
      { "min_data_per_leaf", "min_data_in_leaf" },
      { "min_data", "min_data_in_leaf" },
Guolin Ke's avatar
Guolin Ke committed
391
      { "min_child_samples", "min_data_in_leaf" },
Guolin Ke's avatar
Guolin Ke committed
392
393
394
      { "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" },
Guolin Ke's avatar
Guolin Ke committed
395
      { "min_child_weight", "min_sum_hessian_in_leaf" },
Guolin Ke's avatar
Guolin Ke committed
396
397
      { "num_leaf", "num_leaves" },
      { "sub_feature", "feature_fraction" },
Guolin Ke's avatar
Guolin Ke committed
398
      { "colsample_bytree", "feature_fraction" },
Guolin Ke's avatar
Guolin Ke committed
399
400
401
402
403
404
      { "num_iteration", "num_iterations" },
      { "num_tree", "num_iterations" },
      { "num_round", "num_iterations" },
      { "num_trees", "num_iterations" },
      { "num_rounds", "num_iterations" },
      { "sub_row", "bagging_fraction" },
Guolin Ke's avatar
Guolin Ke committed
405
406
      { "subsample", "bagging_fraction" },
      { "subsample_freq", "bagging_freq" },
Guolin Ke's avatar
Guolin Ke committed
407
408
409
410
411
412
413
414
      { "shrinkage_rate", "learning_rate" },
      { "tree", "tree_learner" },
      { "num_machine", "num_machines" },
      { "local_port", "local_listen_port" },
      { "two_round_loading", "use_two_round_loading"},
      { "two_round", "use_two_round_loading" },
      { "mlist", "machine_list_file" },
      { "is_save_binary", "is_save_binary_file" },
Qiwei Ye's avatar
Qiwei Ye committed
415
      { "save_binary", "is_save_binary_file" },
wxchan's avatar
wxchan committed
416
      { "early_stopping_rounds", "early_stopping_round"},
417
      { "early_stopping", "early_stopping_round"},
Guolin Ke's avatar
Guolin Ke committed
418
419
420
421
422
423
424
425
      { "verbosity", "verbose" },
      { "header", "has_header" },
      { "label", "label_column" },
      { "weight", "weight_column" },
      { "group", "group_column" },
      { "query", "group_column" },
      { "query_column", "group_column" },
      { "ignore_feature", "ignore_column" },
Guolin Ke's avatar
Guolin Ke committed
426
      { "blacklist", "ignore_column" },
427
428
429
      { "categorical_feature", "categorical_column" },
      { "cat_column", "categorical_column" },
      { "cat_feature", "categorical_column" },
Guolin Ke's avatar
Guolin Ke committed
430
      { "predict_raw_score", "is_predict_raw_score" },
Guolin Ke's avatar
Guolin Ke committed
431
      { "predict_leaf_index", "is_predict_leaf_index" }, 
Guolin Ke's avatar
Guolin Ke committed
432
433
      { "raw_score", "is_predict_raw_score" },
      { "leaf_index", "is_predict_leaf_index" },
Guolin Ke's avatar
Guolin Ke committed
434
      { "min_split_gain", "min_gain_to_split" },
Guolin Ke's avatar
Guolin Ke committed
435
      { "topk", "top_k" },
Guolin Ke's avatar
Guolin Ke committed
436
437
      { "reg_alpha", "lambda_l1" },
      { "reg_lambda", "lambda_l2" },
438
      { "num_classes", "num_class" },
Guolin Ke's avatar
Guolin Ke committed
439
440
441
      { "unbalanced_sets", "is_unbalance" },
      { "bagging_fraction_seed", "bagging_seed" }, 
      { "num_boost_round", "num_iterations" }
Guolin Ke's avatar
Guolin Ke committed
442
    });
wxchan's avatar
wxchan committed
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
    std::unordered_set<std::string> parameter_set({
      "config", "config_file", "task", "device",
      "num_threads", "seed", "boosting_type", "objective", "data",
      "output_model", "input_model", "output_result", "valid_data",
      "is_enable_sparse", "is_pre_partition", "is_training_metric",
      "ndcg_eval_at", "min_data_in_leaf", "min_sum_hessian_in_leaf",
      "num_leaves", "feature_fraction", "num_iterations",
      "bagging_fraction", "bagging_freq", "learning_rate", "tree_learner",
      "num_machines", "local_listen_port", "use_two_round_loading",
      "machine_list_file", "is_save_binary_file", "early_stopping_round",
      "verbose", "has_header, label_column", "weight_column", "group_column",
      "ignore_column", "categorical_column", "is_predict_raw_score",
      "is_predict_leaf_index", "min_gain_to_split", "top_k",
      "lambda_l1", "lambda_l2", "num_class", "is_unbalance",
      "max_depth", "subsample_for_bin", "max_bin", "bagging_seed",
      "drop_rate", "skip_drop", "max_drop", "uniform_drop",
      "xgboost_dart_mode", "drop_seed", "top_rate", "other_rate",
      "min_data_in_bin", "data_random_seed", "bin_construct_sample_cnt",
      "num_iteration_predict", "pred_early_stop", "pred_early_stop_freq",
      "pred_early_stop_margin", "use_missing", "sigmoid", "huber_delta",
      "fair_c", "poission_max_delta_step", "scale_pos_weight",
      "boost_from_average", "max_position", "label_gain",
      "metric", "metric_freq", "time_out",
      "gpu_platform_id", "gpu_device_id", "gpu_use_dp",
Guolin Ke's avatar
Guolin Ke committed
467
468
469
470
471
      "convert_model", "convert_model_language", 
      "feature_fraction_seed", "enable_bundle", "data_filename", "valid_data_filenames",
      "snapshot_freq", "verbosity", "sparse_threshold", "enable_load_from_binary_file",
      "max_conflict_rate", "poisson_max_delta_step", "gaussian_eta",
      "histogram_pool_size", "output_freq", "is_provide_training_metric", "machine_list_filename"
wxchan's avatar
wxchan committed
472
    });
Guolin Ke's avatar
Guolin Ke committed
473
474
475
476
    std::unordered_map<std::string, std::string> tmp_map;
    for (const auto& pair : *params) {
      if (alias_table.count(pair.first) > 0) {
        tmp_map[alias_table[pair.first]] = pair.second;
wxchan's avatar
wxchan committed
477
478
      } else if (parameter_set.count(pair.first) == 0) {
        Log::Fatal("Unknown parameter: %s", pair.first.c_str());
Guolin Ke's avatar
Guolin Ke committed
479
480
481
482
483
484
485
486
487
488
489
490
      }
    }
    for (const auto& pair : tmp_map) {
      if (params->count(pair.first) == 0) {
        params->insert(std::make_pair(pair.first, pair.second));
      }
    }
  }
};

}   // namespace LightGBM

Guolin Ke's avatar
Guolin Ke committed
491
#endif   // LightGBM_CONFIG_H_