config.cpp 12.3 KB
Newer Older
Guolin Ke's avatar
Guolin Ke committed
1
2
3
4
5
6
7
8
9
10
11
12
#include <LightGBM/config.h>

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

#include <vector>
#include <string>
#include <unordered_map>
#include <algorithm>

namespace LightGBM {

13
14
15
16
17
18
19
20
21
22
23
24
25
void OverallConfig::LoadFromString(const char* str) {
  std::unordered_map<std::string, std::string> params;
  auto args = Common::Split(str, " \t\n\r");
  for (auto arg : args) {
    std::vector<std::string> tmp_strs = Common::Split(arg.c_str(), '=');
    if (tmp_strs.size() == 2) {
      std::string key = Common::RemoveQuotationSymbol(Common::Trim(tmp_strs[0]));
      std::string value = Common::RemoveQuotationSymbol(Common::Trim(tmp_strs[1]));
      if (key.size() <= 0) {
        continue;
      }
      params[key] = value;
    } else {
Qiwei Ye's avatar
Qiwei Ye committed
26
      Log::Warning("Unknown parameter %s", arg.c_str());
27
28
29
30
31
32
    }
  }
  ParameterAlias::KeyAliasTransform(&params);
  Set(params);
}

Guolin Ke's avatar
Guolin Ke committed
33
34
35
36
37
38
39
40
41
void OverallConfig::Set(const std::unordered_map<std::string, std::string>& params) {
  // load main config types
  GetInt(params, "num_threads", &num_threads);
  GetTaskType(params);
  GetBoostingType(params);
  GetObjectiveType(params);
  GetMetricType(params);

  // construct boosting configs
42
  if (boosting_type == BoostingType::kGBDT || boosting_type == BoostingType::kDART) {
Guolin Ke's avatar
Guolin Ke committed
43
44
45
46
47
48
49
50
51
52
53
54
    boosting_config = new GBDTConfig();
  }

  // sub-config setup
  network_config.Set(params);
  io_config.Set(params);

  boosting_config->Set(params);
  objective_config.Set(params);
  metric_config.Set(params);
  // check for conflicts
  CheckParamConflict();
Qiwei Ye's avatar
Qiwei Ye committed
55

Guolin Ke's avatar
Guolin Ke committed
56
  if (io_config.verbosity == 1) {
Qiwei Ye's avatar
Qiwei Ye committed
57
    LightGBM::Log::ResetLogLevel(LightGBM::LogLevel::Info);
Guolin Ke's avatar
Guolin Ke committed
58
59
  }
  else if (io_config.verbosity == 0) {
Qiwei Ye's avatar
Qiwei Ye committed
60
    LightGBM::Log::ResetLogLevel(LightGBM::LogLevel::Warning);
Guolin Ke's avatar
Guolin Ke committed
61
62
  }
  else if (io_config.verbosity >= 2) {
Qiwei Ye's avatar
Qiwei Ye committed
63
    LightGBM::Log::ResetLogLevel(LightGBM::LogLevel::Debug);
Guolin Ke's avatar
Guolin Ke committed
64
65
  }
  else {
Qiwei Ye's avatar
Qiwei Ye committed
66
    LightGBM::Log::ResetLogLevel(LightGBM::LogLevel::Fatal);
Guolin Ke's avatar
Guolin Ke committed
67
  }
Guolin Ke's avatar
Guolin Ke committed
68
69
70
71
72
73
74
75
}

void OverallConfig::GetBoostingType(const std::unordered_map<std::string, std::string>& params) {
  std::string value;
  if (GetString(params, "boosting_type", &value)) {
    std::transform(value.begin(), value.end(), value.begin(), ::tolower);
    if (value == std::string("gbdt") || value == std::string("gbrt")) {
      boosting_type = BoostingType::kGBDT;
76
77
    } else if (value == std::string("dart")) {
      boosting_type = BoostingType::kDART;
Guolin Ke's avatar
Guolin Ke committed
78
    } else {
79
      Log::Fatal("Unknown boosting type %s", value.c_str());
Guolin Ke's avatar
Guolin Ke committed
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
    }
  }
}

void OverallConfig::GetObjectiveType(const std::unordered_map<std::string, std::string>& params) {
  std::string value;
  if (GetString(params, "objective", &value)) {
    std::transform(value.begin(), value.end(), value.begin(), ::tolower);
    objective_type = value;
  }
}

void OverallConfig::GetMetricType(const std::unordered_map<std::string, std::string>& params) {
  std::string value;
  if (GetString(params, "metric", &value)) {
    // clear old metrics
    metric_types.clear();
    // to lower
    std::transform(value.begin(), value.end(), value.begin(), ::tolower);
    // split
    std::vector<std::string> metrics = Common::Split(value.c_str(), ',');
    // remove dumplicate
    std::unordered_map<std::string, int> metric_maps;
    for (auto& metric : metrics) {
      std::transform(metric.begin(), metric.end(), metric.begin(), ::tolower);
      if (metric_maps.count(metric) <= 0) {
        metric_maps[metric] = 1;
      }
    }
    for (auto& pair : metric_maps) {
      std::string sub_metric_str = pair.first;
      metric_types.push_back(sub_metric_str);
    }
  }
}


void OverallConfig::GetTaskType(const std::unordered_map<std::string, std::string>& params) {
  std::string value;
  if (GetString(params, "task", &value)) {
    std::transform(value.begin(), value.end(), value.begin(), ::tolower);
    if (value == std::string("train") || value == std::string("training")) {
      task_type = TaskType::kTrain;
    } else if (value == std::string("predict") || value == std::string("prediction")
      || value == std::string("test")) {
      task_type = TaskType::kPredict;
    } else {
127
      Log::Fatal("Unknown task type %s", value.c_str());
Guolin Ke's avatar
Guolin Ke committed
128
129
130
131
132
    }
  }
}

void OverallConfig::CheckParamConflict() {
133
134
  GBDTConfig* gbdt_config = dynamic_cast<GBDTConfig*>(boosting_config);

135
136
137
138
139
  // check if objective_type, metric_type, and num_class match
  bool objective_type_multiclass = (objective_type == std::string("multiclass"));
  int num_class_check = gbdt_config->num_class;
  if (objective_type_multiclass){
      if (num_class_check <= 1){
140
          Log::Fatal("Number of classes should be specified and greater than 1 for multiclass training");
141
142
143
144
      }
  }
  else {
      if (task_type == TaskType::kTrain && num_class_check != 1){
145
146
          Log::Fatal("Number of classes must be 1 for non-multiclass training");
      }
147
148
149
  }
  for (std::string metric_type : metric_types){
        bool metric_type_multiclass = ( metric_type == std::string("multi_logloss") || metric_type == std::string("multi_error"));
150
        if ((objective_type_multiclass && !metric_type_multiclass)
151
            || (!objective_type_multiclass && metric_type_multiclass)){
152
            Log::Fatal("Objective and metrics don't match");
153
        }
154
  }
155

Guolin Ke's avatar
Guolin Ke committed
156
157
158
159
  if (network_config.num_machines > 1) {
    is_parallel = true;
  } else {
    is_parallel = false;
160
    gbdt_config->tree_learner_type = TreeLearnerType::kSerialTreeLearner;
Guolin Ke's avatar
Guolin Ke committed
161
162
  }

163
  if (gbdt_config->tree_learner_type == TreeLearnerType::kSerialTreeLearner) {
Guolin Ke's avatar
Guolin Ke committed
164
165
166
167
    is_parallel = false;
    network_config.num_machines = 1;
  }

168
169
  if (gbdt_config->tree_learner_type == TreeLearnerType::kSerialTreeLearner ||
    gbdt_config->tree_learner_type == TreeLearnerType::kFeatureParallelTreelearner) {
Guolin Ke's avatar
Guolin Ke committed
170
    is_parallel_find_bin = false;
171
  } else if (gbdt_config->tree_learner_type == TreeLearnerType::kDataParallelTreeLearner) {
Guolin Ke's avatar
Guolin Ke committed
172
    is_parallel_find_bin = true;
173
    if (gbdt_config->tree_config.histogram_pool_size >= 0) {
174
      Log::Warning("Histogram LRU queue was enabled (histogram_pool_size=%f). Will disable this to reduce communication costs"
Guolin Ke's avatar
Guolin Ke committed
175
                 , gbdt_config->tree_config.histogram_pool_size);
176
      // Change pool size to -1 (not limit) when using data parallel to reduce communication costs
177
178
179
      gbdt_config->tree_config.histogram_pool_size = -1;
    }

Guolin Ke's avatar
Guolin Ke committed
180
181
182
183
184
185
  }
}

void IOConfig::Set(const std::unordered_map<std::string, std::string>& params) {
  GetInt(params, "max_bin", &max_bin);
  CHECK(max_bin > 0);
186
  GetInt(params, "num_class", &num_class);
Guolin Ke's avatar
Guolin Ke committed
187
  GetInt(params, "data_random_seed", &data_random_seed);
188
  GetString(params, "data", &data_filename);
Qiwei Ye's avatar
Qiwei Ye committed
189
  GetInt(params, "verbose", &verbosity);
Guolin Ke's avatar
Guolin Ke committed
190
  GetInt(params, "num_model_predict", &num_model_predict);
Guolin Ke's avatar
Guolin Ke committed
191
  GetInt(params, "bin_construct_sample_cnt", &bin_construct_sample_cnt);
Guolin Ke's avatar
Guolin Ke committed
192
193
194
195
  GetBool(params, "is_pre_partition", &is_pre_partition);
  GetBool(params, "is_enable_sparse", &is_enable_sparse);
  GetBool(params, "use_two_round_loading", &use_two_round_loading);
  GetBool(params, "is_save_binary_file", &is_save_binary_file);
Guolin Ke's avatar
Guolin Ke committed
196
  GetBool(params, "enable_load_from_binary_file", &enable_load_from_binary_file);
Guolin Ke's avatar
Guolin Ke committed
197
198
  GetBool(params, "is_predict_raw_score", &is_predict_raw_score);
  GetBool(params, "is_predict_leaf_index", &is_predict_leaf_index);
Guolin Ke's avatar
Guolin Ke committed
199
200
201
202
203
204
205
  GetString(params, "output_model", &output_model);
  GetString(params, "input_model", &input_model);
  GetString(params, "output_result", &output_result);
  std::string tmp_str = "";
  if (GetString(params, "valid_data", &tmp_str)) {
    valid_data_filenames = Common::Split(tmp_str.c_str(), ',');
  }
Guolin Ke's avatar
Guolin Ke committed
206
207
208
209
210
  GetBool(params, "has_header", &has_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);
Guolin Ke's avatar
Guolin Ke committed
211
212
213
214
215
}


void ObjectiveConfig::Set(const std::unordered_map<std::string, std::string>& params) {
  GetBool(params, "is_unbalance", &is_unbalance);
216
  GetDouble(params, "sigmoid", &sigmoid);
Guolin Ke's avatar
Guolin Ke committed
217
218
  GetInt(params, "max_position", &max_position);
  CHECK(max_position > 0);
219
220
  GetInt(params, "num_class", &num_class);
  CHECK(num_class >= 1);
Guolin Ke's avatar
Guolin Ke committed
221
222
  std::string tmp_str = "";
  if (GetString(params, "label_gain", &tmp_str)) {
223
    label_gain = Common::StringToDoubleArray(tmp_str, ',');
Guolin Ke's avatar
Guolin Ke committed
224
225
226
  } else {
    // label_gain = 2^i - 1, may overflow, so we use 31 here
    const int max_label = 31;
227
    label_gain.push_back(0.0f);
Guolin Ke's avatar
Guolin Ke committed
228
    for (int i = 1; i < max_label; ++i) {
229
      label_gain.push_back(static_cast<double>((1 << i) - 1));
Guolin Ke's avatar
Guolin Ke committed
230
231
232
233
234
235
    }
  }
}


void MetricConfig::Set(const std::unordered_map<std::string, std::string>& params) {
236
  GetDouble(params, "sigmoid", &sigmoid);
237
  GetInt(params, "num_class", &num_class);
Guolin Ke's avatar
Guolin Ke committed
238
239
  std::string tmp_str = "";
  if (GetString(params, "label_gain", &tmp_str)) {
240
    label_gain = Common::StringToDoubleArray(tmp_str, ',');
Guolin Ke's avatar
Guolin Ke committed
241
242
243
  } else {
    // label_gain = 2^i - 1, may overflow, so we use 31 here
    const int max_label = 31;
244
    label_gain.push_back(0.0f);
Guolin Ke's avatar
Guolin Ke committed
245
    for (int i = 1; i < max_label; ++i) {
246
      label_gain.push_back(static_cast<double>((1 << i) - 1));
Guolin Ke's avatar
Guolin Ke committed
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
    }
  }
  if (GetString(params, "ndcg_eval_at", &tmp_str)) {
    eval_at = Common::StringToIntArray(tmp_str, ',');
    std::sort(eval_at.begin(), eval_at.end());
    for (size_t i = 0; i < eval_at.size(); ++i) {
      CHECK(eval_at[i] > 0);
    }
  } else {
    // default eval ndcg @[1-5]
    for (int i = 1; i <= 5; ++i) {
      eval_at.push_back(i);
    }
  }
}


void TreeConfig::Set(const std::unordered_map<std::string, std::string>& params) {
  GetInt(params, "min_data_in_leaf", &min_data_in_leaf);
266
  GetDouble(params, "min_sum_hessian_in_leaf", &min_sum_hessian_in_leaf);
267
  CHECK(min_sum_hessian_in_leaf > 1.0f || min_data_in_leaf > 0);
268
269
270
271
272
273
  GetDouble(params, "lambda_l1", &lambda_l1);
  CHECK(lambda_l1 >= 0.0f)
  GetDouble(params, "lambda_l2", &lambda_l2);
  CHECK(lambda_l2 >= 0.0f)
  GetDouble(params, "min_gain_to_split", &min_gain_to_split);
  CHECK(min_gain_to_split >= 0.0f)
Guolin Ke's avatar
Guolin Ke committed
274
  GetInt(params, "num_leaves", &num_leaves);
275
  CHECK(num_leaves > 1);
Guolin Ke's avatar
Guolin Ke committed
276
  GetInt(params, "feature_fraction_seed", &feature_fraction_seed);
277
  GetDouble(params, "feature_fraction", &feature_fraction);
278
  CHECK(feature_fraction > 0.0f && feature_fraction <= 1.0f);
279
  GetDouble(params, "histogram_pool_size", &histogram_pool_size);
Guolin Ke's avatar
Guolin Ke committed
280
281
  GetInt(params, "max_depth", &max_depth);
  CHECK(max_depth > 1 || max_depth < 0);
Guolin Ke's avatar
Guolin Ke committed
282
283
284
285
286
287
288
289
290
}


void BoostingConfig::Set(const std::unordered_map<std::string, std::string>& params) {
  GetInt(params, "num_iterations", &num_iterations);
  CHECK(num_iterations >= 0);
  GetInt(params, "bagging_seed", &bagging_seed);
  GetInt(params, "bagging_freq", &bagging_freq);
  CHECK(bagging_freq >= 0);
291
  GetDouble(params, "bagging_fraction", &bagging_fraction);
292
  CHECK(bagging_fraction > 0.0f && bagging_fraction <= 1.0f);
293
  GetDouble(params, "learning_rate", &learning_rate);
294
  CHECK(learning_rate > 0.0f);
wxchan's avatar
wxchan committed
295
296
  GetInt(params, "early_stopping_round", &early_stopping_round);
  CHECK(early_stopping_round >= 0);
297
298
299
  GetInt(params, "metric_freq", &output_freq);
  CHECK(output_freq >= 0);
  GetBool(params, "is_training_metric", &is_provide_training_metric);
300
  GetInt(params, "num_class", &num_class);
Guolin Ke's avatar
Guolin Ke committed
301
  GetInt(params, "drop_seed", &drop_seed);
302
303
  GetDouble(params, "drop_rate", &drop_rate);
  CHECK(drop_rate <= 1.0 && drop_rate >= 0.0);
Guolin Ke's avatar
Guolin Ke committed
304
305
306
307
308
309
310
311
312
313
314
315
316
317
}

void GBDTConfig::GetTreeLearnerType(const std::unordered_map<std::string, std::string>& params) {
  std::string value;
  if (GetString(params, "tree_learner", &value)) {
    std::transform(value.begin(), value.end(), value.begin(), ::tolower);
    if (value == std::string("serial")) {
      tree_learner_type = TreeLearnerType::kSerialTreeLearner;
    } else if (value == std::string("feature") || value == std::string("feature_parallel")) {
      tree_learner_type = TreeLearnerType::kFeatureParallelTreelearner;
    } else if (value == std::string("data") || value == std::string("data_parallel")) {
      tree_learner_type = TreeLearnerType::kDataParallelTreeLearner;
    }
    else {
318
      Log::Fatal("Unknown tree learner type %s", value.c_str());
Guolin Ke's avatar
Guolin Ke committed
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
    }
  }
}

void GBDTConfig::Set(const std::unordered_map<std::string, std::string>& params) {
  BoostingConfig::Set(params);
  GetTreeLearnerType(params);
  tree_config.Set(params);
}

void NetworkConfig::Set(const std::unordered_map<std::string, std::string>& params) {
  GetInt(params, "num_machines", &num_machines);
  CHECK(num_machines >= 1);
  GetInt(params, "local_listen_port", &local_listen_port);
  CHECK(local_listen_port > 0);
  GetInt(params, "time_out", &time_out);
  CHECK(time_out > 0);
  GetString(params, "machine_list_file", &machine_list_filename);
}

}  // namespace LightGBM