gbdt.h

#ifndef LIGHTGBM_BOOSTING_GBDT_H_
#define LIGHTGBM_BOOSTING_GBDT_H_
 
#include <LightGBM/boosting.h>
#include <LightGBM/objective_function.h>
#include <LightGBM/prediction_early_stop.h>
#include <LightGBM/json11.hpp>
 
#include "score_updater.hpp"
 
#include <cstdio>
#include <vector>
#include <string>
#include <fstream>
#include <memory>
#include <mutex>
#include <map>
 
using namespace json11;
 
namespace LightGBM {
 
class GBDT : public GBDTBase {
public:
  GBDT();
 
  ~GBDT();
 
  void Init(const Config* gbdt_config, const Dataset* train_data,
            const ObjectiveFunction* objective_function,
            const std::vector<const Metric*>& training_metrics) override;
 
  void MergeFrom(const Boosting* other) override {
    auto other_gbdt = reinterpret_cast<const GBDT*>(other);
    // tmp move to other vector
    auto original_models = std::move(models_);
    models_ = std::vector<std::unique_ptr<Tree>>();
    // push model from other first
    for (const auto& tree : other_gbdt->models_) {
      auto new_tree = std::unique_ptr<Tree>(new Tree(*(tree.get())));
      models_.push_back(std::move(new_tree));
    }
    num_init_iteration_ = static_cast<int>(models_.size()) / num_tree_per_iteration_;
    // push model in current object
    for (const auto& tree : original_models) {
      auto new_tree = std::unique_ptr<Tree>(new Tree(*(tree.get())));
      models_.push_back(std::move(new_tree));
    }
    num_iteration_for_pred_ = static_cast<int>(models_.size()) / num_tree_per_iteration_;
  }
 
  void ShuffleModels(int start_iter, int end_iter) override {
    int total_iter = static_cast<int>(models_.size()) / num_tree_per_iteration_;
    start_iter = std::max(0, start_iter);
    if (end_iter <= 0) {
      end_iter = total_iter;
    }
    end_iter = std::min(total_iter, end_iter);
    auto original_models = std::move(models_);
    std::vector<int> indices(total_iter);
    for (int i = 0; i < total_iter; ++i) {
      indices[i] = i;
    }
    Random tmp_rand(17);
    for (int i = start_iter; i < end_iter - 1; ++i) {
      int j = tmp_rand.NextShort(i + 1, end_iter);
      std::swap(indices[i], indices[j]);
    }
    models_ = std::vector<std::unique_ptr<Tree>>();
    for (int i = 0; i < total_iter; ++i) {
      for (int j = 0; j < num_tree_per_iteration_; ++j) {
        int tree_idx = indices[i] * num_tree_per_iteration_ + j;
        auto new_tree = std::unique_ptr<Tree>(new Tree(*(original_models[tree_idx].get())));
        models_.push_back(std::move(new_tree));
      }
    }
  }
 
  void ResetTrainingData(const Dataset* train_data, const ObjectiveFunction* objective_function,
                         const std::vector<const Metric*>& training_metrics) override;
 
  void ResetConfig(const Config* gbdt_config) override;
 
  void AddValidDataset(const Dataset* valid_data,
                       const std::vector<const Metric*>& valid_metrics) override;
 
  void Train(int snapshot_freq, const std::string& model_output_path) override;
 
  void RefitTree(const std::vector<std::vector<int>>& tree_leaf_prediction) override;
 
  virtual bool TrainOneIter(const score_t* gradients, const score_t* hessians) override;
 
  void RollbackOneIter() override;
 
  int GetCurrentIteration() const override { return static_cast<int>(models_.size()) / num_tree_per_iteration_; }
 
  bool NeedAccuratePrediction() const override {
    if (objective_function_ == nullptr) {
      return true;
    } else {
      return objective_function_->NeedAccuratePrediction();
    }
  }
 
  std::vector<double> GetEvalAt(int data_idx) const override;
 
  virtual const double* GetTrainingScore(int64_t* out_len) override;
 
  virtual int64_t GetNumPredictAt(int data_idx) const override {
    CHECK(data_idx >= 0 && data_idx <= static_cast<int>(valid_score_updater_.size()));
    data_size_t num_data = train_data_->num_data();
    if (data_idx > 0) {
      num_data = valid_score_updater_[data_idx - 1]->num_data();
    }
    return num_data * num_class_;
  }
 
  void GetPredictAt(int data_idx, double* out_result, int64_t* out_len) override;
 
  inline int NumPredictOneRow(int num_iteration, bool is_pred_leaf, bool is_pred_contrib) const override {
    int num_preb_in_one_row = num_class_;
    if (is_pred_leaf) {
      int max_iteration = GetCurrentIteration();
      if (num_iteration > 0) {
        num_preb_in_one_row *= static_cast<int>(std::min(max_iteration, num_iteration));
      } else {
        num_preb_in_one_row *= max_iteration;
      }
    } else if (is_pred_contrib) {
      num_preb_in_one_row = num_tree_per_iteration_ * (max_feature_idx_ + 2);  // +1 for 0-based indexing, +1 for baseline
    }
    return num_preb_in_one_row;
  }
 
  void PredictRaw(const double* features, double* output,
                  const PredictionEarlyStopInstance* earlyStop) const override;
 
  void PredictRawByMap(const std::unordered_map<int, double>& features, double* output,
                       const PredictionEarlyStopInstance* early_stop) const override;
 
  void Predict(const double* features, double* output,
               const PredictionEarlyStopInstance* earlyStop) const override;
 
  void PredictByMap(const std::unordered_map<int, double>& features, double* output,
                    const PredictionEarlyStopInstance* early_stop) const override;
 
  void PredictLeafIndex(const double* features, double* output) const override;
 
  void PredictLeafIndexByMap(const std::unordered_map<int, double>& features, double* output) const override;
 
  void PredictContrib(const double* features, double* output,
                      const PredictionEarlyStopInstance* earlyStop) const override;
 
  std::string DumpModel(int start_iteration, int num_iteration) const override;
 
  std::string ModelToIfElse(int num_iteration) const override;
 
  bool SaveModelToIfElse(int num_iteration, const char* filename) const override;
 
  virtual bool SaveModelToFile(int start_iteration, int num_iterations, const char* filename) const override;
 
  std::string SaveModelToString(int num_iterations) { return SaveModelToString(0, num_iterations); } // ADDED by Medial to allow backward compatability with MedLightGBM wrapper
  virtual std::string SaveModelToString(int start_iteration, int num_iterations) const override;
 
  bool LoadModelFromString(std::string str) { return LoadModelFromString(str.c_str(), str.length()); } // ADDED by Medial for backward compatability
  bool LoadModelFromString(const char* buffer, size_t len) override;
 
  std::vector<double> FeatureImportance(int num_iteration, int importance_type) const override;
 
  inline int MaxFeatureIdx() const override { return max_feature_idx_; }
 
  inline std::vector<std::string> FeatureNames() const override { return feature_names_; }
 
  inline int LabelIdx() const override { return label_idx_; }
 
  inline int NumberOfTotalModel() const override { return static_cast<int>(models_.size()); }
 
  inline int NumModelPerIteration() const override { return num_tree_per_iteration_; }
 
  inline int NumberOfClasses() const override { return num_class_; }
 
  inline void InitPredict(int num_iteration, bool is_pred_contrib) override {
    num_iteration_for_pred_ = static_cast<int>(models_.size()) / num_tree_per_iteration_;
    if (num_iteration > 0) {
      num_iteration_for_pred_ = std::min(num_iteration, num_iteration_for_pred_);
    }
    if (is_pred_contrib) {
      #pragma omp parallel for schedule(static)
      for (int i = 0; i < static_cast<int>(models_.size()); ++i) {
        models_[i]->RecomputeMaxDepth();
      }
    }
  }
 
  inline double GetLeafValue(int tree_idx, int leaf_idx) const override {
    CHECK(tree_idx >= 0 && static_cast<size_t>(tree_idx) < models_.size());
    CHECK(leaf_idx >= 0 && leaf_idx < models_[tree_idx]->num_leaves());
    return models_[tree_idx]->LeafOutput(leaf_idx);
  }
 
  inline void SetLeafValue(int tree_idx, int leaf_idx, double val) override {
    CHECK(tree_idx >= 0 && static_cast<size_t>(tree_idx) < models_.size());
    CHECK(leaf_idx >= 0 && leaf_idx < models_[tree_idx]->num_leaves());
    models_[tree_idx]->SetLeafOutput(leaf_idx, val);
  }
 
  virtual const char* SubModelName() const override { return "tree"; }
 
protected:
  virtual bool EvalAndCheckEarlyStopping();
 
  void ResetBaggingConfig(const Config* config, bool is_change_dataset);
 
  virtual void Bagging(int iter);
 
  data_size_t BaggingHelper(Random& cur_rand, data_size_t start, data_size_t cnt, data_size_t* buffer);
 
  virtual void Boosting();
 
  virtual void UpdateScore(const Tree* tree, const int cur_tree_id);
 
  virtual std::vector<double> EvalOneMetric(const Metric* metric, const double* score) const;
 
  std::string OutputMetric(int iter);
 
  double BoostFromAverage(int class_id, bool update_scorer);
 
  int iter_;
  const Dataset* train_data_;
  std::unique_ptr<Config> config_;
  std::unique_ptr<TreeLearner> tree_learner_;
  const ObjectiveFunction* objective_function_;
  std::unique_ptr<ScoreUpdater> train_score_updater_;
  std::vector<const Metric*> training_metrics_;
  std::vector<std::unique_ptr<ScoreUpdater>> valid_score_updater_;
  std::vector<std::vector<const Metric*>> valid_metrics_;
  int early_stopping_round_;
  std::vector<std::vector<int>> best_iter_;
  std::vector<std::vector<double>> best_score_;
  std::vector<std::vector<std::string>> best_msg_;
  std::vector<std::unique_ptr<Tree>> models_;
  int max_feature_idx_;
  std::vector<score_t> gradients_;
  std::vector<score_t> hessians_;
  std::vector<data_size_t> bag_data_indices_;
  data_size_t bag_data_cnt_;
  std::vector<data_size_t> tmp_indices_;
  data_size_t num_data_;
  int num_tree_per_iteration_;
  int num_class_;
  data_size_t label_idx_;
  int num_iteration_for_pred_;
  double shrinkage_rate_;
  int num_init_iteration_;
  std::vector<std::string> feature_names_;
  std::vector<std::string> feature_infos_;
  int num_threads_;
  std::vector<data_size_t> offsets_buf_;
  std::vector<data_size_t> left_cnts_buf_;
  std::vector<data_size_t> right_cnts_buf_;
  std::vector<data_size_t> left_write_pos_buf_;
  std::vector<data_size_t> right_write_pos_buf_;
  std::unique_ptr<Dataset> tmp_subset_;
  bool is_use_subset_;
  std::vector<bool> class_need_train_;
  bool is_constant_hessian_;
  std::unique_ptr<ObjectiveFunction> loaded_objective_;
  bool average_output_;
  bool need_re_bagging_;
  std::string loaded_parameter_;
 
  Json forced_splits_json_;
};
 
}  // namespace LightGBM
#endif   // LightGBM_BOOSTING_GBDT_H_