source: trunk/test/svm_test.cc @ 1672

// $Id: svm_test.cc 1672 2008-12-22 13:27:20Z peter $

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

  This file is part of the yat library, http://dev.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 3 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 yat. If not, see <http://www.gnu.org/licenses/>.
*/

#include "Suite.h"

#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/MatrixLookup.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( int argc, char* argv[])
{  
  test::Suite suite(argc, argv);
  suite.err() << "testing svm" << std::endl;

  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++)
      suite.err() << kernel2(i,j) << " ";
    suite.err() << std::endl;
  }
  classifier::KernelLookup kv2(kernel2);
  suite.err() << "testing with linear kernel" << std::endl;
  assert(kv2.rows()==target2.size());
  classifier::SVM classifier2;
  suite.err() << "training...";
  classifier2.train(kv2, target2);
  suite.err() << " 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){
    suite.err() << "ERROR: found " << tmp << " expected zero" << std::endl;
    return -1;
  }

  // tol defined on learning precision
  double tol=1e-6;
  if (!suite.equal_fix(classifier2.alpha()(1), 2.0, tol) ||
      !suite.equal_fix(classifier2.alpha()(2), 2.0, tol) ) {
    suite.err() << "wrong alpha" << std::endl;
    suite.err() << "alpha: " << classifier2.alpha() <<  std::endl;
    suite.err() << "expected: 4 2 2" <<  std::endl;

    return -1;
  }

  

  std::ifstream is(test::filename("data/nm_data_centralized.txt").c_str());
  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(test::filename("data/nm_target_bin.txt").c_str());
  classifier::Target target(is);
  is.close();

  is.open(test::filename("data/nm_alpha_linear_matlab.txt").c_str());
  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
  if (!suite.equal_range_fix(alpha.begin(), alpha.end(),
                             alpha_matlab.begin(), 1e-6) ) {
    suite.err() << "Difference to matlab alphas too large\n";
    suite.add(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)){
        suite.err() << "Slack too large. Is the bias correct?\n";
        suite.err() << "slack: " << slack << std::endl;
        suite.err() << "expected less than " << slack_bound << std::endl;
        suite.add(false);
      }
    }
  }
  
  delete kf;
  delete kf2;

  return suite.return_value();
}