source: trunk/test/svm_test.cc @ 514

// $Id: svm_test.cc 514 2006-02-20 09:45:34Z peter $

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

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

using namespace theplu;

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

  std::ostream* error;
  if (argc>1 && argv[1]==std::string("-v"))
    error = &std::cerr;
  else {
    error = new std::ofstream("/dev/null");
    if (argc>1)
      std::cout << "svm_test -v : for printing extra information\n";
  }
  *error << "testing svm" << std::endl;
  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;
  std::vector<std::string> label;
  label.reserve(3);
  label.push_back("-1");
  label.push_back("1");
  label.push_back("1");
  classifier::Target target2(label);
  classifier::KernelFunction* kf2 = new classifier::PolynomialKernelFunction(); 
  classifier::Kernel_MEV kernel2(data2,*kf2);
  assert(kernel2.size()==3);
  assert(target2.size()==3);
  classifier::KernelLookup kv2(kernel2);
  *error << "testing with linear kernel" << std::endl;
  assert(kv2.rows()==target2.size());
  classifier::SVM classifier2(kv2, target2);
  *error << "training...";
  classifier2.train();
  *error << " done!" << std::endl;

  double tmp=0;
  for (size_t i=0; i<target2.size(); i++) 
    if (target2.binary(i))
      tmp += classifier2.alpha()(i);
    else
      tmp -= classifier2.alpha()(i);

  if (tmp){
    *error << "ERROR: found " << tmp << " expected zero" << std::endl;
    return -1;
  }

  double tol=1e-6;
  if (fabs(classifier2.alpha()(1)-2)>tol || 
      fabs(classifier2.alpha()(2)-2)>tol){
    *error << "wrong alpha" << std::endl;
    *error << "alpha: " << classifier2.alpha() <<  std::endl;
    *error << "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;

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


  is.open("data/nm_target_bin.txt");
  classifier::Target target(is);
  is.close();

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

  classifier::KernelLookup kv(kernel);
  theplu::classifier::SVM svm(kv, target);
  if (!svm.train()){
    ok=false;
    *error << "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 ){
    *error << "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){
      if (target.binary(i))
        slack += 1 - output(i);
      else
        slack += 1 + output(i);
    }
  }
  double slack_bound=2e-7;
  if (slack > slack_bound){
    *error << "Slack too large. Is the bias correct?\n";
    *error << "slack: " << slack << std::endl;
    *error << "expected less than " << slack_bound << std::endl;
    ok = false;
  }
  
  delete kf;
  delete kf2;

  if (error!=&std::cerr)
    delete error;

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