source: trunk/lib/svm/SVM.h @ 295

// $Id: SVM.h 295 2005-04-29 09:15:58Z peter $

#ifndef _theplu_svm_svm_ 
#define _theplu_svm_svm_ 

#include <c++_tools/svm/Kernel.h>
#include <c++_tools/gslapi/vector.h>

#include <utility>
#include <vector>


namespace theplu {
namespace svm {  
  ///
  /// 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 Kernel&, 
        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_; }

    ///
    /// @return number of maximal epochs
    ///
    inline long int max_epochs(void) const {return max_epochs_;}
    
    ///
    /// Changing number of maximal epochs
    ///
    inline void max_epochs(const unsigned long int d) {max_epochs_=d;} 
    
    ///
    /// @return output
    ///
    inline theplu::gslapi::vector output(void) 
    {return kernel_.get() * alpha_.mul(target_)+
       theplu::gslapi::vector(alpha_.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. Minimizing \f$
    /// \frac{1}{2}\sum
    /// y_iy_j\alpha_i\alpha_j(K_{ij}+\frac{1}{C_i}\delta_{ij}) \f$,
    /// which corresponds to minimizing \f$ \sum w_i^2+\sum
    /// C_i\xi_i^2 \f$
    ///

    bool train(void);
   
      
  private:
    gslapi::vector alpha_;
    double bias_;
    double c_;
    Kernel kernel_; // Peter, const ref?
    unsigned long int max_epochs_;
    gslapi::vector target_; // Peter, const ref?
    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 theplu::gslapi::vector&,
                                     const theplu::gslapi::vector&,
                                     bool&);

        
    
  };




}} // of namespace svm and namespace theplu

#endif