objective.h

Go to the documentation of this file.

 
#ifndef XGBOOST_OBJECTIVE_H_
#define XGBOOST_OBJECTIVE_H_
 
#include <dmlc/registry.h>
#include <xgboost/base.h>
#include <xgboost/data.h>
#include <xgboost/host_device_vector.h>
#include <xgboost/model.h>
#include <xgboost/task.h>
 
#include <cstdint>  // std::int32_t
#include <functional>
#include <string>
#include <utility>
#include <vector>
 
namespace xgboost {
 
class RegTree;
struct Context;
 
class ObjFunction : public Configurable {
 protected:
  Context const* ctx_;
 
 public:
  static constexpr float DefaultBaseScore() { return 0.5f; }
 
 public:
  ~ObjFunction() override = default;
  virtual void Configure(const std::vector<std::pair<std::string, std::string> >& args) = 0;
  virtual void GetGradient(const HostDeviceVector<bst_float>& preds, const MetaInfo& info,
                           std::int32_t iter, linalg::Matrix<GradientPair>* out_gpair) = 0;
 
  virtual const char* DefaultEvalMetric() const = 0;
  virtual Json DefaultMetricConfig() const { return Json{Null{}}; }
 
  // the following functions are optional, most of time default implementation is good enough
  virtual void PredTransform(HostDeviceVector<bst_float>*) const {}
 
  virtual void EvalTransform(HostDeviceVector<bst_float> *io_preds) {
    this->PredTransform(io_preds);
  }
  [[nodiscard]] virtual bst_float ProbToMargin(bst_float base_score) const { return base_score; }
  virtual void InitEstimation(MetaInfo const& info, linalg::Tensor<float, 1>* base_score) const;
  [[nodiscard]] virtual struct ObjInfo Task() const = 0;
  [[nodiscard]] virtual bst_target_t Targets(MetaInfo const& info) const {
    if (info.labels.Shape(1) > 1) {
      LOG(FATAL) << "multioutput is not supported by the current objective function";
    }
    return 1;
  }
 
  virtual void UpdateTreeLeaf(HostDeviceVector<bst_node_t> const& /*position*/,
                              MetaInfo const& /*info*/, float /*learning_rate*/,
                              HostDeviceVector<float> const& /*prediction*/,
                              std::int32_t /*group_idx*/, RegTree* /*p_tree*/) const {}
 
  static ObjFunction* Create(const std::string& name, Context const* ctx);
 
  static std::string GetSyclImplementationName(const std::string& name);
};
 
struct ObjFunctionReg
    : public dmlc::FunctionRegEntryBase<ObjFunctionReg,
                                        std::function<ObjFunction* ()> > {
};
 
#define XGBOOST_REGISTER_OBJECTIVE(UniqueId, Name)                      \
  static DMLC_ATTRIBUTE_UNUSED ::xgboost::ObjFunctionReg &              \
  __make_ ## ObjFunctionReg ## _ ## UniqueId ## __ =                    \
      ::dmlc::Registry< ::xgboost::ObjFunctionReg>::Get()->__REGISTER__(Name)
}  // namespace xgboost
#endif  // XGBOOST_OBJECTIVE_H_