serial_tree_learner.h

#ifndef LIGHTGBM_TREELEARNER_SERIAL_TREE_LEARNER_H_
#define LIGHTGBM_TREELEARNER_SERIAL_TREE_LEARNER_H_
#include <LightGBM/tree_learner.h>
 
#include <LightGBM/utils/random.h>
#include <LightGBM/utils/array_args.h>
 
#include <LightGBM/dataset.h>
#include <LightGBM/tree.h>
 
#include "feature_histogram.hpp"
#include "split_info.hpp"
#include "data_partition.hpp"
#include "leaf_splits.hpp"
 
#include <cstdio>
#include <vector>
#include <random>
#include <cmath>
#include <memory>
#ifdef USE_GPU
// Use 4KBytes aligned allocator for ordered gradients and ordered hessians when GPU is enabled.
// This is necessary to pin the two arrays in memory and make transferring faster.
#include <boost/align/aligned_allocator.hpp>
#endif
 
using namespace json11;
 
namespace LightGBM {
 
class SerialTreeLearner: public TreeLearner {
public:
  explicit SerialTreeLearner(const Config* config);
 
  ~SerialTreeLearner();
 
  void Init(const Dataset* train_data, bool is_constant_hessian) override;
 
  void ResetTrainingData(const Dataset* train_data) override;
 
  void ResetConfig(const Config* config) override;
 
  Tree* Train(const score_t* gradients, const score_t *hessians, bool is_constant_hessian,
              Json& forced_split_json) override;
 
  Tree* FitByExistingTree(const Tree* old_tree, const score_t* gradients, const score_t* hessians) const override;
 
  Tree* FitByExistingTree(const Tree* old_tree, const std::vector<int>& leaf_pred,
                          const score_t* gradients, const score_t* hessians) override;
 
  void SetBaggingData(const data_size_t* used_indices, data_size_t num_data) override {
    data_partition_->SetUsedDataIndices(used_indices, num_data);
  }
 
  void AddPredictionToScore(const Tree* tree, double* out_score) const override {
    if (tree->num_leaves() <= 1) { return; }
    CHECK(tree->num_leaves() <= data_partition_->num_leaves());
    #pragma omp parallel for schedule(static)
    for (int i = 0; i < tree->num_leaves(); ++i) {
      double output = static_cast<double>(tree->LeafOutput(i));
      data_size_t cnt_leaf_data = 0;
      auto tmp_idx = data_partition_->GetIndexOnLeaf(i, &cnt_leaf_data);
      for (data_size_t j = 0; j < cnt_leaf_data; ++j) {
        out_score[tmp_idx[j]] += output;
      }
    }
  }
 
  void RenewTreeOutput(Tree* tree, const ObjectiveFunction* obj, const double* prediction,
                       data_size_t total_num_data, const data_size_t* bag_indices, data_size_t bag_cnt) const override;
 
  void RenewTreeOutput(Tree* tree, const ObjectiveFunction* obj, double prediction,
                       data_size_t total_num_data, const data_size_t* bag_indices, data_size_t bag_cnt) const override;
 
protected:
  virtual void BeforeTrain();
 
  virtual bool BeforeFindBestSplit(const Tree* tree, int left_leaf, int right_leaf);
 
  virtual void FindBestSplits();
 
  virtual void ConstructHistograms(const std::vector<int8_t>& is_feature_used, bool use_subtract);
 
  virtual void FindBestSplitsFromHistograms(const std::vector<int8_t>& is_feature_used, bool use_subtract);
 
  virtual void Split(Tree* tree, int best_leaf, int* left_leaf, int* right_leaf);
 
  /* Force splits with forced_split_json dict and then return num splits forced.*/
  virtual int32_t ForceSplits(Tree* tree, Json& forced_split_json, int* left_leaf,
                              int* right_leaf, int* cur_depth,
                              bool *aborted_last_force_split);
 
  inline virtual data_size_t GetGlobalDataCountInLeaf(int leaf_idx) const;
  data_size_t num_data_;
  int num_features_;
  const Dataset* train_data_;
  const score_t* gradients_;
  const score_t* hessians_;
  std::unique_ptr<DataPartition> data_partition_;
  Random random_;
  std::vector<int8_t> is_feature_used_;
  FeatureHistogram* parent_leaf_histogram_array_;
  FeatureHistogram* smaller_leaf_histogram_array_;
  FeatureHistogram* larger_leaf_histogram_array_;
 
  std::vector<SplitInfo> best_split_per_leaf_;
 
  std::unique_ptr<LeafSplits> smaller_leaf_splits_;
  std::unique_ptr<LeafSplits> larger_leaf_splits_;
  std::vector<int> valid_feature_indices_;
 
#ifdef USE_GPU
  std::vector<score_t, boost::alignment::aligned_allocator<score_t, 4096>> ordered_gradients_;
  std::vector<score_t, boost::alignment::aligned_allocator<score_t, 4096>> ordered_hessians_;
#else
  std::vector<score_t> ordered_gradients_;
  std::vector<score_t> ordered_hessians_;
#endif
 
  std::vector<std::unique_ptr<OrderedBin>> ordered_bins_;
  bool has_ordered_bin_ = false;
  std::vector<char> is_data_in_leaf_;
  HistogramPool histogram_pool_;
  const Config* config_;
  int num_threads_;
  std::vector<int> ordered_bin_indices_;
  bool is_constant_hessian_;
};
 
inline data_size_t SerialTreeLearner::GetGlobalDataCountInLeaf(int leaf_idx) const {
  if (leaf_idx >= 0) {
    return data_partition_->leaf_count(leaf_idx);
  } else {
    return 0;
  }
}
 
}  // namespace LightGBM
#endif   // LightGBM_TREELEARNER_SERIAL_TREE_LEARNER_H_