dlib C++ Library - ekm_and_lisf.cpp

// Copyright (C) 2009 Davis E. King (davis@dlib.net)
// License: Boost Software License See LICENSE.txt for the full license.
#include "tester.h"
#include <dlib/svm.h>
#include <dlib/rand.h>
#include <dlib/string.h>
#include <vector>
#include <sstream>
#include <ctime>
namespace 
{
 using namespace test;
 using namespace dlib;
 using namespace std;
 dlib::logger dlog("test.ekm_and_lisf");
 class empirical_kernel_map_tester : public tester
 {
 /*!
 WHAT THIS OBJECT REPRESENTS
 This object represents a unit test. When it is constructed
 it adds itself into the testing framework.
 !*/
 public:
 empirical_kernel_map_tester (
 ) :
 tester (
 "test_ekm_and_lisf", // the command line argument name for this test
 "Run tests on the empirical_kernel_map and linearly_independent_subset_finder objects.", // the command line argument description
 0 // the number of command line arguments for this test
 )
 {
 thetime = time(0);
 }
 time_t thetime;
 dlib::rand rnd;
 template <typename T>
 void validate (
 const T& ekm_small,
 const T& ekm_big
 )
 {
 matrix<double> tmat;
 projection_function<typename T::kernel_type> proj;
 ekm_small.get_transformation_to(ekm_big, tmat, proj);
 DLIB_TEST(tmat.nr() == ekm_big.out_vector_size());
 DLIB_TEST(tmat.nc() == ekm_small.out_vector_size());
 DLIB_TEST((unsigned long)proj.basis_vectors.size() == ekm_big.basis_size() - ekm_small.basis_size());
 for (unsigned long i = 0; i < 6; ++i)
 {
 const typename T::sample_type temp = randm(4,1,rnd);
 DLIB_TEST(length(ekm_big.project(temp) - (tmat*ekm_small.project(temp) + proj(temp))) < 1e-10);
 }
 }
 void test_transformation_stuff()
 {
 typedef matrix<double,0,1> sample_type;
 typedef radial_basis_kernel<sample_type> kernel_type;
 const kernel_type kern(1);
 for (unsigned long n = 1; n < 6; ++n)
 {
 print_spinner();
 for (unsigned long extra = 1; extra < 10; ++extra)
 {
 std::vector<sample_type> samps_small, samps_big;
 linearly_independent_subset_finder<kernel_type> lisf_small(kern, 1000);
 linearly_independent_subset_finder<kernel_type> lisf_big(kern, 1000);
 for (unsigned long i = 0; i < n; ++i)
 {
 samps_small.push_back(randm(4,1,rnd));
 samps_big.push_back(samps_small.back());
 lisf_big.add(samps_small.back());
 lisf_small.add(samps_small.back());
 }
 for (unsigned long i = 0; i < extra; ++i)
 {
 samps_big.push_back(randm(4,1,rnd));
 lisf_big.add(samps_big.back());
 }
 // test no lisf
 {
 empirical_kernel_map<kernel_type> ekm_small, ekm_big;
 ekm_small.load(kern, samps_small);
 ekm_big.load(kern, samps_big);
 validate(ekm_small, ekm_big);
 }
 // test with lisf
 {
 empirical_kernel_map<kernel_type> ekm_small, ekm_big;
 ekm_small.load(lisf_small);
 ekm_big.load(lisf_big);
 validate(ekm_small, ekm_big);
 }
 // test with partly lisf
 {
 empirical_kernel_map<kernel_type> ekm_small, ekm_big;
 ekm_small.load(kern, samps_small);
 ekm_big.load(lisf_big);
 validate(ekm_small, ekm_big);
 }
 // test with partly lisf
 {
 empirical_kernel_map<kernel_type> ekm_small, ekm_big;
 ekm_small.load(lisf_small);
 ekm_big.load(kern, samps_big);
 validate(ekm_small, ekm_big);
 }
 }
 }
 // test what happens if the bigger ekm only has repeated basis vectors
 {
 empirical_kernel_map<kernel_type> ekm_big, ekm_small;
 std::vector<sample_type> samps_big, samps_small;
 sample_type temp = randm(4,1,rnd);
 samps_small.push_back(temp);
 samps_big.push_back(temp);
 samps_big.push_back(temp);
 ekm_big.load(kern, samps_big);
 ekm_small.load(kern, samps_small);
 validate(ekm_small, ekm_big);
 }
 {
 empirical_kernel_map<kernel_type> ekm_big, ekm_small;
 linearly_independent_subset_finder<kernel_type> lisf_small(kern, 1000);
 std::vector<sample_type> samps_big;
 sample_type temp = randm(4,1,rnd);
 lisf_small.add(temp);
 samps_big.push_back(temp);
 samps_big.push_back(temp);
 ekm_big.load(kern, samps_big);
 ekm_small.load(lisf_small);
 validate(ekm_small, ekm_big);
 }
 {
 empirical_kernel_map<kernel_type> ekm_big, ekm_small;
 std::vector<sample_type> samps_big, samps_small;
 sample_type temp = randm(4,1,rnd);
 sample_type temp2 = randm(4,1,rnd);
 samps_small.push_back(temp);
 samps_small.push_back(temp2);
 samps_big.push_back(temp);
 samps_big.push_back(temp2);
 samps_big.push_back(randm(4,1,rnd));
 ekm_big.load(kern, samps_big);
 ekm_small.load(kern, samps_small);
 validate(ekm_small, ekm_big);
 }
 {
 empirical_kernel_map<kernel_type> ekm_big, ekm_small;
 linearly_independent_subset_finder<kernel_type> lisf_small(kern, 1000);
 std::vector<sample_type> samps_big;
 sample_type temp = randm(4,1,rnd);
 sample_type temp2 = randm(4,1,rnd);
 lisf_small.add(temp);
 lisf_small.add(temp2);
 samps_big.push_back(temp);
 samps_big.push_back(temp2);
 samps_big.push_back(temp);
 ekm_big.load(kern, samps_big);
 ekm_small.load(lisf_small);
 validate(ekm_small, ekm_big);
 }
 }
 void perform_test (
 )
 {
 ++thetime;
 typedef matrix<double,0,1> sample_type;
 //dlog << LINFO << "time seed: " << thetime;
 //rnd.set_seed(cast_to_string(thetime));
 typedef radial_basis_kernel<sample_type> kernel_type;
 for (int n = 1; n < 10; ++n)
 {
 print_spinner();
 dlog << LINFO << "matrix size " << n;
 std::vector<sample_type> samples;
 // make some samples
 for (int i = 0; i < n; ++i)
 {
 samples.push_back(randm(4,1,rnd));
 // double up the samples just to mess with the lisf
 if (n > 5)
 samples.push_back(samples.back());
 }
 dlog << LINFO << "samples.size(): "<< samples.size();
 const kernel_type kern(1);
 linearly_independent_subset_finder<kernel_type> lisf(kern, 100, 1e-4);
 unsigned long count = 0;
 for (unsigned long i = 0; i < samples.size(); ++i)
 {
 if (lisf.add(samples[i]))
 {
 DLIB_TEST(equal(lisf[lisf.size()-1], samples[i]));
 ++count;
 }
 }
 DLIB_TEST(count == lisf.size());
 DLIB_TEST(lisf.size() == (unsigned int)n);
 dlog << LINFO << "lisf.size(): "<< lisf.size();
 // make sure the kernel matrices coming out of the lisf are correct
 DLIB_TEST(dlib::equal(lisf.get_kernel_matrix(), kernel_matrix(kern, lisf), 1e-8));
 DLIB_TEST(dlib::equal(lisf.get_inv_kernel_marix(), inv(kernel_matrix(kern, lisf.get_dictionary())), 1e-8));
 empirical_kernel_map<kernel_type> ekm;
 ekm.load(lisf);
 DLIB_TEST(ekm.basis_size() == lisf.size());
 std::vector<sample_type> proj_samples;
 for (unsigned long i = 0; i < samples.size(); ++i)
 {
 double err;
 proj_samples.push_back(ekm.project(samples[i], err));
 DLIB_TEST(err <= 1e-4);
 const double error_agreement = std::abs(err - lisf.projection_error(samples[i]));
 dlog << LTRACE << "err: " << err << " error_agreement: "<< error_agreement;
 DLIB_TEST(error_agreement < 1e-11);
 }
 for (int i = 0; i < 5; ++i)
 {
 sample_type temp = randm(4,1,rnd);
 double err;
 ekm.project(temp, err);
 const double error_agreement = std::abs(err - lisf.projection_error(temp));
 dlog << LTRACE << "err: " << err << " error_agreement: "<< error_agreement;
 DLIB_TEST(error_agreement < 1e-11);
 }
 // make sure the EKM did the projection correctly
 DLIB_TEST(dlib::equal(kernel_matrix(kern, samples), kernel_matrix(linear_kernel<sample_type>(), proj_samples), 1e-5));
 }
 test_transformation_stuff();
 }
 };
 // Create an instance of this object. Doing this causes this test
 // to be automatically inserted into the testing framework whenever this cpp file
 // is linked into the project. Note that since we are inside an unnamed-namespace 
 // we won't get any linker errors about the symbol a being defined multiple times. 
 empirical_kernel_map_tester a;
}