screening.h

Go to the documentation of this file.

 
#pragma once
 
#include "jit_normalization.h"
#include <Eigen/SparseCore>
#include <memory>
#include <vector>
 
namespace slope {
 
std::vector<int>
activeSet(const Eigen::VectorXd& beta);
 
std::vector<int>
strongSet(const Eigen::VectorXd& gradient_prev,
          const Eigen::ArrayXd& lambda,
          const Eigen::ArrayXd& lambda_prev);
 
class ScreeningRule
{
public:
  virtual ~ScreeningRule() = default;
 
  virtual std::vector<int> initialize(const std::vector<int>& full_set,
                                      int alpha_max_ind) = 0;
 
  virtual std::vector<int> screen(Eigen::VectorXd& gradient,
                                  const Eigen::ArrayXd& lambda_curr,
                                  const Eigen::ArrayXd& lambda_prev,
                                  const Eigen::VectorXd& beta,
                                  const std::vector<int>& full_set) = 0;
 
  virtual bool checkKktViolations(Eigen::VectorXd& gradient,
                                  const Eigen::VectorXd& beta,
                                  const Eigen::ArrayXd& lambda_curr,
                                  std::vector<int>& working_set,
                                  const Eigen::MatrixXd& x,
                                  const Eigen::MatrixXd& residual,
                                  const Eigen::VectorXd& x_centers,
                                  const Eigen::VectorXd& x_scales,
                                  JitNormalization jit_normalization,
                                  const std::vector<int>& full_set) = 0;
  virtual bool checkKktViolations(Eigen::VectorXd& gradient,
                                  const Eigen::VectorXd& beta,
                                  const Eigen::ArrayXd& lambda_curr,
                                  std::vector<int>& working_set,
                                  const Eigen::SparseMatrix<double>& x,
                                  const Eigen::MatrixXd& residual,
                                  const Eigen::VectorXd& x_centers,
                                  const Eigen::VectorXd& x_scales,
                                  JitNormalization jit_normalization,
                                  const std::vector<int>& full_set) = 0;
 
  virtual std::string toString() const = 0;
 
protected:
  std::vector<int> strong_set;
};
 
class NoScreening : public ScreeningRule
{
public:
  std::vector<int> initialize(const std::vector<int>& full_set,
                              int alpha_max_ind) override;
 
  std::vector<int> screen(Eigen::VectorXd& gradient,
                          const Eigen::ArrayXd& lambda_curr,
                          const Eigen::ArrayXd& lambda_prev,
                          const Eigen::VectorXd& beta,
                          const std::vector<int>& full_set) override;
 
  bool checkKktViolations(Eigen::VectorXd& gradient,
                          const Eigen::VectorXd& beta,
                          const Eigen::ArrayXd& lambda_curr,
                          std::vector<int>& working_set,
                          const Eigen::MatrixXd& x,
                          const Eigen::MatrixXd& residual,
                          const Eigen::VectorXd& x_centers,
                          const Eigen::VectorXd& x_scales,
                          JitNormalization jit_normalization,
                          const std::vector<int>& full_set) override;
 
  bool checkKktViolations(Eigen::VectorXd& gradient,
                          const Eigen::VectorXd& beta,
                          const Eigen::ArrayXd& lambda_curr,
                          std::vector<int>& working_set,
                          const Eigen::SparseMatrix<double>& x,
                          const Eigen::MatrixXd& residual,
                          const Eigen::VectorXd& x_centers,
                          const Eigen::VectorXd& x_scales,
                          JitNormalization jit_normalization,
                          const std::vector<int>& full_set) override;
 
  std::string toString() const override;
};
 
class StrongScreening : public ScreeningRule
{
public:
  std::vector<int> initialize(const std::vector<int>& full_set,
                              int alpha_max_ind) override;
 
  std::vector<int> screen(Eigen::VectorXd& gradient,
                          const Eigen::ArrayXd& lambda_curr,
                          const Eigen::ArrayXd& lambda_prev,
                          const Eigen::VectorXd& beta,
                          const std::vector<int>& full_set) override;
 
  bool checkKktViolations(Eigen::VectorXd& gradient,
                          const Eigen::VectorXd& beta,
                          const Eigen::ArrayXd& lambda_curr,
                          std::vector<int>& working_set,
                          const Eigen::MatrixXd& x,
                          const Eigen::MatrixXd& residual,
                          const Eigen::VectorXd& x_centers,
                          const Eigen::VectorXd& x_scales,
                          JitNormalization jit_normalization,
                          const std::vector<int>& full_set) override;
 
  bool checkKktViolations(Eigen::VectorXd& gradient,
                          const Eigen::VectorXd& beta,
                          const Eigen::ArrayXd& lambda_curr,
                          std::vector<int>& working_set,
                          const Eigen::SparseMatrix<double>& x,
                          const Eigen::MatrixXd& residual,
                          const Eigen::VectorXd& x_centers,
                          const Eigen::VectorXd& x_scales,
                          JitNormalization jit_normalization,
                          const std::vector<int>& full_set) override;
 
  std::string toString() const override;
 
private:
  template<typename MatrixType>
  bool checkKktViolationsImpl(Eigen::VectorXd& gradient,
                              const Eigen::VectorXd& beta,
                              const Eigen::ArrayXd& lambda_curr,
                              std::vector<int>& working_set,
                              const MatrixType& x,
                              const Eigen::MatrixXd& residual,
                              const Eigen::VectorXd& x_centers,
                              const Eigen::VectorXd& x_scales,
                              JitNormalization jit_normalization,
                              const std::vector<int>& full_set);
};
 
std::unique_ptr<ScreeningRule>
createScreeningRule(const std::string& screening_type);
 
} // namespace slope