svm_classifier.hpp

#pragma once
 
#include "types.hpp"
#include "kernel_parameters.hpp"
#include "data_converter.hpp"
#include "multiclass_strategy.hpp"
#include <torch/torch.h>
#include <nlohmann/json.hpp>
#include <memory>
#include <string>
 
namespace svm_classifier {
 
    class SVMClassifier {
    public:
        SVMClassifier();
 
        explicit SVMClassifier(const nlohmann::json& config);
 
        SVMClassifier(KernelType kernel,
            double C = 1.0,
            MulticlassStrategy multiclass_strategy = MulticlassStrategy::ONE_VS_REST);
 
        ~SVMClassifier();
 
        SVMClassifier(const SVMClassifier&) = delete;
 
        SVMClassifier& operator=(const SVMClassifier&) = delete;
 
        SVMClassifier(SVMClassifier&&) noexcept;
 
        SVMClassifier& operator=(SVMClassifier&&) noexcept;
 
        TrainingMetrics fit(const torch::Tensor& X, const torch::Tensor& y);
 
        torch::Tensor predict(const torch::Tensor& X);
 
        torch::Tensor predict_proba(const torch::Tensor& X);
 
        torch::Tensor decision_function(const torch::Tensor& X);
 
        double score(const torch::Tensor& X, const torch::Tensor& y_true);
 
        EvaluationMetrics evaluate(const torch::Tensor& X, const torch::Tensor& y_true);
 
        void set_parameters(const nlohmann::json& config);
 
        nlohmann::json get_parameters() const;
 
        bool is_fitted() const { return is_fitted_; }
 
        int get_n_classes() const;
 
        std::vector<int> get_classes() const;
 
        int get_n_features() const { return n_features_; }
 
        TrainingMetrics get_training_metrics() const { return training_metrics_; }
 
        bool supports_probability() const;
 
        void save_model(const std::string& filename) const;
 
        void load_model(const std::string& filename);
 
        KernelType get_kernel_type() const { return params_.get_kernel_type(); }
 
        MulticlassStrategy get_multiclass_strategy() const { return params_.get_multiclass_strategy(); }
 
        SVMLibrary get_svm_library() const { return get_svm_library(params_.get_kernel_type()); }
 
        std::vector<double> cross_validate(const torch::Tensor& X,
            const torch::Tensor& y,
            int cv = 5);
 
        nlohmann::json grid_search(const torch::Tensor& X,
            const torch::Tensor& y,
            const nlohmann::json& param_grid,
            int cv = 5);
 
        torch::Tensor get_feature_importance() const;
 
        void reset();
 
    private:
        KernelParameters params_;                                    
        std::unique_ptr<MulticlassStrategyBase> multiclass_strategy_; 
        std::unique_ptr<DataConverter> data_converter_;              
 
        bool is_fitted_;                                            
        int n_features_;                                            
        TrainingMetrics training_metrics_;                          
 
        void validate_input(const torch::Tensor& X,
            const torch::Tensor& y = torch::Tensor(),
            bool check_fitted = false);
 
        void initialize_multiclass_strategy();
 
        std::vector<std::vector<int>> calculate_confusion_matrix(const std::vector<int>& y_true,
            const std::vector<int>& y_pred);
 
        std::tuple<double, double, double> calculate_metrics_from_confusion_matrix(
            const std::vector<std::vector<int>>& confusion_matrix);
 
        std::tuple<torch::Tensor, torch::Tensor, torch::Tensor, torch::Tensor>
            split_for_cv(const torch::Tensor& X, const torch::Tensor& y, int fold, int n_folds);
 
        std::vector<nlohmann::json> generate_param_combinations(const nlohmann::json& param_grid);
    };
 
} // namespace svm_classifier