Svm.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================


#ifndef _Svm_H_
#define _Svm_H_


#include <SharkDefs.h>
#include <ReClaM/Model.h>
#include <ReClaM/Optimizer.h>
#include <ReClaM/KernelFunction.h>
#include <ReClaM/QuadraticProgram.h>
#include <Rng/GlobalRng.h>

class SvmApproximation;


class SVM : public Model
{
public:
    SVM(KernelFunction* pKernel, bool bSignOutput = false);

    SVM(KernelFunction* pKernel, const Array<double>& input, bool bSignOutput = false);

    ~SVM();

    void SetTrainingData(const Array<double>& input, bool copy = false);

    void model(const Array<double>& input, Array<double>& output);

    double model(const Array<double>& input);

    void modelDerivative(const Array<double>& input, Array<double>& derivative);

    void modelDerivative(const Array<double>& input, Array<double>& output, Array<double>& derivative);

    inline double getAlpha(int index)
    {
        return parameter(index);
    }

    inline double getOffset()
    {
        return parameter(examples);
    }

    inline KernelFunction* getKernel()
    {
        return kernel;
    }

    inline const Array<double>& getPoints()
    {
        return *x;
    }

    inline unsigned int getExamples()
    {
        return examples;
    }

    inline unsigned int getDimension()
    {
        return inputDimension;
    }

    void MakeSparse();

    bool LoadSVMModel(std::istream& is);

    bool SaveSVMModel(std::ostream& os);

    static SVM* ImportLibsvmModel(std::istream& is);

    static SVM* ImportSvmlightModel(std::istream& is);

    friend class SvmApproximation;

protected:
    static int ReadToken(std::istream& is, char* buffer, int maxlength, const char* separators);

    static int DiscardUntil(std::istream& is, const char* separators);

    KernelFunction* kernel;

    bool bOwnMemory;

    const Array<double>* x;

    bool signOutput;

    unsigned int examples;
};


class MultiClassSVM : public Model
{
public:
    MultiClassSVM(KernelFunction* pKernel, unsigned int numberOfClasses, bool bOrthogonalVectors, bool bNumberOutput = true);

    MultiClassSVM(KernelFunction* pKernel, Array<double> prototypes, bool bNumberOutput = true);

    ~MultiClassSVM();


    void SetTrainingData(const Array<double>& input, bool copy = false);

    void model(const Array<double>& input, Array<double>& output);

    unsigned int model(const Array<double>& input);

    void Normalize();

    inline KernelFunction* getKernel()
    {
        return kernel;
    }

    inline const Array<double>& getPoints()
    {
        return *x;
    }

    inline double getAlpha(unsigned int index, unsigned int c) const
    {
        return parameter(classes * index + c);
    }

    inline double getOffset(unsigned int c) const
    {
        return parameter(classes * examples + c);
    }

    inline unsigned int getClasses() const
    {
        return classes;
    }

    inline const ArrayReference<double> getClassPrototype(unsigned int c) const
    {
        return prototypes[c];
    }

    unsigned int VectorToClass(const Array<double>& v);

protected:
    void Predict(const Array<double>& input, Array<double>& output);
    void Predict(const Array<double>& input, ArrayReference<double> output);

    KernelFunction* kernel;

    bool bOwnMemory;

    const Array<double>* x;

    bool numberOutput;

    unsigned int examples;

    unsigned int classes;

    Array<double> prototypes;
};


class MetaSVM : public Model
{
public:
    MetaSVM(SVM* pSVM, unsigned int numberOfHyperParameters);

    MetaSVM(MultiClassSVM* pSVM, unsigned int numberOfHyperParameters);

    ~MetaSVM();


    inline SVM* getSVM()
    {
        return dynamic_cast<SVM*>(svm);
    }

    inline MultiClassSVM* getMultiClassSVM()
    {
        return dynamic_cast<MultiClassSVM*>(svm);
    }

    void model(const Array<double>& input, Array<double>& output);

    void setParameter(unsigned int index, double value);

    bool isFeasible();

protected:
    Model* svm;

    KernelFunction* kernel;

    unsigned int hyperparameters;
};


class C_SVM : public MetaSVM
{
public:
    C_SVM(SVM* pSVM, double Cplus, double Cminus, bool norm2 = false, bool unconst = false);

    ~C_SVM();


    void PrepareDerivative();

    void modelDerivative(const Array<double>& input, Array<double>& derivative);

    void setParameter(unsigned int index, double value);

    inline double get_Cplus()
    {
        return C_plus;
    }

    inline double get_Cminus()
    {
        return C_minus;
    }

    inline bool is2norm()
    {
        return norm2penalty;
    }

    inline bool isUnconstrained()
    {
        return exponential;
    }

    inline double getCRatio()
    {
        return C_ratio;
    }

    bool isFeasible();

protected:
    bool norm2penalty;

    double C_plus;

    double C_minus;

    double C_ratio;

    bool exponential;

    Array<double> alpha_b_Derivative;
};


class Epsilon_SVM : public MetaSVM
{
public:
    Epsilon_SVM(SVM* pSVM, double C, double epsilon, bool unconst = false);

    ~Epsilon_SVM();


    void setParameter(unsigned int index, double value);

    inline double get_C()
    {
        return C;
    }

    inline double get_epsilon()
    {
        return epsilon;
    }

    bool isFeasible();

protected:
    double C;

    double epsilon;

    bool exponential;
};



class OneClassSVM : public MetaSVM
{
public:

    OneClassSVM(SVM* pSVM, double fractionNu);

    ~OneClassSVM();

    void setParameter(unsigned int index, double value);

    inline double getNu(){
        return nu;
    }

    bool isFeasible();

protected:
    double nu;
};


class RegularizationNetwork : public MetaSVM
{
public:
    RegularizationNetwork(SVM* pSVM, double gamma);

    ~RegularizationNetwork();


    inline double get_gamma() { return parameter(0); }
    inline void set_gamma(double gamma) { setParameter(0, gamma); }

    bool isFeasible();
};


class AllInOneMcSVM : public MetaSVM
{
public:
    AllInOneMcSVM(MultiClassSVM* pSVM, double C);

    ~AllInOneMcSVM();


    inline double get_C() { return parameter(0); }
    inline void set_C(double C) { setParameter(0, C); }

    bool isFeasible();
};


class CrammerSingerMcSVM : public MetaSVM
{
public:
    CrammerSingerMcSVM(MultiClassSVM* pSVM, double beta);

    ~CrammerSingerMcSVM();


    inline double get_beta() { return parameter(0); }
    inline void set_beta(double beta) { setParameter(0, beta); }

    bool isFeasible();
};


class OVAMcSVM : public MetaSVM
{
public:
    OVAMcSVM(MultiClassSVM* pSVM, double C);

    ~OVAMcSVM();


    inline double get_C() { return parameter(0); }
    inline void set_C(double C) { setParameter(0, C); }

    bool isFeasible();
};


class OCCMcSVM : public MetaSVM
{
public:
    OCCMcSVM(MultiClassSVM* pSVM, double C);

    ~OCCMcSVM();


    inline double get_C() { return parameter(0); }
    inline void set_C(double C) { setParameter(0, C); }

    bool isFeasible();
};


class SVM_Optimizer : public Optimizer
{
public:
    SVM_Optimizer();

    ~SVM_Optimizer();


    void init(Model& model);

    double optimize(Model& model, ErrorFunction& error, const Array<double>& input, const Array<double>& target);

    double optimize(SVM& model, const Array<double>& input, const Array<double>& target, bool copy = false);

    void optimize(MultiClassSVM& model, const Array<double>& input, const Array<double>& target, bool copy = false);

    static ErrorFunction& dummyError;

    inline QPSolver* get_Solver()
    {
        return solver;
    }

    inline void setAccuracy(double accuracy = 0.001)
    {
        this->accuracy = accuracy;
    }

    inline void setMaxIterations(SharkInt64 maxiter = -1)
    {
        this->maxIter = maxiter;
    }

    inline void setMaxSeconds(int seconds = -1)
    {
        maxSeconds = seconds;
    }

    inline void setVerbose(bool verbose = true)
    {
        printInfo = verbose;
    }

    inline void setCacheSize(unsigned int cacheSize)
    {
        cacheMB = cacheSize;
    }

protected:
    enum eMode
    {
        eC1,                // C-SVM with 1-norm penalty for binary classification
        eC2,                // C-SVM with 2-norm penalty for binary classification
        eEpsilon,           // \varepsilon-SVM for regression
        eNu,                // \nu-SVM, not implemented yet
        eRegularizationNetwork,
        e1Class,            // One-Class SVM for density estimation XXX
        eAllInOne,          // standard multi class SVM
        eCrammerSinger,     // MC-SVM by Crammer and Singer
        eOVA,               // one-versus-all multi class SVM
        eOCC,       // binary-SVM-cost multi-class SVM
    };

    eMode mode;

    QPMatrix* matrix;

    CachedMatrix* cache;

    QPSolver* solver;

    double Cplus;

    double Cminus;

    double C;

    double epsilon;

    double gamma;

    double beta;

    double fractionOfOutliers;
    
    double OneClassBoxUpper;

    bool printInfo;

    unsigned int cacheMB;

    double accuracy;

    SharkInt64 maxIter;

    int maxSeconds;
};


typedef SVM KernelExpansion;
typedef SVM LinearKernelModel;


#endif