SVMClassifier/multiclass__strategy_8hpp_source.html at gh-pages

Files
rmontanana a1bf986365 deploy: d6dc083a5a
2025-06-22 11:25:27 +00:00
51 KiB

Raw Permalink 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 <torch/torch.h>
    7#include <vector>
    8#include <memory>
    9#include <unordered_map>

   11// Forward declarations
   12struct svm_model;
   13struct model;

   15namespace 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);

  264} // namespace svm_classifier
Generated on Sun Jun 22 2025 11:25:27 for SVM Classifier C++ by
1.9.8 </html>
51 KiB Raw Permalink Blame History

51 KiB

Raw Permalink Blame History
