source: trunk/test/svm_test.cc @ 442

// $Id: svm_test.cc 442 2005-12-15 14:17:53Z jari $

#include <c++_tools/gslapi/matrix.h>
#include <c++_tools/gslapi/vector.h>
#include <c++_tools/svm/SVM.h>
#include <c++_tools/svm/Kernel.h>
#include <c++_tools/svm/Kernel_SEV.h>
#include <c++_tools/svm/Kernel_MEV.h>
#include <c++_tools/svm/PolynomialKernelFunction.h>

#include <cassert>
#include <fstream>
#include <iostream>
#include <cstdlib>
#include <limits>

using namespace theplu;

int main(const int argc,const char* argv[])
{  

  bool print = (argc>1 && argv[1]==std::string("-p"));
  bool ok = true;

  gslapi::matrix data2(2,3);
  data2(0,0)=0;
  data2(1,0)=0;
  data2(0,1)=0;
  data2(1,1)=1;
  data2(0,2)=1;
  data2(1,2)=0;
  gslapi::vector target2(3);
  target2(0)=-1;
  target2(1)=1;
  target2(2)=1;
  svm::KernelFunction* kf2 = new svm::PolynomialKernelFunction(); 
  svm::Kernel_MEV kernel2(data2,*kf2);
  assert(kernel2.size()==3);
  svm::SVM svm2(kernel2, target2);
  svm2.train();

  if (svm2.alpha()*target2){
    std::cerr << "condition not fullfilled" << std::endl;
    return -1;
  }

  if (svm2.alpha()(1)!=2 || svm2.alpha()(2)!=2){
    std::cerr << "wrong alpha" << std::endl;
    std::cerr << "alpha: " << svm2.alpha() <<  std::endl;
    std::cerr << "expected: 4 2 2" <<  std::endl;

    return -1;
  }

  

  std::ifstream is("data/nm_data_centralized.txt");
  gslapi::matrix transposed_data(is);
  is.close();
  // Because how the kernel is treated is changed, data must be transposed.
  gslapi::matrix data=transposed_data;

  svm::KernelFunction* kf = new svm::PolynomialKernelFunction(); 
  svm::Kernel_SEV kernel(data,*kf);


  is.open("data/nm_target_bin.txt");
  theplu::gslapi::vector target(is);
  is.close();

  is.open("data/nm_alpha_linear_matlab.txt");
  theplu::gslapi::vector alpha_matlab(is);
  is.close();

  theplu::svm::SVM svm(kernel, target);
  if (!svm.train()){
    ok=false;
    if (print)
      std::cerr << "Training failured" << std::endl;
  }

  theplu::gslapi::vector alpha = svm.alpha();
      
  // Comparing alpha to alpha_matlab
  theplu::gslapi::vector diff_alpha(alpha);
  diff_alpha-=alpha_matlab;
  if (diff_alpha*diff_alpha> 1e-10 ){
    if (print) 
      std::cerr << "Difference to matlab alphas too large\n";
    ok=false;
  }

  // Comparing output to target
  theplu::gslapi::vector output(svm.output());
  double slack = 0;
  for (unsigned int i=0; i<target.size(); i++){
    if (output[i]*target[i] < 1){
      slack += 1 - output[i]*target[i];
    }
  }
  double slack_bound=2e-7;
  if (slack > slack_bound){
    if (print){
      std::cerr << "Slack too large. Is the bias correct?\n";
      std::cerr << "slack: " << slack << std::endl;
      std::cerr << "expected less than " << slack_bound << std::endl;
    }
    ok = false;
  }
  
  delete kf;
  delete kf2;

  if(ok)
    return 0;
  return -1;
  
}