Refine config object (#1381)

* [WIP] refine config

* [wip] ready for the auto code generate

* auto generate config codes

* use with to open file

* fix bug

* fix pylint

* fix bug

* fix pylint

* fix bugs.

* tmp for failed test.

* fix tests.

* added nthreads alias

* added new aliases from new config.h

* fixed duplicated alias

* refactored parameter_generator.py

* added new aliases from config.h and removed remaining old names

* fix bugs & some miss alias

* added aliases

* add more descriptions.

* add comment.

src/objective/multiclass_objective.hpp

@@ -15,7 +15,7 @@ namespace LightGBM {
 */
 class MulticlassSoftmax: public ObjectiveFunction {
 public:
-  explicit MulticlassSoftmax(const ObjectiveConfig& config) {
+  explicit MulticlassSoftmax(const Config& config) {
     num_class_ = config.num_class;
   }
 
@@ -138,7 +138,7 @@ private:
 */
 class MulticlassOVA: public ObjectiveFunction {
 public:
-  explicit MulticlassOVA(const ObjectiveConfig& config) {
+  explicit MulticlassOVA(const Config& config) {
     num_class_ = config.num_class;
     for (int i = 0; i < num_class_; ++i) {
       binary_loss_.emplace_back(

src/objective/objective_function.cpp

@@ -7,7 +7,7 @@
 
 namespace LightGBM {
 
-ObjectiveFunction* ObjectiveFunction::CreateObjectiveFunction(const std::string& type, const ObjectiveConfig& config) {
+ObjectiveFunction* ObjectiveFunction::CreateObjectiveFunction(const std::string& type, const Config& config) {
   if (type == std::string("regression") || type == std::string("regression_l2")
       || type == std::string("mean_squared_error") || type == std::string("mse") 
       || type == std::string("l2_root") || type == std::string("root_mean_squared_error") || type == std::string("rmse")) {

src/objective/rank_objective.hpp

@@ -18,15 +18,12 @@ namespace LightGBM {
 */
 class LambdarankNDCG: public ObjectiveFunction {
 public:
-  explicit LambdarankNDCG(const ObjectiveConfig& config) {
+  explicit LambdarankNDCG(const Config& config) {
     sigmoid_ = static_cast<double>(config.sigmoid);
+    label_gain_ = config.label_gain;
     // initialize DCG calculator
-    DCGCalculator::Init(config.label_gain);
-    // copy lable gain to local
-    for (auto gain : config.label_gain) {
-      label_gain_.push_back(static_cast<double>(gain));
-    }
-    label_gain_.shrink_to_fit();
+    DCGCalculator::DefaultLabelGain(&label_gain_);
+    DCGCalculator::Init(label_gain_);
     // will optimize NDCG@optimize_pos_at_
     optimize_pos_at_ = config.max_position;
     sigmoid_table_.clear();

src/objective/regression_objective.hpp

@@ -63,7 +63,7 @@ namespace LightGBM {
 */
 class RegressionL2loss: public ObjectiveFunction {
 public:
-  explicit RegressionL2loss(const ObjectiveConfig& config) {
+  explicit RegressionL2loss(const Config& config) {
     sqrt_ = config.reg_sqrt;
   }
 
@@ -174,7 +174,7 @@ protected:
 */
 class RegressionL1loss: public RegressionL2loss {
 public:
-  explicit RegressionL1loss(const ObjectiveConfig& config): RegressionL2loss(config) {
+  explicit RegressionL1loss(const Config& config): RegressionL2loss(config) {
   }
 
   explicit RegressionL1loss(const std::vector<std::string>& strs): RegressionL2loss(strs) {
@@ -260,7 +260,7 @@ public:
 */
 class RegressionHuberLoss: public RegressionL2loss {
 public:
-  explicit RegressionHuberLoss(const ObjectiveConfig& config): RegressionL2loss(config) {
+  explicit RegressionHuberLoss(const Config& config): RegressionL2loss(config) {
     alpha_ = static_cast<double>(config.alpha);
   }
 
@@ -315,7 +315,7 @@ private:
 // http://research.microsoft.com/en-us/um/people/zhang/INRIA/Publis/Tutorial-Estim/node24.html
 class RegressionFairLoss: public RegressionL2loss {
 public:
-  explicit RegressionFairLoss(const ObjectiveConfig& config): RegressionL2loss(config) {
+  explicit RegressionFairLoss(const Config& config): RegressionL2loss(config) {
     c_ = static_cast<double>(config.fair_c);
   }
 
@@ -363,7 +363,7 @@ private:
 */
 class RegressionPoissonLoss: public RegressionL2loss {
 public:
-  explicit RegressionPoissonLoss(const ObjectiveConfig& config): RegressionL2loss(config) {
+  explicit RegressionPoissonLoss(const Config& config): RegressionL2loss(config) {
     max_delta_step_ = static_cast<double>(config.poisson_max_delta_step);
     if (sqrt_) {
       Log::Warning("Cannot use sqrt transform in %s Regression, will auto disable it", GetName());
@@ -444,7 +444,7 @@ private:
 
 class RegressionQuantileloss : public RegressionL2loss {
 public:
-  explicit RegressionQuantileloss(const ObjectiveConfig& config): RegressionL2loss(config) {
+  explicit RegressionQuantileloss(const Config& config): RegressionL2loss(config) {
     alpha_ = static_cast<score_t>(config.alpha);
     CHECK(alpha_ > 0 && alpha_ < 1);
   }
@@ -543,7 +543,7 @@ private:
 */
 class RegressionMAPELOSS : public RegressionL1loss {
 public:
-  explicit RegressionMAPELOSS(const ObjectiveConfig& config) : RegressionL1loss(config) {
+  explicit RegressionMAPELOSS(const Config& config) : RegressionL1loss(config) {
   }
 
   explicit RegressionMAPELOSS(const std::vector<std::string>& strs) : RegressionL1loss(strs) {
@@ -644,7 +644,7 @@ private:
 */
 class RegressionGammaLoss : public RegressionPoissonLoss {
 public:
-  explicit RegressionGammaLoss(const ObjectiveConfig& config) : RegressionPoissonLoss(config) {
+  explicit RegressionGammaLoss(const Config& config) : RegressionPoissonLoss(config) {
   }
 
   explicit RegressionGammaLoss(const std::vector<std::string>& strs) : RegressionPoissonLoss(strs) {
@@ -681,7 +681,7 @@ public:
 */
 class RegressionTweedieLoss: public RegressionPoissonLoss {
 public:
-  explicit RegressionTweedieLoss(const ObjectiveConfig& config) : RegressionPoissonLoss(config) {
+  explicit RegressionTweedieLoss(const Config& config) : RegressionPoissonLoss(config) {
     rho_ = config.tweedie_variance_power;
   }
 

src/objective/xentropy_objective.hpp

@@ -38,7 +38,7 @@ namespace LightGBM {
 */
 class CrossEntropy: public ObjectiveFunction {
 public:
-  explicit CrossEntropy(const ObjectiveConfig&) {
+  explicit CrossEntropy(const Config&) {
   }
 
   explicit CrossEntropy(const std::vector<std::string>&) {
@@ -141,7 +141,7 @@ private:
 */
 class CrossEntropyLambda: public ObjectiveFunction {
 public:
-  explicit CrossEntropyLambda(const ObjectiveConfig&) {
+  explicit CrossEntropyLambda(const Config&) {
     min_weight_ = max_weight_ = 0.0f;
   }
 

src/treelearner/data_parallel_tree_learner.cpp

@@ -8,8 +8,8 @@
 namespace LightGBM {
 
 template <typename TREELEARNER_T>
-DataParallelTreeLearner<TREELEARNER_T>::DataParallelTreeLearner(const TreeConfig* tree_config)
-  :TREELEARNER_T(tree_config) {
+DataParallelTreeLearner<TREELEARNER_T>::DataParallelTreeLearner(const Config* config)
+  :TREELEARNER_T(config) {
 }
 
 template <typename TREELEARNER_T>
@@ -37,13 +37,13 @@ void DataParallelTreeLearner<TREELEARNER_T>::Init(const Dataset* train_data, boo
 
   buffer_write_start_pos_.resize(this->num_features_);
   buffer_read_start_pos_.resize(this->num_features_);
-  global_data_count_in_leaf_.resize(this->tree_config_->num_leaves);
+  global_data_count_in_leaf_.resize(this->config_->num_leaves);
 }
 
 template <typename TREELEARNER_T>
-void DataParallelTreeLearner<TREELEARNER_T>::ResetConfig(const TreeConfig* tree_config) {
-  TREELEARNER_T::ResetConfig(tree_config);
-  global_data_count_in_leaf_.resize(this->tree_config_->num_leaves);
+void DataParallelTreeLearner<TREELEARNER_T>::ResetConfig(const Config* config) {
+  TREELEARNER_T::ResetConfig(config);
+  global_data_count_in_leaf_.resize(this->config_->num_leaves);
 }
 
 template <typename TREELEARNER_T>
@@ -236,7 +236,7 @@ void DataParallelTreeLearner<TREELEARNER_T>::FindBestSplitsFromHistograms(const
   }
 
   // sync global best info
-  SyncUpGlobalBestSplit(input_buffer_.data(), input_buffer_.data(), &smaller_best_split, &larger_best_split, this->tree_config_->max_cat_threshold);
+  SyncUpGlobalBestSplit(input_buffer_.data(), input_buffer_.data(), &smaller_best_split, &larger_best_split, this->config_->max_cat_threshold);
 
   // set best split
   this->best_split_per_leaf_[this->smaller_leaf_splits_->LeafIndex()] = smaller_best_split;

src/treelearner/feature_parallel_tree_learner.cpp

@@ -8,8 +8,8 @@ namespace LightGBM {
 
 
 template <typename TREELEARNER_T>
-FeatureParallelTreeLearner<TREELEARNER_T>::FeatureParallelTreeLearner(const TreeConfig* tree_config)
-  :TREELEARNER_T(tree_config) {
+FeatureParallelTreeLearner<TREELEARNER_T>::FeatureParallelTreeLearner(const Config* config)
+  :TREELEARNER_T(config) {
 }
 
 template <typename TREELEARNER_T>
@@ -22,8 +22,8 @@ void FeatureParallelTreeLearner<TREELEARNER_T>::Init(const Dataset* train_data,
   TREELEARNER_T::Init(train_data, is_constant_hessian);
   rank_ = Network::rank();
   num_machines_ = Network::num_machines();
-  input_buffer_.resize((sizeof(SplitInfo) + sizeof(uint32_t) * this->tree_config_->max_cat_threshold) * 2);
-  output_buffer_.resize((sizeof(SplitInfo) + sizeof(uint32_t) * this->tree_config_->max_cat_threshold) * 2);
+  input_buffer_.resize((sizeof(SplitInfo) + sizeof(uint32_t) * this->config_->max_cat_threshold) * 2);
+  output_buffer_.resize((sizeof(SplitInfo) + sizeof(uint32_t) * this->config_->max_cat_threshold) * 2);
 }
 
 
@@ -60,7 +60,7 @@ void FeatureParallelTreeLearner<TREELEARNER_T>::FindBestSplitsFromHistograms(con
     larger_best_split = this->best_split_per_leaf_[this->larger_leaf_splits_->LeafIndex()];
   }
   // sync global best info
-  SyncUpGlobalBestSplit(input_buffer_.data(), input_buffer_.data(), &smaller_best_split, &larger_best_split, this->tree_config_->max_cat_threshold);
+  SyncUpGlobalBestSplit(input_buffer_.data(), input_buffer_.data(), &smaller_best_split, &larger_best_split, this->config_->max_cat_threshold);
   // update best split
   this->best_split_per_leaf_[this->smaller_leaf_splits_->LeafIndex()] = smaller_best_split;
   if (this->larger_leaf_splits_->LeafIndex() >= 0) {

src/treelearner/gpu_tree_learner.cpp

@@ -15,8 +15,8 @@
 
 namespace LightGBM {
 
-GPUTreeLearner::GPUTreeLearner(const TreeConfig* tree_config)
-  :SerialTreeLearner(tree_config) {
+GPUTreeLearner::GPUTreeLearner(const Config* config)
+  :SerialTreeLearner(config) {
   use_bagging_ = false;
   Log::Info("This is the GPU trainer!!");
 }
@@ -39,7 +39,7 @@ void GPUTreeLearner::Init(const Dataset* train_data, bool is_constant_hessian) {
   // some additional variables needed for GPU trainer
   num_feature_groups_ = train_data_->num_feature_groups();
   // Initialize GPU buffers and kernels
-  InitGPU(tree_config_->gpu_platform_id, tree_config_->gpu_device_id);
+  InitGPU(config_->gpu_platform_id, config_->gpu_device_id);
 }
 
 // some functions used for debugging the GPU histogram construction
@@ -304,7 +304,7 @@ void GPUTreeLearner::AllocateGPUMemory() {
   device_data_indices_ = std::unique_ptr<boost::compute::vector<data_size_t>>(new boost::compute::vector<data_size_t>(allocated_num_data_, ctx_));
   boost::compute::fill(device_data_indices_->begin(), device_data_indices_->end(), 0, queue_);
   // histogram bin entry size depends on the precision (single/double)
-  hist_bin_entry_sz_ = tree_config_->gpu_use_dp ? sizeof(HistogramBinEntry) : sizeof(GPUHistogramBinEntry);
+  hist_bin_entry_sz_ = config_->gpu_use_dp ? sizeof(HistogramBinEntry) : sizeof(GPUHistogramBinEntry);
   Log::Info("Size of histogram bin entry: %d", hist_bin_entry_sz_);
   // create output buffer, each feature has a histogram with device_bin_size_ bins,
   // each work group generates a sub-histogram of dword_features_ features.
@@ -598,7 +598,7 @@ void GPUTreeLearner::BuildGPUKernels() {
     std::ostringstream opts;
     // compile the GPU kernel depending if double precision is used, constant hessian is used, etc 
     opts << " -D POWER_FEATURE_WORKGROUPS=" << i
-         << " -D USE_CONSTANT_BUF=" << use_constants << " -D USE_DP_FLOAT=" << int(tree_config_->gpu_use_dp)
+         << " -D USE_CONSTANT_BUF=" << use_constants << " -D USE_DP_FLOAT=" << int(config_->gpu_use_dp)
          << " -D CONST_HESSIAN=" << int(is_constant_hessian_)
          << " -cl-mad-enable -cl-no-signed-zeros -cl-fast-relaxed-math";
     #if GPU_DEBUG >= 1
@@ -1006,7 +1006,7 @@ void GPUTreeLearner::ConstructHistograms(const std::vector<int8_t>& is_feature_u
     ptr_smaller_leaf_hist_data);
   // wait for GPU to finish, only if GPU is actually used
   if (is_gpu_used) {
-    if (tree_config_->gpu_use_dp) {
+    if (config_->gpu_use_dp) {
       // use double precision
       WaitAndGetHistograms<HistogramBinEntry>(ptr_smaller_leaf_hist_data);
     }
@@ -1060,7 +1060,7 @@ void GPUTreeLearner::ConstructHistograms(const std::vector<int8_t>& is_feature_u
       ptr_larger_leaf_hist_data);
     // wait for GPU to finish, only if GPU is actually used
     if (is_gpu_used) {
-      if (tree_config_->gpu_use_dp) {
+      if (config_->gpu_use_dp) {
         // use double precision
         WaitAndGetHistograms<HistogramBinEntry>(ptr_larger_leaf_hist_data);
       }

src/treelearner/gpu_tree_learner.h

@@ -37,7 +37,7 @@ namespace LightGBM {
 */
 class GPUTreeLearner: public SerialTreeLearner {
 public:
-  explicit GPUTreeLearner(const TreeConfig* tree_config);
+  explicit GPUTreeLearner(const Config* tree_config);
   ~GPUTreeLearner();
   void Init(const Dataset* train_data, bool is_constant_hessian) override;
   void ResetTrainingData(const Dataset* train_data) override;
@@ -270,7 +270,7 @@ namespace LightGBM {
 class GPUTreeLearner: public SerialTreeLearner {
 public:
   #pragma warning(disable : 4702)
-  explicit GPUTreeLearner(const TreeConfig* tree_config) : SerialTreeLearner(tree_config) {
+  explicit GPUTreeLearner(const Config* tree_config) : SerialTreeLearner(tree_config) {
     Log::Fatal("GPU Tree Learner was not enabled in this build.\n"
                "Please recompile with CMake option -DUSE_GPU=1");
   }

src/treelearner/parallel_tree_learner.h

@@ -22,7 +22,7 @@ namespace LightGBM {
 template <typename TREELEARNER_T>
 class FeatureParallelTreeLearner: public TREELEARNER_T {
 public:
-  explicit FeatureParallelTreeLearner(const TreeConfig* tree_config);
+  explicit FeatureParallelTreeLearner(const Config* config);
   ~FeatureParallelTreeLearner();
   void Init(const Dataset* train_data, bool is_constant_hessian) override;
 
@@ -48,10 +48,10 @@ private:
 template <typename TREELEARNER_T>
 class DataParallelTreeLearner: public TREELEARNER_T {
 public:
-  explicit DataParallelTreeLearner(const TreeConfig* tree_config);
+  explicit DataParallelTreeLearner(const Config* config);
   ~DataParallelTreeLearner();
   void Init(const Dataset* train_data, bool is_constant_hessian) override;
-  void ResetConfig(const TreeConfig* tree_config) override;
+  void ResetConfig(const Config* config) override;
 protected:
   void BeforeTrain() override;
   void FindBestSplits() override;
@@ -101,10 +101,10 @@ private:
 template <typename TREELEARNER_T>
 class VotingParallelTreeLearner: public TREELEARNER_T {
 public:
-  explicit VotingParallelTreeLearner(const TreeConfig* tree_config);
+  explicit VotingParallelTreeLearner(const Config* config);
   ~VotingParallelTreeLearner() { }
   void Init(const Dataset* train_data, bool is_constant_hessian) override;
-  void ResetConfig(const TreeConfig* tree_config) override;
+  void ResetConfig(const Config* config) override;
 protected:
   void BeforeTrain() override;
   bool BeforeFindBestSplit(const Tree* tree, int left_leaf, int right_leaf) override;
@@ -137,7 +137,7 @@ protected:
 
 private:
   /*! \brief Tree config used in local mode */
-  TreeConfig local_tree_config_;
+  Config local_config_;
   /*! \brief Voting size */
   int top_k_;
   /*! \brief Rank of local machine*/

windows/LightGBM.vcxproj

@@ -257,6 +257,7 @@
     <ClCompile Include="..\src\c_api.cpp" />
     <ClCompile Include="..\src\io\bin.cpp" />
     <ClCompile Include="..\src\io\config.cpp" />
+    <ClCompile Include="..\src\io\config_auto.cpp" />
     <ClCompile Include="..\src\io\dataset.cpp" />
     <ClCompile Include="..\src\io\dataset_loader.cpp" />
     <ClCompile Include="..\src\io\file_io.cpp" />