multiclass_strategy.hpp

#pragma once
 
#include "types.hpp"
#include "kernel_parameters.hpp"
#include "data_converter.hpp"
#include <torch/torch.h>
#include <vector>
#include <memory>
#include <unordered_map>
 
// Forward declarations
struct svm_model;
struct model;
 
namespace svm_classifier {
 
    class MulticlassStrategyBase {
    public:
        virtual ~MulticlassStrategyBase() = default;
 
        virtual TrainingMetrics fit(const torch::Tensor& X,
            const torch::Tensor& y,
            const KernelParameters& params,
            DataConverter& converter) = 0;
 
        virtual std::vector<int> predict(const torch::Tensor& X,
            DataConverter& converter) = 0;
 
        virtual std::vector<std::vector<double>> predict_proba(const torch::Tensor& X,
            DataConverter& converter) = 0;
 
        virtual std::vector<std::vector<double>> decision_function(const torch::Tensor& X,
            DataConverter& converter) = 0;
 
        virtual std::vector<int> get_classes() const = 0;
 
        virtual bool supports_probability() const = 0;
 
        virtual int get_n_classes() const = 0;
 
        virtual MulticlassStrategy get_strategy_type() const = 0;
 
    protected:
        std::vector<int> classes_;  
        bool is_trained_ = false;   
    };
 
    class OneVsRestStrategy : public MulticlassStrategyBase {
    public:
        OneVsRestStrategy();
 
        ~OneVsRestStrategy() override;
 
        TrainingMetrics fit(const torch::Tensor& X,
            const torch::Tensor& y,
            const KernelParameters& params,
            DataConverter& converter) override;
 
        std::vector<int> predict(const torch::Tensor& X,
            DataConverter& converter) override;
 
        std::vector<std::vector<double>> predict_proba(const torch::Tensor& X,
            DataConverter& converter) override;
 
        std::vector<std::vector<double>> decision_function(const torch::Tensor& X,
            DataConverter& converter) override;
 
        std::vector<int> get_classes() const override { return classes_; }
 
        bool supports_probability() const override;
 
        int get_n_classes() const override { return static_cast<int>(classes_.size()); }
 
        MulticlassStrategy get_strategy_type() const override { return MulticlassStrategy::ONE_VS_REST; }
 
    private:
        std::vector<std::unique_ptr<svm_model>> svm_models_;      
        std::vector<std::unique_ptr<model>> linear_models_;       
        KernelParameters params_;                                 
        SVMLibrary library_type_;                                
 
        torch::Tensor create_binary_labels(const torch::Tensor& y, int positive_class);
 
        double train_binary_classifier(const torch::Tensor& X,
            const torch::Tensor& y_binary,
            const KernelParameters& params,
            DataConverter& converter,
            int class_idx);
 
        void cleanup_models();
    };
 
    class OneVsOneStrategy : public MulticlassStrategyBase {
    public:
        OneVsOneStrategy();
 
        ~OneVsOneStrategy() override;
 
        TrainingMetrics fit(const torch::Tensor& X,
            const torch::Tensor& y,
            const KernelParameters& params,
            DataConverter& converter) override;
 
        std::vector<int> predict(const torch::Tensor& X,
            DataConverter& converter) override;
 
        std::vector<std::vector<double>> predict_proba(const torch::Tensor& X,
            DataConverter& converter) override;
 
        std::vector<std::vector<double>> decision_function(const torch::Tensor& X,
            DataConverter& converter) override;
 
        std::vector<int> get_classes() const override { return classes_; }
 
        bool supports_probability() const override;
 
        int get_n_classes() const override { return static_cast<int>(classes_.size()); }
 
        MulticlassStrategy get_strategy_type() const override { return MulticlassStrategy::ONE_VS_ONE; }
 
    private:
        std::vector<std::unique_ptr<svm_model>> svm_models_;      
        std::vector<std::unique_ptr<model>> linear_models_;       
        std::vector<std::pair<int, int>> class_pairs_;           
        KernelParameters params_;                                 
        SVMLibrary library_type_;                                
 
        std::pair<torch::Tensor, torch::Tensor> extract_binary_data(const torch::Tensor& X,
            const torch::Tensor& y,
            int class1,
            int class2);
 
        double train_pairwise_classifier(const torch::Tensor& X,
            const torch::Tensor& y,
            int class1,
            int class2,
            const KernelParameters& params,
            DataConverter& converter,
            int model_idx);
 
        std::vector<int> vote_predictions(const std::vector<std::vector<double>>& decisions);
 
        void cleanup_models();
    };
 
    std::unique_ptr<MulticlassStrategyBase> create_multiclass_strategy(MulticlassStrategy strategy);
 
} // namespace svm_classifier