slope.h

Go to the documentation of this file.

 
#pragma once
 
#include "slope_fit.h"
#include "slope_path.h"
#include <Eigen/Core>
#include <Eigen/SparseCore>
#include <cassert>
#include <optional>
 
namespace slope {
 
class Slope
{
public:
  Slope()
    : intercept(true)
    , modify_x(false)
    , update_clusters(false)
    , collect_diagnostics(false)
    , return_clusters(true)
    , alpha_min_ratio(-1) // TODO: Use std::optional for alpha_min_ratio
    , dev_change_tol(1e-5)
    , dev_ratio_tol(0.999)
    , learning_rate_decr(0.5)
    , q(0.1)
    , tol(1e-4)
    , alpha_est_maxit(1000)
    , max_it(1e4)
    , path_length(100)
    , cd_iterations(10)
    , max_clusters(std::optional<int>())
    , alpha_type("path")
    , lambda_type("bh")
    , centering_type("mean")
    , scaling_type("sd")
    , loss_type("quadratic")
    , screening_type("strong")
    , solver_type("auto")
  {
  }
 
  void setSolver(const std::string& solver);
 
  void setIntercept(bool intercept);
 
  void setNormalization(const std::string& type);
 
  void setUpdateClusters(bool update_clusters);
 
  void setReturnClusters(const bool return_clusters);
 
  void setAlphaMinRatio(double alpha_min_ratio);
 
  void setAlphaType(const std::string& alpha_type);
 
  void setLearningRateDecr(double learning_rate_decr);
 
  void setQ(double q);
 
  void setOscarParameters(const double theta1, const double theta2);
 
  void setTol(double tol);
 
  void setMaxIterations(int max_it);
 
  void setPathLength(int path_length);
 
  void setHybridCdIterations(int cd_iterations);
 
  void setLambdaType(const std::string& lambda_type);
 
  void setLoss(const std::string& loss_type);
 
  void setScreening(const std::string& screening_type);
 
  void setModifyX(const bool modify_x);
 
  void setDevChangeTol(const double dev_change_tol);
 
  void setDevRatioTol(const double dev_ratio_tol);
 
  void setMaxClusters(const int max_clusters);
 
  void setCentering(const std::string& type);
 
  void setCentering(const Eigen::VectorXd& x_centers);
 
  void setScaling(const std::string& type);
 
  void setDiagnostics(const bool collect_diagnostics);
 
  void setScaling(const Eigen::VectorXd& x_scales);
 
  void setAlphaEstimationMaxIterations(const int alpha_est_maxit);
 
  int getAlphaEstimationMaxIterations() const;
 
  bool getFitIntercept() const;
 
  const std::string& getLossType();
 
  template<typename T>
  SlopePath path(T& x,
                 const Eigen::MatrixXd& y_in,
                 Eigen::ArrayXd alpha = Eigen::ArrayXd::Zero(0),
                 Eigen::ArrayXd lambda = Eigen::ArrayXd::Zero(0));
 
  template<typename T>
  SlopeFit fit(T& x,
               const Eigen::MatrixXd& y_in,
               const double alpha = 1.0,
               Eigen::ArrayXd lambda = Eigen::ArrayXd::Zero(0));
 
private:
  // Parameters
  bool intercept;
  bool modify_x;
  bool update_clusters;
  bool collect_diagnostics;
  bool return_clusters;
  double alpha_min_ratio;
  double dev_change_tol;
  double dev_ratio_tol;
  double learning_rate_decr;
  double q;
  double theta1;
  double theta2;
  double tol;
  int alpha_est_maxit;
  int max_it;
  int path_length;
  int cd_iterations;
  std::optional<int> max_clusters;
  std::string alpha_type;
  std::string lambda_type;
  std::string centering_type;
  std::string scaling_type;
  std::string loss_type;
  std::string screening_type;
  std::string solver_type;
 
  // Data
  Eigen::VectorXd x_centers;
  Eigen::VectorXd x_scales;
};
 
} // namespace slope