source: trunk/src/SVM.h @ 80

// $Id: SVM.h 80 2004-05-05 10:26:53Z peter $

#ifndef _theplu_cpptools_svm_ 
#define _theplu_cpptools_svm_ 

// C++ tools include
/////////////////////
#include "vector.h"
#include "matrix.h"

// Standard C++ includes
////////////////////////
#include <utility>
#include <vector>

namespace theplu {
namespace cpptools {  
  ///
  /// Class for SVM using Keerthi's second modification of Platt's SMO. Also
  /// the elements of the kernel is not computed sequentially, but the
  /// complete kernel matrix is taken as input and stored in memory. This
  /// means that the training is faster, but also that it is not possible to
  /// train a large number of samples N, since the memory cost for the kernel
  /// matrix is N^2. The SVM object does not contain any data, hence any true
  /// prediction is not possible.
  ///   
  class SVM
  {
  
  public:
    ///
    /// Constructor taking the kernel matrix and the target vector as input
    ///
    SVM(const gslapi::matrix&, const gslapi::vector&, 
        const std::vector<size_t> = std::vector<size_t>());
         
    ///
    /// Function returns \f$\alpha\f$
    ///
    inline gslapi::vector get_alpha(void) const { return alpha_; }

    ///
    /// Function returns the C-parameter 
    ///
    inline double get_c(void) const { return c_; }

    ///
    /// Function returns the output from SVM
    ///
    inline gslapi::vector get_output(void) const { return (kernel_ * alpha_.mul_elements(target_) + gslapi::vector(target_.size(),bias_) );}

    ///
    /// Changing the C-parameter
    ///
    inline void set_c(const double c) {c_ = c;}

    ///
    /// Training the SVM following Platt's SMO, with Keerti's
    /// modifacation. However the complete kernel is stored in memory. The
    /// reason for this is speed. When number of samples N is large this is
    /// not possible since the memory cost for the kernel scales N^2. In that
    /// case one should follow the SMO and calculate the kernel elements
    /// sequentially
    ///

    void train(void);
   
      
  private:
    gslapi::vector alpha_;
    double bias_;
    double c_;
    gslapi::matrix kernel_;
    gslapi::vector target_;
    bool trained_;
    std::vector<size_t> train_set_;
    double tolerance_;
    ///
    ///   Private function choosing which two elements that should be
    ///   updated. First checking for the biggest violation (output - target =
    ///   0) among support vectors (alpha!=0). If no violation was found check
    ///   for sequentially among the other samples. If no violation there as
    ///   well, stop_condition is fullfilled.
    ///
    
    std::pair<size_t, size_t> choose(const theplu::gslapi::vector&, 
                                  const std::vector<size_t>&, 
                                  const std::vector<size_t>&, 
                                  const theplu::gslapi::vector&,
                                  bool&);
    
    
  };




}} // of namespace cpptools and namespace theplu

#endif