// Copyright (C) 2012 Davis E. King (davis@dlib.net)
// License: Boost Software License See LICENSE.txt for the full license.
#include <dlib/svm.h>
#include <dlib/rand.h>
#include <sstream>
#include <string>
#include <cstdlib>
#include <ctime>
#include <map>
#include "tester.h"
namespace
{
using namespace test;
using namespace dlib;
using namespace std;
logger dlog("test.ranking");
// ----------------------------------------------------------------------------------------
template <typename T>
void brute_force_count_ranking_inversions (
const std::vector<T>& x,
const std::vector<T>& y,
std::vector<unsigned long>& x_count,
std::vector<unsigned long>& y_count
)
{
x_count.assign(x.size(),0);
y_count.assign(y.size(),0);
for (unsigned long i = 0; i < x.size(); ++i)
{
for (unsigned long j = 0; j < y.size(); ++j)
{
if (x[i] <= y[j])
{
x_count[i]++;
y_count[j]++;
}
}
}
}
// ----------------------------------------------------------------------------------------
void test_count_ranking_inversions()
{
print_spinner();
dlog << LINFO << "in test_count_ranking_inversions()";
dlib::rand rnd;
std::vector<int> x, y;
std::vector<unsigned long> x_count, y_count;
std::vector<unsigned long> x_count2, y_count2;
for (int iter = 0; iter < 5000; ++iter)
{
x.resize(rnd.get_random_32bit_number()%10);
y.resize(rnd.get_random_32bit_number()%10);
for (unsigned long i = 0; i < x.size(); ++i)
x[i] = ((int)rnd.get_random_32bit_number()%10) - 5;
for (unsigned long i = 0; i < y.size(); ++i)
y[i] = ((int)rnd.get_random_32bit_number()%10) - 5;
count_ranking_inversions(x, y, x_count, y_count);
brute_force_count_ranking_inversions(x, y, x_count2, y_count2);
DLIB_TEST(mat(x_count) == mat(x_count2));
DLIB_TEST(mat(y_count) == mat(y_count2));
}
}
// ----------------------------------------------------------------------------------------
void run_prior_test()
{
print_spinner();
typedef matrix<double,3,1> sample_type;
typedef linear_kernel<sample_type> kernel_type;
svm_rank_trainer<kernel_type> trainer;
ranking_pair<sample_type> data;
sample_type samp;
samp = 0, 0, 1; data.relevant.push_back(samp);
samp = 0, 1, 0; data.nonrelevant.push_back(samp);
trainer.set_c(10);
decision_function<kernel_type> df = trainer.train(data);
trainer.set_prior(df);
data.relevant.clear();
data.nonrelevant.clear();
samp = 1, 0, 0; data.relevant.push_back(samp);
samp = 0, 1, 0; data.nonrelevant.push_back(samp);
df = trainer.train(data);
dlog << LINFO << trans(df.basis_vectors(0));
DLIB_TEST(df.basis_vectors(0)(0) > 0);
DLIB_TEST(df.basis_vectors(0)(1) < 0);
DLIB_TEST(df.basis_vectors(0)(2) > 0);
}
// ----------------------------------------------------------------------------------------
void run_prior_sparse_test()
{
print_spinner();
typedef std::map<unsigned long,double> sample_type;
typedef sparse_linear_kernel<sample_type> kernel_type;
svm_rank_trainer<kernel_type> trainer;
ranking_pair<sample_type> data;
sample_type samp;
samp[0] = 1; data.relevant.push_back(samp); samp.clear();
samp[1] = 1; data.nonrelevant.push_back(samp); samp.clear();
trainer.set_c(10);
decision_function<kernel_type> df = trainer.train(data);
trainer.set_prior(df);
data.relevant.clear();
data.nonrelevant.clear();
samp[2] = 1; data.relevant.push_back(samp); samp.clear();
samp[1] = 1; data.nonrelevant.push_back(samp); samp.clear();
df = trainer.train(data);
matrix<double,0,1> w = sparse_to_dense(df.basis_vectors(0));
dlog << LINFO << trans(w);
DLIB_TEST(w(0) > 0.1);
DLIB_TEST(w(1) < -0.1);
DLIB_TEST(w(2) > 0.1);
}
// ----------------------------------------------------------------------------------------
void dotest1()
{
print_spinner();
dlog << LINFO << "in dotest1()";
typedef matrix<double,4,1> sample_type;
typedef linear_kernel<sample_type> kernel_type;
svm_rank_trainer<kernel_type> trainer;
std::vector<ranking_pair<sample_type> > samples;
ranking_pair<sample_type> p;
sample_type samp;
samp = 0, 0, 0, 1; p.relevant.push_back(samp);
samp = 1, 0, 0, 0; p.nonrelevant.push_back(samp);
samples.push_back(p);
samp = 0, 0, 1, 0; p.relevant.push_back(samp);
samp = 1, 0, 0, 0; p.nonrelevant.push_back(samp);
samp = 0, 1, 0, 0; p.nonrelevant.push_back(samp);
samp = 0, 1, 0, 0; p.nonrelevant.push_back(samp);
samples.push_back(p);
trainer.set_c(10);
decision_function<kernel_type> df = trainer.train(samples);
dlog << LINFO << "accuracy: "<< test_ranking_function(df, samples);
matrix<double,1,2> res;
res = 1,1;
DLIB_TEST(equal(test_ranking_function(df, samples), res));
DLIB_TEST(equal(test_ranking_function(trainer.train(samples[1]), samples), res));
trainer.set_epsilon(1e-13);
df = trainer.train(samples);
dlog << LINFO << df.basis_vectors(0);
sample_type truew;
truew = -0.5, -0.5, 0.5, 0.5;
DLIB_TEST(length(truew - df.basis_vectors(0)) < 1e-10);
dlog << LINFO << "accuracy: "<< test_ranking_function(df, samples);
DLIB_TEST(equal(test_ranking_function(df, samples), res));
dlog << LINFO << "cv-accuracy: "<< cross_validate_ranking_trainer(trainer, samples,2);
DLIB_TEST(std::abs(cross_validate_ranking_trainer(trainer, samples,2)(0) - 0.7777777778) < 0.0001);
trainer.set_learns_nonnegative_weights(true);
df = trainer.train(samples);
truew = 0, 0, 1.0, 1.0;
dlog << LINFO << df.basis_vectors(0);
DLIB_TEST(length(truew - df.basis_vectors(0)) < 1e-10);
dlog << LINFO << "accuracy: "<< test_ranking_function(df, samples);
DLIB_TEST(equal(test_ranking_function(df, samples), res));
samples.clear();
samples.push_back(p);
samples.push_back(p);
samples.push_back(p);
samples.push_back(p);
dlog << LINFO << "cv-accuracy: "<< cross_validate_ranking_trainer(trainer, samples,4);
DLIB_TEST(equal(cross_validate_ranking_trainer(trainer, samples,4) , res));
df.basis_vectors(0) = 0;
dlog << LINFO << "BAD RANKING:" << test_ranking_function(df, samples);
DLIB_TEST(test_ranking_function(df, samples)(1) < 0.5);
}
// ----------------------------------------------------------------------------------------
void dotest_sparse_vectors()
{
print_spinner();
dlog << LINFO << "in dotest_sparse_vectors()";
typedef std::map<unsigned long,double> sample_type;
typedef sparse_linear_kernel<sample_type> kernel_type;
svm_rank_trainer<kernel_type> trainer;
std::vector<ranking_pair<sample_type> > samples;
ranking_pair<sample_type> p;
sample_type samp;
samp[3] = 1; p.relevant.push_back(samp); samp.clear();
samp[0] = 1; p.nonrelevant.push_back(samp); samp.clear();
samples.push_back(p);
samp[2] = 1; p.relevant.push_back(samp); samp.clear();
samp[0] = 1; p.nonrelevant.push_back(samp); samp.clear();
samp[1] = 1; p.nonrelevant.push_back(samp); samp.clear();
samp[1] = 1; p.nonrelevant.push_back(samp); samp.clear();
samples.push_back(p);
trainer.set_c(10);
decision_function<kernel_type> df = trainer.train(samples);
matrix<double,1,2> res;
res = 1,1;
dlog << LINFO << "accuracy: "<< test_ranking_function(df, samples);
DLIB_TEST(equal(test_ranking_function(df, samples), res));
DLIB_TEST(equal(test_ranking_function(trainer.train(samples[1]), samples), res));
trainer.set_epsilon(1e-13);
df = trainer.train(samples);
dlog << LINFO << sparse_to_dense(df.basis_vectors(0));
sample_type truew;
truew[0] = -0.5;
truew[1] = -0.5;
truew[2] = 0.5;
truew[3] = 0.5;
DLIB_TEST(length(subtract(truew , df.basis_vectors(0))) < 1e-10);
dlog << LINFO << "accuracy: "<< test_ranking_function(df, samples);
DLIB_TEST(equal(test_ranking_function(df, samples), res));
dlog << LINFO << "cv-accuracy: "<< cross_validate_ranking_trainer(trainer, samples,2);
DLIB_TEST(std::abs(cross_validate_ranking_trainer(trainer, samples,2)(0) - 0.7777777778) < 0.0001);
trainer.set_learns_nonnegative_weights(true);
df = trainer.train(samples);
truew[0] = 0.0;
truew[1] = 0.0;
truew[2] = 1.0;
truew[3] = 1.0;
dlog << LINFO << sparse_to_dense(df.basis_vectors(0));
DLIB_TEST(length(subtract(truew , df.basis_vectors(0))) < 1e-10);
dlog << LINFO << "accuracy: "<< test_ranking_function(df, samples);
DLIB_TEST(equal(test_ranking_function(df, samples), res));
samples.clear();
samples.push_back(p);
samples.push_back(p);
samples.push_back(p);
samples.push_back(p);
dlog << LINFO << "cv-accuracy: "<< cross_validate_ranking_trainer(trainer, samples,4);
DLIB_TEST(equal(cross_validate_ranking_trainer(trainer, samples,4) , res) );
}
// ----------------------------------------------------------------------------------------
template <typename K, bool use_dcd_trainer>
class simple_rank_trainer
{
public:
template <typename T>
decision_function<K> train (
const ranking_pair<T>& pair
) const
{
typedef matrix<double,10,1> sample_type;
std::vector<sample_type> relevant = pair.relevant;
std::vector<sample_type> nonrelevant = pair.nonrelevant;
std::vector<sample_type> samples;
std::vector<double> labels;
for (unsigned long i = 0; i < relevant.size(); ++i)
{
for (unsigned long j = 0; j < nonrelevant.size(); ++j)
{
samples.push_back(relevant[i] - nonrelevant[j]);
labels.push_back(+1);
samples.push_back(nonrelevant[i] - relevant[j]);
labels.push_back(-1);
}
}
if (use_dcd_trainer)
{
svm_c_linear_dcd_trainer<K> trainer;
trainer.set_c(1.0/samples.size());
trainer.set_epsilon(1e-10);
trainer.force_last_weight_to_1(true);
//trainer.be_verbose();
return trainer.train(samples, labels);
}
else
{
svm_c_linear_trainer<K> trainer;
trainer.set_c(1.0);
trainer.set_epsilon(1e-13);
trainer.force_last_weight_to_1(true);
//trainer.be_verbose();
decision_function<K> df = trainer.train(samples, labels);
DLIB_TEST_MSG(df.b == 0, df.b);
return df;
}
}
};
template <bool use_dcd_trainer>
void test_svmrank_weight_force_dense()
{
print_spinner();
dlog << LINFO << "use_dcd_trainer: "<< use_dcd_trainer;
typedef matrix<double,10,1> sample_type;
typedef linear_kernel<sample_type> kernel_type;
ranking_pair<sample_type> pair;
for (int i = 0; i < 20; ++i)
{
pair.relevant.push_back(abs(gaussian_randm(10,1,i)));
}
for (int i = 0; i < 20; ++i)
{
pair.nonrelevant.push_back(-abs(gaussian_randm(10,1,i+10000)));
pair.nonrelevant.back()(9) += 1;
}
svm_rank_trainer<kernel_type> trainer;
trainer.force_last_weight_to_1(true);
trainer.set_epsilon(1e-13);
//trainer.be_verbose();
decision_function<kernel_type> df;
df = trainer.train(pair);
matrix<double,1,2> res;
res = 1,1;
dlog << LINFO << "weights: "<< trans(df.basis_vectors(0));
const matrix<double,1,2> acc1 = test_ranking_function(df, pair);
dlog << LINFO << "ranking accuracy: " << acc1;
DLIB_TEST(equal(acc1,res));
simple_rank_trainer<kernel_type,use_dcd_trainer> strainer;
decision_function<kernel_type> df2;
df2 = strainer.train(pair);
dlog << LINFO << "weights: "<< trans(df2.basis_vectors(0));
const matrix<double,1,2> acc2 = test_ranking_function(df2, pair);
dlog << LINFO << "ranking accuracy: " << acc2;
DLIB_TEST(equal(acc2,res));
dlog << LINFO << "w error: " << max(abs(df.basis_vectors(0) - df2.basis_vectors(0)));
dlog << LINFO << "b error: " << abs(df.b - df2.b);
DLIB_TEST(std::abs(max(abs(df.basis_vectors(0) - df2.basis_vectors(0)))) < 1e-8);
DLIB_TEST(std::abs(abs(df.b - df2.b)) < 1e-8);
}
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
// ----------------------------------------------------------------------------------------
class test_ranking_tools : public tester
{
public:
test_ranking_tools (
) :
tester ("test_ranking",
"Runs tests on the ranking tools.")
{}
void perform_test (
)
{
test_count_ranking_inversions();
dotest1();
dotest_sparse_vectors();
test_svmrank_weight_force_dense<true>();
test_svmrank_weight_force_dense<false>();
run_prior_test();
run_prior_sparse_test();
}
} a;
}