classifier.h

Go to the documentation of this file.

#ifndef CLASSIFIER_H
#define CLASSIFIER_H
 
#include <cmp_defines.h>
#include <list>
#include <kernel++.h>
#include <svm.h>
#include <statistics.h>
#include <optimization.h>
#include <kde.h>
#include <covariance.h>
 
namespace cmp::classifier {
 
enum method {
    CV_SCORE,      
    CV_PROB_SCORE  
};
 
 
 
class Classifier {
  public:
    virtual ~Classifier() = default;
    virtual std::vector<double> predictProbabilities(const Eigen::Ref<const Eigen::VectorXd> &x) const = 0;
    virtual size_t predict(const Eigen::Ref<const Eigen::VectorXd> &x) const = 0;
};
 
class KNN {
  private:
    std::vector<std::vector<size_t>> neighbours_; 
    size_t kNearestValue_;                        
    size_t nPoints_;                              
 
  public:
    void compute(const std::vector<Eigen::VectorXd> &points, size_t k);
 
    const std::vector<size_t> &operator[](size_t i) const;
 
    size_t nPoints() const;
 
    size_t k() const;
};
 
 
 
class KDE : public Classifier {
  private:
    Eigen::MatrixXd xObs_ = Eigen::MatrixXd(0, 0); 
    Eigen::VectorXs labels_ = Eigen::VectorXs(0);  
    Eigen::VectorXs classCounts_;               
 
    size_t nObs_ = 0;      
    size_t dimX_ = 0;      
    size_t nClasses_ = 1;  
 
    std::shared_ptr<cmp::kernel::Bandwidth> bandwidth_{nullptr}; 
    std::shared_ptr<kernel::Kernel> kernel_{nullptr};            
 
  public:
    KDE() {};
 
 
    void set(std::shared_ptr<kernel::Kernel> kernel, std::shared_ptr<cmp::kernel::Bandwidth> bandwidth) {
        kernel_ = kernel;
        bandwidth_ = bandwidth;
    };
 
 
    void condition(const Eigen::Ref<const Eigen::MatrixXd> &xObs, const Eigen::Ref<const Eigen::VectorXs> &labels) {
        xObs_ = xObs;
        labels_ = labels;
 
        nObs_ = xObs_.rows();
        dimX_ = xObs_.cols();
        nClasses_ = labels_.maxCoeff() + 1;
 
        if(nObs_ != labels_.size()) {
            throw std::runtime_error("KDE::set: Number of observations and labels size do not match.");
        }
 
        classCounts_ = Eigen::VectorXs::Zero(nClasses_);
        for(size_t i = 0; i < nObs_; i++) {
            classCounts_(labels_(i))++;
        }
    }
 
    double density(const Eigen::Ref<const Eigen::VectorXd> &x, const size_t &classLabel) const;
 
    std::vector<double> predictProbabilities(const Eigen::Ref<const Eigen::VectorXd> &x) const override;
 
    size_t predict(const Eigen::Ref<const Eigen::VectorXd> &x) const override {
        std::vector<double> probs = predictProbabilities(x);
        return std::max_element(probs.begin(), probs.end()) - probs.begin();
    };
 
 
    double objectiveFunctionCV(const method& method, const cmp::statistics::KFold& kf) const;
 
    double objectiveFunctionLOO() const;
 
    void fit(const Eigen::Ref<const Eigen::MatrixXd>& xObs, const Eigen::Ref<const Eigen::VectorXs>& labels, cmp::statistics::KFold kf, const double& minBw, const double& maxBw, const method method = CV_PROB_SCORE, nlopt::algorithm algo = nlopt::LN_SBPLX, double ftol_rel = 1e-4, std::vector<bool> logScaleFlags = {});
 
 
    void fitLOO(const Eigen::Ref<const Eigen::MatrixXd>& xObs, const Eigen::Ref<const Eigen::VectorXs>& labels, const double& minBw, const double& maxBw, nlopt::algorithm algo = nlopt::LN_SBPLX, double ftol_rel = 1e-4, std::vector<bool> logScaleFlags = {});
};
 
 
 
class SVM : public Classifier {
  private:
 
    struct svm_model *model_ = nullptr; 
    struct svm_problem prob_;            
 
    struct svm_parameter modelParameters_;                          
    std::shared_ptr<cmp::covariance::Covariance> covariance_{nullptr};  
    Eigen::VectorXd hyperparameters_ = Eigen::VectorXd(0);                             
 
    // Eigen::VectorXd to hold the original training data
    Eigen::MatrixXd xObs_; 
    size_t nObs_ = 0;      
 
    static void silent_print(const char *s) {}
 
    void initDefaultParameters(double C, double eps) {
        modelParameters_ = svm_parameter();
 
        // Use a classifier with precomputed kernel
        modelParameters_.svm_type = C_SVC;
        modelParameters_.kernel_type = PRECOMPUTED;
 
        // Set the two parameters C and eps
        modelParameters_.eps = eps;
        modelParameters_.C = C;
 
        // Other parameters
        modelParameters_.weight = nullptr;
        modelParameters_.weight_label = nullptr;
        modelParameters_.shrinking = 1;
        modelParameters_.probability = 1;
        modelParameters_.nr_weight = 0;
        modelParameters_.cache_size = 200;
    }
 
 
    // Helper function to free a problem pointer
    static void freeProblem(struct svm_problem *prob) {
        if(prob->x) {
            for(int i = 0; i < prob->l; i++) {
                delete[] prob->x[i];
            }
            delete[] prob->x;
            prob->x = nullptr;
        }
        if(prob->y) {
            delete[] prob->y;
            prob->y = nullptr;
        }
        prob->l = 0;
    }
 
  public:
 
    // Initialize the SVM with default parameters
    SVM() {
        initDefaultParameters(100, 1e-3);
 
        // Disable LIBSVM printing by default
        svm_set_print_string_function(&silent_print);
    };
 
    ~SVM() {
        svm_free_and_destroy_model(&model_);
        freeProblem(&prob_);
    };
 
    void set(std::shared_ptr<cmp::covariance::Covariance> covariance, const Eigen::Ref<const Eigen::VectorXd> hpar, const double &C, const double &eps = 1e-3) {
        initDefaultParameters(C, eps);
        covariance_ = covariance;
        hyperparameters_ = hpar;
    }
 
 
    void condition(const Eigen::Ref<const Eigen::MatrixXd> &xObs, const Eigen::Ref<const Eigen::VectorXs> &labels);
 
 
    size_t predict(const Eigen::Ref<const Eigen::VectorXd> &x) const override;
 
    std::vector<double> predictProbabilities(const Eigen::Ref<const Eigen::VectorXd> &x) const override;
 
 
    std::pair<Eigen::VectorXd, double> getHyperparameters() const {
        return {hyperparameters_, modelParameters_.C};
    }
 
 
    void fit(const method& method, const cmp::statistics::KFold& kf, const Eigen::Ref<const Eigen::MatrixXd>& xObs, const Eigen::Ref<const Eigen::VectorXs>& membershipTable, Eigen::VectorXd lb, Eigen::VectorXd ub, nlopt::algorithm algo = nlopt::LN_SBPLX, double ftol_rel = 1e-4, std::vector<bool> logScaleFlags = {});
 
    void fit(Eigen::Ref<const Eigen::MatrixXd> xObs, Eigen::Ref<const Eigen::VectorXs> membershipTable, Eigen::Ref<const Eigen::VectorXd> lb, Eigen::Ref<const Eigen::VectorXd> ub, nlopt::algorithm algo = nlopt::LN_SBPLX, double ftol_rel = 1e-4, std::vector<bool> logScaleFlags = {});
 
 
    double objectiveFunctionCV(const method& method, const cmp::statistics::KFold& kf);
 
    double objectiveFunctionSpan();
};
 
 
class Dummy : public Classifier {
  private :
    size_t nClasses_{1}; 
 
  public :
    void condition(const Eigen::Ref<const Eigen::MatrixXd> &xObs, const Eigen::Ref<const Eigen::VectorXs> &labels);
 
    size_t predict(const Eigen::Ref<const Eigen::VectorXd> &x) const override;
 
    std::vector<double> predictProbabilities(const Eigen::Ref<const Eigen::VectorXd> &x) const override;
 
};
 
} // namespace cmp::classifier
 
#endif // CLASSIFIER_H