gbm.h

Go to the documentation of this file.

 
#ifndef XGBOOST_GBM_H_
#define XGBOOST_GBM_H_
 
#include <dmlc/registry.h>
#include <dmlc/any.h>
#include <xgboost/base.h>
#include <xgboost/data.h>
#include <xgboost/host_device_vector.h>
#include <xgboost/model.h>
 
#include <vector>
#include <utility>
#include <string>
#include <functional>
#include <unordered_map>
#include <memory>
 
namespace xgboost {
 
class Json;
class FeatureMap;
class ObjFunction;
 
struct GenericParameter;
struct LearnerModelParam;
struct PredictionCacheEntry;
class PredictionContainer;
 
class GradientBooster : public Model, public Configurable {
 protected:
  GenericParameter const* ctx_;
  explicit GradientBooster(GenericParameter const* ctx) : ctx_{ctx} {}
 
 public:
  ~GradientBooster() override = default;
  virtual void Configure(const std::vector<std::pair<std::string, std::string> >& cfg) = 0;
  virtual void Load(dmlc::Stream* fi) = 0;
  virtual void Save(dmlc::Stream* fo) const = 0;
  virtual void Slice(int32_t /*layer_begin*/, int32_t /*layer_end*/, int32_t /*step*/,
                     GradientBooster* /*out*/, bool* /*out_of_bound*/) const {
    LOG(FATAL) << "Slice is not supported by current booster.";
  }
  virtual int32_t BoostedRounds() const = 0;
  virtual bool ModelFitted() const = 0;
  virtual void DoBoost(DMatrix* p_fmat, HostDeviceVector<GradientPair>* in_gpair,
                       PredictionCacheEntry*, ObjFunction const* obj) = 0;
 
  virtual void PredictBatch(DMatrix* dmat,
                            PredictionCacheEntry* out_preds,
                            bool training,
                            unsigned layer_begin,
                            unsigned layer_end) = 0;
 
  virtual void InplacePredict(std::shared_ptr<DMatrix>, float, PredictionCacheEntry*, uint32_t,
                              uint32_t) const {
    LOG(FATAL) << "Inplace predict is not supported by current booster.";
  }
  virtual void PredictInstance(const SparsePage::Inst& inst,
                               std::vector<bst_float>* out_preds,
                               unsigned layer_begin, unsigned layer_end) = 0;
  virtual void PredictLeaf(DMatrix *dmat,
                           HostDeviceVector<bst_float> *out_preds,
                           unsigned layer_begin, unsigned layer_end) = 0;
 
  virtual void PredictContribution(DMatrix* dmat,
                                   HostDeviceVector<bst_float>* out_contribs,
                                   unsigned layer_begin, unsigned layer_end,
                                   bool approximate = false, int condition = 0,
                                   unsigned condition_feature = 0) = 0;
 
  virtual void PredictInteractionContributions(
      DMatrix *dmat, HostDeviceVector<bst_float> *out_contribs,
      unsigned layer_begin, unsigned layer_end, bool approximate) = 0;
 
  virtual std::vector<std::string> DumpModel(const FeatureMap& fmap,
                                             bool with_stats,
                                             std::string format) const = 0;
 
  virtual void FeatureScore(std::string const& importance_type,
                            common::Span<int32_t const> trees,
                            std::vector<bst_feature_t>* features,
                            std::vector<float>* scores) const = 0;
  virtual bool UseGPU() const = 0;
  static GradientBooster* Create(
      const std::string& name,
      GenericParameter const* generic_param,
      LearnerModelParam const* learner_model_param);
};
 
struct GradientBoosterReg
    : public dmlc::FunctionRegEntryBase<
          GradientBoosterReg,
          std::function<GradientBooster*(LearnerModelParam const* learner_model_param,
                                         GenericParameter const* ctx)> > {};
 
#define XGBOOST_REGISTER_GBM(UniqueId, Name)                            \
  static DMLC_ATTRIBUTE_UNUSED ::xgboost::GradientBoosterReg &          \
  __make_ ## GradientBoosterReg ## _ ## UniqueId ## __ =                \
      ::dmlc::Registry< ::xgboost::GradientBoosterReg>::Get()->__REGISTER__(Name)
 
}  // namespace xgboost
#endif  // XGBOOST_GBM_H_