slope_fit.h

Go to the documentation of this file.

 
#pragma once
 
#include "clusters.h"
#include "losses/setup_loss.h"
#include "normalize.h"
#include "utils.h"
#include <Eigen/Dense>
#include <Eigen/SparseCore>
#include <memory>
 
namespace slope {
 
class SlopeFit
{
private:
  Eigen::VectorXd intercepts;        
  Eigen::SparseMatrix<double> coefs; 
  Clusters clusters;                 
  double alpha;                      
  Eigen::ArrayXd lambda; 
  double deviance;       
  double null_deviance;  
  std::vector<double>
    primals; 
  std::vector<double>
    duals; 
  std::vector<double> time; 
  int passes; 
  std::string centering_type; 
  std::string scaling_type;   
  std::string loss_type;      
  bool has_intercept;         
  Eigen::VectorXd x_centers;  
  Eigen::VectorXd x_scales;   
 
public:
  SlopeFit() = default;
 
  SlopeFit(const Eigen::VectorXd& intercepts,
           const Eigen::SparseMatrix<double>& coefs,
           const Clusters& clusters,
           const double alpha,
           const Eigen::ArrayXd& lambda,
           const double deviance,
           const double null_deviance,
           const std::vector<double>& primals,
           const std::vector<double>& duals,
           const std::vector<double>& time,
           const int passes,
           const std::string& centering_type,
           const std::string& scaling_type,
           const bool has_intercept,
           const Eigen::VectorXd& x_centers,
           const Eigen::VectorXd& x_scales)
    : intercepts{ intercepts }
    , coefs{ coefs }
    , clusters{ clusters }
    , alpha{ alpha }
    , lambda{ lambda }
    , deviance{ deviance }
    , null_deviance{ null_deviance }
    , primals{ primals }
    , duals{ duals }
    , time{ time }
    , passes{ passes }
    , centering_type{ centering_type }
    , scaling_type{ scaling_type }
    , has_intercept{ has_intercept }
    , x_centers{ x_centers }
    , x_scales{ x_scales }
  {
  }
 
  Eigen::VectorXd getIntercepts(const bool original_scale = true) const
  {
    // TODO: Scale intercepts independently of coefficients
    if (original_scale) {
      auto [beta0_out, beta_out] = rescaleCoefficients(intercepts,
                                                       coefs,
                                                       this->x_centers,
                                                       this->x_scales,
                                                       this->has_intercept);
      return beta0_out;
    }
 
    return intercepts;
  }
 
  Eigen::SparseMatrix<double> getCoefs(const bool original_scale = true) const
  {
    if (original_scale) {
      // TODO: Scale coefficients independently of intercepts
      auto [beta0_out, beta_out] = rescaleCoefficients(intercepts,
                                                       coefs,
                                                       this->x_centers,
                                                       this->x_scales,
                                                       this->has_intercept);
      return beta_out.sparseView();
    }
 
    return coefs;
  }
 
  const Clusters& getClusters() const { return clusters; }
 
  const Eigen::ArrayXd& getLambda() const { return lambda; }
 
  double getAlpha() const { return alpha; }
 
  double getDeviance() const { return deviance; }
 
  const std::string& getLossType() const { return loss_type; }
 
  double getNullDeviance() const { return null_deviance; }
 
  const std::vector<double>& getPrimals() const { return primals; }
 
  const std::vector<double>& getDuals() const { return duals; }
 
  const std::vector<double>& getTime() const { return time; }
 
  int getPasses() const { return passes; }
 
  double getDevianceRatio() const { return 1.0 - deviance / null_deviance; }
 
  std::vector<double> getGaps() const
  {
    std::vector<double> gaps(primals.size());
    for (size_t i = 0; i < primals.size(); i++) {
      gaps[i] = primals[i] - duals[i];
    }
    return gaps;
  }
 
  bool hasIntercept() const { return has_intercept; }
 
  template<typename T>
  Eigen::MatrixXd predict(Eigen::EigenBase<T>& x,
                          const std::string& type = "response") const
  {
    validateOption(type, { "response", "linear" }, "type");
 
    Eigen::MatrixXd eta = x.derived() * getCoefs();
 
    if (has_intercept) {
      eta.rowwise() += getIntercepts().transpose();
    }
 
    if (type == "linear") {
      return eta;
    }
 
    // Return predictions
    std::unique_ptr<Loss> loss = setupLoss(this->loss_type);
 
    return loss->predict(eta);
  }
};
 
} // namespace slope