boosting.h

#ifndef LIGHTGBM_BOOSTING_H_
#define LIGHTGBM_BOOSTING_H_
 
#include <LightGBM/meta.h>
#include <LightGBM/config.h>
 
#include <vector>
#include <string>
#include <map>
 
namespace LightGBM {
 
class Dataset;
class ObjectiveFunction;
class Metric;
struct PredictionEarlyStopInstance;
 
class LIGHTGBM_EXPORT Boosting {
public:
  virtual ~Boosting() {}
 
  virtual void Init(
    const Config* config,
    const Dataset* train_data,
    const ObjectiveFunction* objective_function,
    const std::vector<const Metric*>& training_metrics) = 0;
 
  virtual void MergeFrom(const Boosting* other) = 0;
 
  virtual void ShuffleModels(int start_iter, int end_iter) = 0;
 
  virtual void ResetTrainingData(const Dataset* train_data, const ObjectiveFunction* objective_function,
                                 const std::vector<const Metric*>& training_metrics) = 0;
 
  virtual void ResetConfig(const Config* config) = 0;
 
 
 
  virtual void AddValidDataset(const Dataset* valid_data,
                               const std::vector<const Metric*>& valid_metrics) = 0;
 
  virtual void Train(int snapshot_freq, const std::string& model_output_path) = 0;
 
  virtual void RefitTree(const std::vector<std::vector<int>>& tree_leaf_prediction) = 0;
 
  virtual bool TrainOneIter(const score_t* gradients, const score_t* hessians) = 0;
 
  virtual void RollbackOneIter() = 0;
 
  virtual int GetCurrentIteration() const = 0;
 
  virtual std::vector<double> GetEvalAt(int data_idx) const = 0;
 
  virtual const double* GetTrainingScore(int64_t* out_len) = 0;
 
  virtual int64_t GetNumPredictAt(int data_idx) const = 0;
 
  virtual void GetPredictAt(int data_idx, double* result, int64_t* out_len) = 0;
 
  virtual int NumPredictOneRow(int num_iteration, bool is_pred_leaf, bool is_pred_contrib) const = 0;
 
  virtual void PredictRaw(const double* features, double* output,
                          const PredictionEarlyStopInstance* early_stop) const = 0;
 
  virtual void PredictRawByMap(const std::unordered_map<int, double>& features, double* output,
                               const PredictionEarlyStopInstance* early_stop) const = 0;
 
 
  virtual void Predict(const double* features, double* output,
                       const PredictionEarlyStopInstance* early_stop) const = 0;
 
  virtual void PredictByMap(const std::unordered_map<int, double>& features, double* output,
                            const PredictionEarlyStopInstance* early_stop) const = 0;
 
 
  virtual void PredictLeafIndex(
    const double* features, double* output) const = 0;
 
  virtual void PredictLeafIndexByMap(
    const std::unordered_map<int, double>& features, double* output) const = 0;
 
  virtual void PredictContrib(const double* features, double* output,
                              const PredictionEarlyStopInstance* early_stop) const = 0;
 
  virtual std::string DumpModel(int start_iteration, int num_iteration) const = 0;
 
  virtual std::string ModelToIfElse(int num_iteration) const = 0;
 
  virtual bool SaveModelToIfElse(int num_iteration, const char* filename) const = 0;
 
  virtual bool SaveModelToFile(int start_iteration, int num_iterations, const char* filename) const = 0;
 
  std::string SaveModelToString(int num_iterations) { return SaveModelToString(0, num_iterations); } // ADDED by Medial for backward compatibility with MedLightGBM
  virtual std::string SaveModelToString(int start_iteration, int num_iterations) const = 0;
 
  bool LoadModelFromString(std::string str) { return LoadModelFromString(str.c_str(), str.length()); } // ADDED by Medial for backward compatability with MedLightGBM
  virtual bool LoadModelFromString(const char* buffer, size_t len) = 0;
 
  virtual std::vector<double> FeatureImportance(int num_iteration, int importance_type) const = 0;
 
  virtual int MaxFeatureIdx() const = 0;
 
  virtual std::vector<std::string> FeatureNames() const = 0;
 
  virtual int LabelIdx() const = 0;
 
  virtual int NumberOfTotalModel() const = 0;
 
  virtual int NumModelPerIteration() const = 0;
 
  virtual int NumberOfClasses() const = 0;
 
  virtual bool NeedAccuratePrediction() const = 0;
 
  virtual void InitPredict(int num_iteration, bool is_pred_contrib) = 0;
 
  virtual const char* SubModelName() const = 0;
 
  Boosting() = default;
  Boosting& operator=(const Boosting&) = delete;
  Boosting(const Boosting&) = delete;
 
  static bool LoadFileToBoosting(Boosting* boosting, const char* filename);
 
  static Boosting* CreateBoosting(const std::string& type, const char* filename);
};
 
class GBDTBase : public Boosting {
public:
  virtual double GetLeafValue(int tree_idx, int leaf_idx) const = 0;
  virtual void SetLeafValue(int tree_idx, int leaf_idx, double val) = 0;
};
 
}  // namespace LightGBM
 
#endif   // LightGBM_BOOSTING_H_