SVMClassifier/svm__classifier_8hpp_source.html at a1bf986365165e8446561ec3391d56af63cafa02

Files

rmontanana a1bf986365 deploy: d6dc083a5a

2025-06-22 11:25:27 +00:00

41 KiB

Raw Blame History

SVM Classifier C++ 1.0.0

High-performance Support Vector Machine classifier with scikit-learn compatible API

Searching...

No Matches

    1#pragma once

    3#include "types.hpp"
    4#include "kernel_parameters.hpp"
    5#include "data_converter.hpp"
    6#include "multiclass_strategy.hpp"
    7#include <torch/torch.h>
    8#include <nlohmann/json.hpp>
    9#include <memory>
   10#include <string>

   12namespace 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);
  };

  297} // namespace svm_classifier

Generated on Sun Jun 22 2025 11:25:27 for SVM Classifier C++ by

1.9.8 </html>

41 KiB Raw Blame History

41 KiB

Raw Blame History