source: trunk/test/kernel_test.cc @ 1238

// $Id: kernel_test.cc 1238 2008-03-15 18:03:05Z peter $

/*
  Copyright (C) 2004, 2005 Jari Häkkinen, Peter Johansson
  Copyright (C) 2006 Jari Häkkinen, Markus Ringnér, Peter Johansson
  Copyright (C) 2007 Jari Häkkinen, 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 "Suite.h"

#include "yat/utility/Matrix.h"
#include "yat/classifier/KernelFunction.h"
#include "yat/classifier/PolynomialKernelFunction.h"
#include "yat/classifier/GaussianKernelFunction.h"
#include "yat/classifier/KernelLookup.h"
#include "yat/classifier/Kernel_MEV.h"
#include "yat/classifier/Kernel_SEV.h"
#include "yat/classifier/MatrixLookup.h"

#include <cassert>
#include <cmath>
#include <cstdlib>
#include <fstream>
#include <iostream>
#include <vector>

using namespace theplu::yat;

bool test_MEV(const classifier::MatrixLookup& data, 
              const classifier::KernelFunction* kf, 
              const utility::Matrix& control, const double error_bound,
              test::Suite& suite);

bool test_SEV(const classifier::MatrixLookup& data, 
              const classifier::KernelFunction* kf, 
              const utility::Matrix& control, const double error_bound,
              test::Suite& suite);


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

{  
  test::Suite suite(argc, argv);
  suite.err() << "testing kernels" << 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);
  classifier::KernelFunction* kf2 = new classifier::PolynomialKernelFunction(); 
  classifier::Kernel_SEV kernel2(data2,*kf2);
  assert(kernel2.size()==3);
  if(kernel2(0,0) || kernel2(0,1) || kernel2(0,2) || 
     kernel2(1,0) || kernel2(1,1)!=1 || kernel2(1,2) || 
     kernel2(2,0) || kernel2(2,1) || kernel2(2,2)!=1){
    suite.add(false);
    suite.err() << "Found:\n";
    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;
    }
    suite.err() << "Expected:\n0 0 0\n0 1 0\n0 0 1" << std::endl;
  }
  classifier::KernelLookup kv2(kernel2);
  delete kf2;

  // Peter, the hardcoded number below reflects precision in files
  // containing kernel matrices calculated in matlab.
  double error_bound = 1e-6; 
  std::ifstream is("data/nm_data_centralized.txt");
  utility::Matrix data_core(is);
  is.close();

  classifier::MatrixLookup data(data_core);

  is.open("data/nm_kernel.txt");
  utility::Matrix kernel_matlab(is);
  is.close();
  classifier::KernelFunction* kf = new classifier::PolynomialKernelFunction(); 
  suite.add(test_MEV(data,kf,kernel_matlab,error_bound, suite) &&
            test_SEV(data,kf,kernel_matlab,error_bound, suite));
  delete kf;
  
  is.open("data/nm_kernel2.txt");
  utility::Matrix kernel_matlab2(is);
  is.close();
  kf = new classifier::PolynomialKernelFunction(2); 
  suite.add(test_MEV(data,kf,kernel_matlab2,error_bound, suite) &&
            test_SEV(data,kf,kernel_matlab2,error_bound, suite));
  delete kf;

  // Checking that GaussianKernelFunction.
  suite.err() << "Checking GaussianKernelFunction.\n";
  is.open("data/nm_kernel_gaussian.txt");
  utility::Matrix kernel_gaussian(is);
  is.close();
  kf = new classifier::GaussianKernelFunction(100); 
  suite.add(test_MEV(data,kf,kernel_gaussian,error_bound, suite));
  suite.add(test_SEV(data,kf,kernel_gaussian,error_bound, suite));
  delete kf;

  data_core.resize(1,5);
  for (size_t i=0; i<data_core.columns(); i++)
    data_core(0,i)=i;
  data = classifier::MatrixLookup(data_core);
  classifier::PolynomialKernelFunction pkf;
  classifier::Kernel_SEV kernel(data,pkf);
  
  return suite.return_value();
}

bool test_MEV(const classifier::MatrixLookup& data, 
              const classifier::KernelFunction* kf, 
              const utility::Matrix& control, const double error_bound,
              test::Suite& suite)
{
  suite.err() << "testing Kernel_MEV" << std::endl;
  classifier::Kernel_MEV kernel(data,*kf);
  for(u_int i=0;i<control.rows();i++)
    for(u_int j=0;j<control.columns();j++)
      if (std::abs(kernel(i,j)-control(i,j))>error_bound){
        suite.err() << "ERROR: comparing kernel(" << i << "," << j << "): "
                    << kernel(i,j)
                    << "\n and control(" << i << "," << j << "): "
                    << control(i,j) << "\n"
                    << "difference: " << kernel(i,j)-control(i,j) << "\n"
                    << "expected less than " << error_bound << "\n";
        return false;
      }
  // checking view
  std::vector<size_t> index_vec(3);
  index_vec[0]=1;
  index_vec[1]=2;
  index_vec[2]=3;
  utility::Index index(index_vec);
  classifier::KernelLookup kv_raw(kernel);
  classifier::KernelLookup kv(kv_raw,index,index);
  if (kv.rows()!=index.size()){
    suite.err() << "Error: KernelLookup(kernel, index)\n"
                << "Size of KernelLookup is " << kv.rows() << "\n"
                << "expected " << index.size() << std::endl;
    
    return false;
  }
  classifier::KernelLookup kv2(kernel);
  if (kv2.rows()!=kernel.size()){
    suite.err() << "Error: KernelLookup(kernel)\n" << std::endl
           << "Size of KernelLookup is " << kv.rows() << std::endl
           << "expected " << kernel.size() << std::endl;
    
    return false;
  }
  return true;
}

bool test_SEV(const classifier::MatrixLookup& data, 
              const classifier::KernelFunction* kf, 
              const utility::Matrix& control, const double error_bound,
              test::Suite& suite)
{
  suite.err() << "testing Kernel_SEV" << std::endl;
  classifier::Kernel_SEV kernel(data,*kf);
  for(u_int i=0;i<control.rows();i++)
    for(u_int j=0;j<control.columns();j++)
      if (std::abs(kernel(i,j)-control(i,j))>error_bound){
        suite.err() << "ERROR: comparing kernel(" << i << "," << j << "): "
                    << kernel(i,j)
                    << "\n and control(" << i << "," << j << "): "
                    << control(i,j) << "\n"
                    << "difference: " << kernel(i,j)-control(i,j) << "\n"
                    << "expected less than " << error_bound << "\n";
        return false;
      }

  // checking view
  std::vector<size_t> index_vec(3);
  index_vec[0]=1;
  index_vec[1]=2;
  index_vec[2]=3;
  utility::Index index(index_vec);
  classifier::KernelLookup kv_raw(kernel);
  classifier::KernelLookup kv(kv_raw,index, index);
  if (kv.rows()!=index.size()){
    suite.err() << "Error: KernelLookup(kernel, index)\n" << std::endl
           << "Size of KernelLookup is " << kv.rows() << std::endl
           << "expected " << index.size() << std::endl;
    
    return false;
  }
  classifier::KernelLookup kv2(kernel);
  if (kv2.rows()!=kernel.size()){
    suite.err() << "Error: KernelLookup(kernel)\n" << std::endl
           << "Size of KernelLookup is " << kv.rows() << std::endl
           << "expected " << kernel.size() << std::endl;
    
    return false;
  }
  return true;
}