slope_fit.h

Go to the documentation of this file.

 
#pragma once
 
#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; 
  std::vector<std::vector<int>>
    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;      
 
public:
  SlopeFit() = default;
 
  SlopeFit(const Eigen::VectorXd& intercepts,
           const Eigen::SparseMatrix<double>& coefs,
           const std::vector<std::vector<int>>& 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)
    : 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 }
  {
  }
 
  const Eigen::VectorXd& getIntercepts() const { return intercepts; }
 
  const Eigen::SparseMatrix<double>& getCoefs() const { return coefs; }
 
  const std::vector<std::vector<int>>& 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;
  }
 
  template<typename T>
  Eigen::MatrixXd predict(T& x, const std::string& type = "response") const
  {
    validateOption(type, { "response", "linear" }, "type");
 
    int n = x.rows();
    int m = coefs.cols();
 
    std::unique_ptr<Loss> loss = setupLoss(this->loss_type);
 
    Eigen::VectorXd x_centers;
    Eigen::VectorXd x_scales;
    normalize(
      x, x_centers, x_scales, this->centering_type, this->scaling_type, false);
 
    Eigen::MatrixXd eta = Eigen::MatrixXd::Zero(n, m);
 
    for (int k = 0; k < m; ++k) {
      for (typename Eigen::SparseMatrix<double>::InnerIterator it(coefs, k); it;
           ++it) {
        int j = it.row();
        eta.col(k) += x.col(j) * (it.value() / x_scales(j));
        eta.col(k).array() -= it.value() * x_centers(j) / x_scales(j);
      }
 
      eta.col(k).array() += intercepts(k);
    }
 
    if (type == "linear") {
      return eta;
    }
 
    // Return predictions
    return loss->predict(eta);
  }
};
 
} // namespace slope