dlib C++ Library - svm_sparse_ex.cpp

// The contents of this file are in the public domain. See LICENSE_FOR_EXAMPLE_PROGRAMS.txt
/*
 This is an example showing how to use sparse feature vectors with
 the dlib C++ library's machine learning tools.
 This example creates a simple binary classification problem and shows
 you how to train a support vector machine on that data.
 The data used in this example will be 100 dimensional data and will
 come from a simple linearly separable distribution. 
*/
#include <iostream>
#include <ctime>
#include <vector>
#include <dlib/svm.h>
using namespace std;
using namespace dlib;
int main()
{
 // In this example program we will be dealing with feature vectors that are sparse (i.e. most
 // of the values in each vector are zero). So rather than using a dlib::matrix we can use
 // one of the containers from the STL to represent our sample vectors. In particular, we 
 // can use the std::map to represent sparse vectors. (Note that you don't have to use std::map.
 // Any STL container of std::pair objects that is sorted can be used. So for example, you could 
 // use a std::vector<std::pair<unsigned long,double> > here so long as you took care to sort every vector)
 typedef std::map<unsigned long,double> sample_type;
 // This is a typedef for the type of kernel we are going to use in this example.
 // Since our data is linearly separable I picked the linear kernel. Note that if you
 // are using a sparse vector representation like std::map then you have to use a kernel
 // meant to be used with that kind of data type. 
 typedef sparse_linear_kernel<sample_type> kernel_type;
 // Here we create an instance of the pegasos svm trainer object we will be using.
 svm_pegasos<kernel_type> trainer;
 // Here we setup a parameter to this object. See the dlib documentation for a 
 // description of what this parameter does. 
 trainer.set_lambda(0.00001);
 // Let's also use the svm trainer specially optimized for the linear_kernel and
 // sparse_linear_kernel.
 svm_c_linear_trainer<kernel_type> linear_trainer;
 // This trainer solves the "C" formulation of the SVM. See the documentation for
 // details.
 linear_trainer.set_c(10);
 std::vector<sample_type> samples;
 std::vector<double> labels;
 // make an instance of a sample vector so we can use it below
 sample_type sample;
 // Now let's go into a loop and randomly generate 10000 samples.
 srand(time(0));
 double label = +1;
 for (int i = 0; i < 10000; ++i)
 {
 // flip this flag
 label *= -1;
 sample.clear();
 // now make a random sparse sample with at most 10 non-zero elements
 for (int j = 0; j < 10; ++j)
 {
 int idx = std::rand()%100;
 double value = static_cast<double>(std::rand())/RAND_MAX;
 sample[idx] = label*value;
 }
 // let the svm_pegasos learn about this sample. 
 trainer.train(sample,label);
 // Also save the samples we are generating so we can let the svm_c_linear_trainer
 // learn from them below. 
 samples.push_back(sample);
 labels.push_back(label);
 }
 // In addition to the rule we learned with the pegasos trainer, let's also use our
 // linear_trainer to learn a decision rule.
 decision_function<kernel_type> df = linear_trainer.train(samples, labels);
 // Now we have trained our SVMs. Let's test them out a bit. 
 // Each of these statements prints the output of the SVMs given a particular sample. 
 // Each SVM outputs a number > 0 if a sample is predicted to be in the +1 class and < 0 
 // if a sample is predicted to be in the -1 class.
 sample.clear();
 sample[4] = 0.3;
 sample[10] = 0.9;
 cout << "This is a +1 example, its SVM output is: " << trainer(sample) << endl;
 cout << "df: " << df(sample) << endl;
 sample.clear();
 sample[83] = -0.3;
 sample[26] = -0.9;
 sample[58] = -0.7;
 cout << "This is a -1 example, its SVM output is: " << trainer(sample) << endl;
 cout << "df: " << df(sample) << endl;
 sample.clear();
 sample[0] = -0.2;
 sample[9] = -0.8;
 cout << "This is a -1 example, its SVM output is: " << trainer(sample) << endl;
 cout << "df: " << df(sample) << endl;
}