MultiTaskSvm.cpp

Go to the documentation of this file.

#include <shark/Algorithms/Trainers/CSvmTrainer.h>
#include <shark/Models/Kernels/GaussianRbfKernel.h>
#include <shark/Models/Kernels/MultiTaskKernel.h>
#include <shark/ObjectiveFunctions/Loss/ZeroOneLoss.h>
#include <shark/Data/DataDistribution.h>

using namespace shark;
using namespace std;


// RealVector input with task index
typedef MultiTaskSample<RealVector> InputType;


// Multi-task problem with up to three tasks.
class MultiTaskProblem : public LabeledDataDistribution<InputType, unsigned int>
{
public:
    MultiTaskProblem()
    {
        m_task[0] = true;
        m_task[1] = true;
        m_task[2] = true;
    }

    void setTasks(bool task0, bool task1, bool task2)
    {
        m_task[0] = task0;
        m_task[1] = task1;
        m_task[2] = task2;
    }

    void draw(InputType& input, unsigned int& label) const
    {
        size_t taskindex = 0;
        do {
            taskindex = random::uni(random::globalRng, 0, 2);
        } while (! m_task[taskindex]);
        double x1 = random::gauss(random::globalRng);
        double x2 = 3.0 * random::gauss(random::globalRng);
        unsigned int y = (x1 > 0.0) ? 1 : 0;
        double alpha = 0.05 * M_PI * taskindex;
        input.input.resize(2);
        input.input(0) = cos(alpha) * x1 - sin(alpha) * x2;
        input.input(1) = sin(alpha) * x1 + cos(alpha) * x2;
        input.task = taskindex;
        label = y;
    }

protected:
    bool m_task[3];
};


int main(int argc, char** argv)
{
    // experiment settings
    unsigned int ell_train = 1000;      // number of training data point from tasks 0 and 1
    unsigned int ell_test = 1000;       // number of test data points from task 2
    double C = 1.0;                         // regularization parameter
    double gamma = 0.5;                 // kernel bandwidth parameter

    // generate data
    MultiTaskProblem problem;
    problem.setTasks(true, true, false);
    LabeledData<InputType, unsigned int> training = problem.generateDataset(ell_train);
    problem.setTasks(false, false, true);
    LabeledData<InputType, unsigned int> test = problem.generateDataset(ell_test);

    // merge all inputs into a single data object
    Data<InputType> data(ell_train + ell_test);
    for (size_t i=0; i<ell_train; i++) 
        data.element(i) = training.inputs().element(i);
    for (size_t i=0; i<ell_test; i++) 
        data.element(ell_train + i) = test.inputs().element(i);

    // create kernel objects
    GaussianRbfKernel<RealVector> inputKernel(gamma);   // Gaussian kernel on inputs
    GaussianTaskKernel<RealVector> taskKernel(          // task similarity kernel
            data,         // all inputs with task indices, no labels
            3,            // total number of tasks
            inputKernel,  // base kernel for input similarity
            gamma);       // bandwidth for task similarity kernel
    MultiTaskKernel<RealVector> multiTaskKernel(&inputKernel, &taskKernel);

    // train the SVM
    KernelClassifier<InputType> ke;
    CSvmTrainer<InputType> trainer(&multiTaskKernel, C,false);
    cout << "training ..." << endl;
    trainer.train(ke, training);
    cout << "done." << endl;

    ZeroOneLoss<unsigned int> loss;
    Data<RealVector> output;

    // evaluate training performance
    double trainError = loss.eval(training.labels(), ke(training.inputs()));
    cout << "training error:\t" <<  trainError << endl;

    // evaluate its transfer performance
    double testError = loss.eval(test.labels(), ke(test.inputs()));
    cout << "test error:\t" << testError << endl;
}