score.h

Go to the documentation of this file.

 
#pragma once
 
#include "losses/loss.h"
#include <Eigen/Core>
#include <memory>
 
namespace slope {

double
binaryRocAuc(const Eigen::VectorXd& scores, const Eigen::VectorXd& labels);

double
binaryRocAuc(const Eigen::VectorXd& scores,
             const Eigen::VectorXd& labels,
             const Eigen::VectorXd& observation_weights);

double
rocAuc(const Eigen::MatrixXd& scores, const Eigen::MatrixXd& labels);

double
rocAuc(const Eigen::MatrixXd& scores,
       const Eigen::MatrixXd& labels,
       const Eigen::VectorXd& observation_weights);

class Score
{
public:
  virtual ~Score() = default;

  virtual bool isWorse(double other, double current) const = 0;

  virtual double initValue() const = 0;

  std::function<bool(double, double)> getComparator() const;

  virtual double eval(const Eigen::MatrixXd& eta,
                      const Eigen::MatrixXd& y,
                      const std::unique_ptr<Loss>& loss) const = 0;

  virtual double eval(const Eigen::MatrixXd& eta,
                      const Eigen::MatrixXd& y,
                      const std::unique_ptr<Loss>& loss,
                      const Eigen::VectorXd& observation_weights) const;

  static std::unique_ptr<Score> create(const std::string& metric);
};

class MinimizeScore : public Score
{
public:
  bool isWorse(double a, double b) const override;

  double initValue() const override;
};

class MaximizeScore : public Score
{
public:
  bool isWorse(double a, double b) const override;

  double initValue() const override;
};

class MSE : public MinimizeScore
{
public:
  double eval(const Eigen::MatrixXd& eta,
              const Eigen::MatrixXd& y,
              const std::unique_ptr<Loss>&) const override;
 
  double eval(const Eigen::MatrixXd& eta,
              const Eigen::MatrixXd& y,
              const std::unique_ptr<Loss>& loss,
              const Eigen::VectorXd& observation_weights) const override;
};

class MAE : public MinimizeScore
{
public:
  double eval(const Eigen::MatrixXd& eta,
              const Eigen::MatrixXd& y,
              const std::unique_ptr<Loss>&) const override;
 
  double eval(const Eigen::MatrixXd& eta,
              const Eigen::MatrixXd& y,
              const std::unique_ptr<Loss>& loss,
              const Eigen::VectorXd& observation_weights) const override;
};

class Accuracy : public MaximizeScore
{
public:
  double eval(const Eigen::MatrixXd& eta,
              const Eigen::MatrixXd& y,
              const std::unique_ptr<Loss>& loss) const override;
 
  double eval(const Eigen::MatrixXd& eta,
              const Eigen::MatrixXd& y,
              const std::unique_ptr<Loss>& loss,
              const Eigen::VectorXd& observation_weights) const override;
};

class MisClass : public MinimizeScore
{
public:
  double eval(const Eigen::MatrixXd& eta,
              const Eigen::MatrixXd& y,
              const std::unique_ptr<Loss>& loss) const override;
 
  double eval(const Eigen::MatrixXd& eta,
              const Eigen::MatrixXd& y,
              const std::unique_ptr<Loss>& loss,
              const Eigen::VectorXd& observation_weights) const override;
};

class Deviance : public MinimizeScore
{
public:
  double eval(const Eigen::MatrixXd& eta,
              const Eigen::MatrixXd& y,
              const std::unique_ptr<Loss>& loss) const override;
 
  double eval(const Eigen::MatrixXd& eta,
              const Eigen::MatrixXd& y,
              const std::unique_ptr<Loss>& loss,
              const Eigen::VectorXd& observation_weights) const override;
};

class AUC : public MaximizeScore
{
public:
  double eval(const Eigen::MatrixXd& eta,
              const Eigen::MatrixXd& y,
              const std::unique_ptr<Loss>& loss) const override;
 
  double eval(const Eigen::MatrixXd& eta,
              const Eigen::MatrixXd& y,
              const std::unique_ptr<Loss>& loss,
              const Eigen::VectorXd& observation_weights) const override;
};
 
} // namespace slope