config.h 13.2 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
8
#include <LightGBM/meta.h>

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

namespace LightGBM {

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

  /*!
Hui Xue's avatar
Hui Xue committed
26
  * \brief Set current config object by params
Guolin Ke's avatar
Guolin Ke committed
27
28
29
30
31
32
33
34
35
  * \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
36
  * \param out Value will assign to out if key exists
Guolin Ke's avatar
Guolin Ke committed
37
38
39
40
41
42
43
44
45
46
  * \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
47
  * \param out Value will assign to out if key exists
Guolin Ke's avatar
Guolin Ke committed
48
49
50
51
52
53
54
  * \return True if key exists
  */
  inline bool GetInt(
    const std::unordered_map<std::string, std::string>& params,
    const std::string& name, int* out);

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

  /*!
  * \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
69
  * \param out Value will assign to out if key exists
Guolin Ke's avatar
Guolin Ke committed
70
71
72
73
74
  * \return True if key exists
  */
  inline bool GetBool(
    const std::unordered_map<std::string, std::string>& params,
    const std::string& name, bool* out);
75
76

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

/*! \brief Types of boosting */
enum BoostingType {
81
  kGBDT, kDART, kUnknow
Guolin Ke's avatar
Guolin Ke committed
82
83
84
85
86
87
88
89
90
91
92
};


/*! \brief Types of tasks */
enum TaskType {
  kTrain, kPredict
};

/*! \brief Config for input and output files */
struct IOConfig: public ConfigBase {
public:
93
  int max_bin = 256;
94
  int num_class = 1;
Guolin Ke's avatar
Guolin Ke committed
95
96
97
98
99
100
  int data_random_seed = 1;
  std::string data_filename = "";
  std::vector<std::string> valid_data_filenames;
  std::string output_model = "LightGBM_model.txt";
  std::string output_result = "LightGBM_predict_result.txt";
  std::string input_model = "";
Guolin Ke's avatar
Guolin Ke committed
101
  int verbosity = 1;
102
  int num_iteration_predict = -1;
Guolin Ke's avatar
Guolin Ke committed
103
104
105
106
  bool is_pre_partition = false;
  bool is_enable_sparse = true;
  bool use_two_round_loading = false;
  bool is_save_binary_file = false;
Guolin Ke's avatar
Guolin Ke committed
107
108
  bool enable_load_from_binary_file = true;
  int bin_construct_sample_cnt = 50000;
Guolin Ke's avatar
Guolin Ke committed
109
110
  bool is_predict_leaf_index = false;
  bool is_predict_raw_score = false;
Guolin Ke's avatar
Guolin Ke committed
111
112
113
114
115
116

  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
117
118
  * And add an prefix "name:" while using column name 
  * Note: when using Index, it dosen't count the label index */
Guolin Ke's avatar
Guolin Ke committed
119
  std::string weight_column = "";
Guolin Ke's avatar
Guolin Ke committed
120
121
122
  /*! \brief Index or column name of group/query id, < 0 means not used
  * And add an prefix "name:" while using column name
  * Note: when using Index, it dosen't count the label index */
Guolin Ke's avatar
Guolin Ke committed
123
124
  std::string group_column = "";
  /*! \brief ignored features, separate by ','
Guolin Ke's avatar
Guolin Ke committed
125
126
  * And add an prefix "name:" while using column name
  * Note: when using Index, it dosen't count the label index */
Guolin Ke's avatar
Guolin Ke committed
127
  std::string ignore_column = "";
Guolin Ke's avatar
Guolin Ke committed
128
129
130
131
  /*! \brief specific categorical columns, Note:only support for integer type categorical
  * And add an prefix "name:" while using column name
  * Note: when using Index, it dosen't count the label index */
  std::string categorical_column = "";
Guolin Ke's avatar
Guolin Ke committed
132
133
134
135
136
137
138
  void Set(const std::unordered_map<std::string, std::string>& params) override;
};

/*! \brief Config for objective function */
struct ObjectiveConfig: public ConfigBase {
public:
  virtual ~ObjectiveConfig() {}
139
  double sigmoid = 1.0f;
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
140
  double huber_delta = 1.0f;
Guolin Ke's avatar
Guolin Ke committed
141
  // for lambdarank
142
  std::vector<double> label_gain;
Guolin Ke's avatar
Guolin Ke committed
143
144
145
146
  // for lambdarank
  int max_position = 20;
  // for binary
  bool is_unbalance = false;
147
148
  // for multiclass
  int num_class = 1;
Guolin Ke's avatar
Guolin Ke committed
149
150
  // Balancing of positive and negative weights
  double scale_pos_weight = 1.0f;
Guolin Ke's avatar
Guolin Ke committed
151
152
153
154
155
156
157
  void Set(const std::unordered_map<std::string, std::string>& params) override;
};

/*! \brief Config for metrics interface*/
struct MetricConfig: public ConfigBase {
public:
  virtual ~MetricConfig() {}
158
  int num_class = 1;
159
  double sigmoid = 1.0f;
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
160
  double huber_delta = 1.0f;
161
  std::vector<double> label_gain;
Guolin Ke's avatar
Guolin Ke committed
162
163
164
165
166
167
168
169
170
  std::vector<int> eval_at;
  void Set(const std::unordered_map<std::string, std::string>& params) override;
};


/*! \brief Config for tree model */
struct TreeConfig: public ConfigBase {
public:
  int min_data_in_leaf = 100;
171
  double min_sum_hessian_in_leaf = 10.0f;
172
173
174
  double lambda_l1 = 0.0f;
  double lambda_l2 = 0.0f;
  double min_gain_to_split = 0.0f;
Guolin Ke's avatar
Guolin Ke committed
175
  // should > 1, only one leaf means not need to learning
Guolin Ke's avatar
Guolin Ke committed
176
177
  int num_leaves = 127;
  int feature_fraction_seed = 2;
178
  double feature_fraction = 1.0f;
Guolin Ke's avatar
Guolin Ke committed
179
  // max cache size(unit:MB) for historical histogram. < 0 means not limit
180
  double histogram_pool_size = -1.0f;
181
  // max depth of tree model.
Guolin Ke's avatar
Guolin Ke committed
182
  // Still grow tree by leaf-wise, but limit the max depth to avoid over-fitting
183
  // And the max leaves will be min(num_leaves, pow(2, max_depth - 1))
Guolin Ke's avatar
Guolin Ke committed
184
  // max_depth < 0 means not limit
185
  int max_depth = -1;
Guolin Ke's avatar
Guolin Ke committed
186
  int top_k = 20;
Guolin Ke's avatar
Guolin Ke committed
187
188
189
190
191
192
193
  void Set(const std::unordered_map<std::string, std::string>& params) override;
};

/*! \brief Config for Boosting */
struct BoostingConfig: public ConfigBase {
public:
  virtual ~BoostingConfig() {}
Guolin Ke's avatar
Guolin Ke committed
194
  double sigmoid = 1.0f;
195
196
  int output_freq = 1;
  bool is_provide_training_metric = false;
Guolin Ke's avatar
Guolin Ke committed
197
  int num_iterations = 10;
198
199
  double learning_rate = 0.1f;
  double bagging_fraction = 1.0f;
Guolin Ke's avatar
Guolin Ke committed
200
201
  int bagging_seed = 3;
  int bagging_freq = 0;
wxchan's avatar
wxchan committed
202
  int early_stopping_round = 0;
203
  int num_class = 1;
204
205
206
207
208
  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
209
  int drop_seed = 4;
210
  std::string tree_learner_type = "serial";
Guolin Ke's avatar
Guolin Ke committed
211
212
213
214
  TreeConfig tree_config;
  void Set(const std::unordered_map<std::string, std::string>& params) override;
private:
  void GetTreeLearnerType(const std::unordered_map<std::string,
Guolin Ke's avatar
Guolin Ke committed
215
    std::string>& params);
Guolin Ke's avatar
Guolin Ke committed
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
};

/*! \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 = "";
  void Set(const std::unordered_map<std::string, std::string>& params) override;
};


/*! \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
234
  int seed = 0;
Guolin Ke's avatar
Guolin Ke committed
235
236
237
238
239
  int num_threads = 0;
  bool is_parallel = false;
  bool is_parallel_find_bin = false;
  IOConfig io_config;
  BoostingType boosting_type = BoostingType::kGBDT;
Guolin Ke's avatar
Guolin Ke committed
240
  BoostingConfig boosting_config;
Guolin Ke's avatar
Guolin Ke committed
241
242
243
244
  std::string objective_type = "regression";
  ObjectiveConfig objective_config;
  std::vector<std::string> metric_types;
  MetricConfig metric_config;
Guolin Ke's avatar
Guolin Ke committed
245

Guolin Ke's avatar
Guolin Ke committed
246
  void Set(const std::unordered_map<std::string, std::string>& params) override;
247

Guolin Ke's avatar
Guolin Ke committed
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
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) {
275
    if (!Common::AtoiAndCheck(params.at(name).c_str(), out)) {
276
      Log::Fatal("Parameter %s should be of type int, got [%s]",
277
278
        name.c_str(), params.at(name).c_str());
    }
Guolin Ke's avatar
Guolin Ke committed
279
280
281
282
283
    return true;
  }
  return false;
}

284
inline bool ConfigBase::GetDouble(
Guolin Ke's avatar
Guolin Ke committed
285
  const std::unordered_map<std::string, std::string>& params,
286
  const std::string& name, double* out) {
Guolin Ke's avatar
Guolin Ke committed
287
  if (params.count(name) > 0) {
288
    if (!Common::AtofAndCheck(params.at(name).c_str(), out)) {
289
      Log::Fatal("Parameter %s should be of type double, got [%s]",
290
291
        name.c_str(), params.at(name).c_str());
    }
Guolin Ke's avatar
Guolin Ke committed
292
293
294
295
296
297
298
299
300
301
    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
302
    std::transform(value.begin(), value.end(), value.begin(), Common::tolower);
303
    if (value == std::string("false") || value == std::string("-")) {
Guolin Ke's avatar
Guolin Ke committed
304
      *out = false;
305
    } else if (value == std::string("true") || value == std::string("+")) {
Guolin Ke's avatar
Guolin Ke committed
306
      *out = true;
307
    } else {
308
      Log::Fatal("Parameter %s should be \"true\"/\"+\" or \"false\"/\"-\", got [%s]",
309
        name.c_str(), params.at(name).c_str());
Guolin Ke's avatar
Guolin Ke committed
310
311
312
313
314
315
316
317
318
319
320
321
    }
    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
322
      { "random_seed", "seed" },
Guolin Ke's avatar
Guolin Ke committed
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
      { "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" },
      { "tranining_metric", "is_training_metric" },
      { "train_metric", "is_training_metric" },
      { "ndcg_at", "ndcg_eval_at" },
      { "min_data_per_leaf", "min_data_in_leaf" },
      { "min_data", "min_data_in_leaf" },
Guolin Ke's avatar
Guolin Ke committed
345
      { "min_child_samples", "min_data_in_leaf" },
Guolin Ke's avatar
Guolin Ke committed
346
347
348
      { "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
349
      { "min_child_weight", "min_sum_hessian_in_leaf" },
Guolin Ke's avatar
Guolin Ke committed
350
351
      { "num_leaf", "num_leaves" },
      { "sub_feature", "feature_fraction" },
Guolin Ke's avatar
Guolin Ke committed
352
      { "colsample_bytree", "feature_fraction" },
Guolin Ke's avatar
Guolin Ke committed
353
354
355
356
357
358
      { "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
359
360
      { "subsample", "bagging_fraction" },
      { "subsample_freq", "bagging_freq" },
Guolin Ke's avatar
Guolin Ke committed
361
362
363
364
365
366
367
368
      { "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
369
      { "save_binary", "is_save_binary_file" },
wxchan's avatar
wxchan committed
370
      { "early_stopping_rounds", "early_stopping_round"},
371
      { "early_stopping", "early_stopping_round"},
Guolin Ke's avatar
Guolin Ke committed
372
373
374
375
376
377
378
379
      { "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
380
      { "blacklist", "ignore_column" },
Guolin Ke's avatar
Guolin Ke committed
381
382
383
      { "categorical_feature", "categorical_column" },
      { "cat_column", "categorical_column" },
      { "cat_feature", "categorical_column" },
Guolin Ke's avatar
Guolin Ke committed
384
      { "predict_raw_score", "is_predict_raw_score" },
Guolin Ke's avatar
Guolin Ke committed
385
      { "predict_leaf_index", "is_predict_leaf_index" }, 
Guolin Ke's avatar
Guolin Ke committed
386
387
      { "raw_score", "is_predict_raw_score" },
      { "leaf_index", "is_predict_leaf_index" },
Guolin Ke's avatar
Guolin Ke committed
388
      { "min_split_gain", "min_gain_to_split" },
Guolin Ke's avatar
Guolin Ke committed
389
      { "topk", "top_k" },
Guolin Ke's avatar
Guolin Ke committed
390
391
      { "reg_alpha", "lambda_l1" },
      { "reg_lambda", "lambda_l2" },
Guolin Ke's avatar
Guolin Ke committed
392
      { "num_classes", "num_class" }
Guolin Ke's avatar
Guolin Ke committed
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
    });
    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;
      }
    }
    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
410
#endif   // LightGBM_CONFIG_H_