kernel_parameters.hpp

#pragma once
 
#include "types.hpp"
#include <torch/torch.h>
#include <vector>
#include <memory>
 
// Forward declarations for libsvm and liblinear structures
struct svm_node;
struct svm_problem;
struct feature_node;
struct problem;
 
namespace svm_classifier {
 
    class DataConverter {
    public:
        DataConverter();
 
        ~DataConverter();
 
        std::unique_ptr<svm_problem> to_svm_problem(const torch::Tensor& X,
            const torch::Tensor& y = torch::Tensor());
 
        std::unique_ptr<problem> to_linear_problem(const torch::Tensor& X,
            const torch::Tensor& y = torch::Tensor());
 
        svm_node* to_svm_node(const torch::Tensor& sample);
 
        feature_node* to_feature_node(const torch::Tensor& sample);
 
        torch::Tensor from_predictions(const std::vector<double>& predictions);
 
        torch::Tensor from_probabilities(const std::vector<std::vector<double>>& probabilities);
 
        torch::Tensor from_decision_values(const std::vector<std::vector<double>>& decision_values);
 
        void validate_tensors(const torch::Tensor& X, const torch::Tensor& y = torch::Tensor());
 
        int get_n_features() const { return n_features_; }
 
        int get_n_samples() const { return n_samples_; }
 
        void cleanup();
 
        void set_sparse_threshold(double threshold) { sparse_threshold_ = threshold; }
 
        double get_sparse_threshold() const { return sparse_threshold_; }
 
    private:
        int n_features_;     
        int n_samples_;      
        double sparse_threshold_;  
 
        // Memory management for libsvm structures
        std::vector<std::vector<svm_node>> svm_nodes_storage_;
        std::vector<svm_node*> svm_x_space_;
        std::vector<double> svm_y_space_;
 
        // Memory management for liblinear structures
        std::vector<std::vector<feature_node>> linear_nodes_storage_;
        std::vector<feature_node*> linear_x_space_;
        std::vector<double> linear_y_space_;
 
        // Single sample storage (for prediction)
        std::vector<svm_node> single_svm_nodes_;
        std::vector<feature_node> single_linear_nodes_;
 
        std::vector<std::vector<svm_node>> tensor_to_svm_nodes(const torch::Tensor& X);
 
        std::vector<std::vector<feature_node>> tensor_to_linear_nodes(const torch::Tensor& X);
 
        std::vector<svm_node> sample_to_svm_nodes(const torch::Tensor& sample);
 
        std::vector<feature_node> sample_to_linear_nodes(const torch::Tensor& sample);
 
        std::vector<double> extract_labels(const torch::Tensor& y);
 
        torch::Tensor ensure_cpu_tensor(const torch::Tensor& tensor);
 
        void validate_tensor_properties(const torch::Tensor& tensor, int expected_dims, const std::string& name);
    };
 
} // namespace svm_classifier