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
81
82
83
84
85
86
};

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

/*! \brief Config for input and output files */
struct IOConfig: public ConfigBase {
public:
87
  int max_bin = 256;
88
  int num_class = 1;
Guolin Ke's avatar
Guolin Ke committed
89
90
91
92
93
94
  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
95
  int verbosity = 1;
96
  int num_iteration_predict = -1;
Guolin Ke's avatar
Guolin Ke committed
97
98
99
100
  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
101
102
  bool enable_load_from_binary_file = true;
  int bin_construct_sample_cnt = 50000;
Guolin Ke's avatar
Guolin Ke committed
103
104
  bool is_predict_leaf_index = false;
  bool is_predict_raw_score = false;
Guolin Ke's avatar
Guolin Ke committed
105
106
107
108
109
110

  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
111
112
  * 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
113
  std::string weight_column = "";
Guolin Ke's avatar
Guolin Ke committed
114
115
116
  /*! \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
117
118
  std::string group_column = "";
  /*! \brief ignored features, separate by ','
Guolin Ke's avatar
Guolin Ke committed
119
120
  * 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
121
  std::string ignore_column = "";
Guolin Ke's avatar
Guolin Ke committed
122
123
124
125
  /*! \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
126
127
128
129
130
131
132
  void Set(const std::unordered_map<std::string, std::string>& params) override;
};

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

/*! \brief Config for metrics interface*/
struct MetricConfig: public ConfigBase {
public:
  virtual ~MetricConfig() {}
155
  int num_class = 1;
156
  double sigmoid = 1.0f;
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
157
  double huber_delta = 1.0f;
Tsukasa OMOTO's avatar
Tsukasa OMOTO committed
158
  double fair_c = 1.0f;
159
  std::vector<double> label_gain;
Guolin Ke's avatar
Guolin Ke committed
160
161
162
163
164
165
166
167
168
  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;
169
  double min_sum_hessian_in_leaf = 10.0f;
170
171
172
  double lambda_l1 = 0.0f;
  double lambda_l2 = 0.0f;
  double min_gain_to_split = 0.0f;
Guolin Ke's avatar
Guolin Ke committed
173
  // should > 1, only one leaf means not need to learning
Guolin Ke's avatar
Guolin Ke committed
174
175
  int num_leaves = 127;
  int feature_fraction_seed = 2;
176
  double feature_fraction = 1.0f;
Guolin Ke's avatar
Guolin Ke committed
177
  // max cache size(unit:MB) for historical histogram. < 0 means not limit
178
  double histogram_pool_size = -1.0f;
179
  // max depth of tree model.
Guolin Ke's avatar
Guolin Ke committed
180
  // Still grow tree by leaf-wise, but limit the max depth to avoid over-fitting
181
  // And the max leaves will be min(num_leaves, pow(2, max_depth - 1))
Guolin Ke's avatar
Guolin Ke committed
182
  // max_depth < 0 means not limit
183
  int max_depth = -1;
Guolin Ke's avatar
Guolin Ke committed
184
  int top_k = 20;
Guolin Ke's avatar
Guolin Ke committed
185
186
187
188
189
190
191
  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
192
  double sigmoid = 1.0f;
193
194
  int output_freq = 1;
  bool is_provide_training_metric = false;
Guolin Ke's avatar
Guolin Ke committed
195
  int num_iterations = 10;
196
197
  double learning_rate = 0.1f;
  double bagging_fraction = 1.0f;
Guolin Ke's avatar
Guolin Ke committed
198
199
  int bagging_seed = 3;
  int bagging_freq = 0;
wxchan's avatar
wxchan committed
200
  int early_stopping_round = 0;
201
  int num_class = 1;
202
203
204
205
206
  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
207
  int drop_seed = 4;
208
  std::string tree_learner_type = "serial";
Guolin Ke's avatar
Guolin Ke committed
209
210
211
212
  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
213
    std::string>& params);
Guolin Ke's avatar
Guolin Ke committed
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
};

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

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

Guolin Ke's avatar
Guolin Ke committed
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
272
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) {
273
    if (!Common::AtoiAndCheck(params.at(name).c_str(), out)) {
274
      Log::Fatal("Parameter %s should be of type int, got [%s]",
275
276
        name.c_str(), params.at(name).c_str());
    }
Guolin Ke's avatar
Guolin Ke committed
277
278
279
280
281
    return true;
  }
  return false;
}

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