source: trunk/test/svm_test.cc @ 1121

// $Id: svm_test.cc 1121 2008-02-22 15:29:56Z peter $

/*
  Copyright (C) 2004, 2005 Jari Häkkinen, Peter Johansson
  Copyright (C) 2006 Jari Häkkinen, Markus Ringnér, Peter Johansson
  Copyright (C) 2007 Peter Johansson

  This file is part of the yat library, http://trac.thep.lu.se/yat

  The yat library is free software; you can redistribute it and/or
  modify it under the terms of the GNU General Public License as
  published by the Free Software Foundation; either version 2 of the
  License, or (at your option) any later version.

  The yat library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  02111-1307, USA.
*/

#include "yat/classifier/SVM.h"
#include "yat/classifier/Kernel.h"
#include "yat/classifier/KernelLookup.h"
#include "yat/classifier/Kernel_SEV.h"
#include "yat/classifier/Kernel_MEV.h"
#include "yat/classifier/PolynomialKernelFunction.h"
#include "yat/classifier/Target.h"
#include "yat/utility/Matrix.h"
#include "yat/utility/Vector.h"

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

using namespace theplu::yat;

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;

  utility::Matrix data2_core(2,3);
  data2_core(0,0)=0;
  data2_core(1,0)=0;
  data2_core(0,1)=0;
  data2_core(1,1)=1;
  data2_core(0,2)=1;
  data2_core(1,2)=0;
  classifier::MatrixLookup data2(data2_core);
  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);
  for (size_t i=0; i<3; i++){
    for (size_t j=0; j<3; j++)
      *error << kernel2(i,j) << " ";
    *error << std::endl;
  }
  classifier::KernelLookup kv2(kernel2);
  *error << "testing with linear kernel" << std::endl;
  assert(kv2.rows()==target2.size());
  classifier::SVM classifier2;
  *error << "training...";
  classifier2.train(kv2, target2);
  *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");
  utility::Matrix data_core(is);
  is.close();

  classifier::MatrixLookup data(data_core);

  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::yat::utility::Vector alpha_matlab(is);
  is.close();

  classifier::KernelLookup kv(kernel);
  theplu::yat::classifier::SVM svm;
  svm.train(kv, target);

  theplu::yat::utility::Vector alpha = svm.alpha();
      
  // Comparing alpha to alpha_matlab
  theplu::yat::utility::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::yat::utility::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 || std::isnan(slack)){
    *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;
  
}