SVM.h

Go to the documentation of this file.

#ifndef GRT_SVM_HEADER
#define GRT_SVM_HEADER

#include "../../CoreModules/Classifier.h"
#include "LIBSVM/libsvm.h"

GRT_BEGIN_NAMESPACE
    
using namespace LIBSVM;
    
#define SVM_MIN_SCALE_RANGE -1.0
#define SVM_MAX_SCALE_RANGE 1.0

class SVM : public Classifier{
public:
 SVM(UINT kernelType = LINEAR_KERNEL,UINT svmType = C_SVC,bool useScaling = true,bool useNullRejection = false,bool useAutoGamma = true,Float gamma = 0.1,UINT degree = 3,Float coef0 = 0,Float nu = 0.5,Float C = 1,bool useCrossValidation = false,UINT kFoldValue = 10);
    
    SVM(const SVM &rhs);
    
 virtual ~SVM();
    
    SVM &operator=(const SVM &rhs);
    
    virtual bool deepCopyFrom(const Classifier *classifier);
    
    virtual bool train_(ClassificationData &trainingData);
    
    virtual bool predict_(VectorFloat &inputVector);
    
 virtual bool clear();
    
    virtual bool saveModelToFile( std::fstream &file ) const;
    
    virtual bool loadModelFromFile( std::fstream &file );
    
    bool init(UINT kernelType,UINT svmType,bool useScaling,bool useNullRejection,bool useAutoGamma,Float gamma,UINT degree,Float coef0,Float nu,Float C,bool useCrossValidation,UINT kFoldValue);
    
 void initDefaultSVMSettings();

    bool getIsCrossValidationTrainingEnabled() const;
    
    bool getIsAutoGammaEnabled() const;
    
 std::string getSVMType() const;
    
    std::string getKernelType() const;
    
    UINT getDegree() const;
    
    virtual UINT getNumClasses() const;
    
    Float getGamma() const;
    
    Float getNu() const;
    
    Float getCoef0() const;
    
    Float getC() const;
    
    Float getCrossValidationResult() const;
    
    struct svm_model *getModel() const { return model; }
    
    bool setSVMType(const UINT svmType);
    
    bool setKernelType(const UINT kernelType);
    
    bool setGamma(const Float gamma);
    
    bool setDegree(const UINT degree);
    
    bool setNu(const Float nu);
    
    bool setCoef0(const Float coef0);
    
    bool setC(const Float C);
    
    bool setKFoldCrossValidationValue(const UINT kFoldValue);
    
    bool enableAutoGamma(const bool useAutoGamma);
    
    bool enableCrossValidationTraining(const bool useCrossValidation);
    
    //Tell the compiler we are using the following functions from the MLBase class to stop hidden virtual function warnings
    using MLBase::saveModelToFile;
    using MLBase::loadModelFromFile;
    using MLBase::train;
    using MLBase::train_;
    using MLBase::predict;
    using MLBase::predict_;

protected:
    void deleteProblemSet();
    bool validateProblemAndParameters();
    bool validateSVMType(UINT svmType);
    bool validateKernelType(UINT kernelType);
    bool convertClassificationDataToLIBSVMFormat(ClassificationData &trainingData);
 bool trainSVM();
    
    bool predictSVM(VectorFloat &inputVector);
 bool predictSVM(VectorFloat &inputVector,Float &maxProbability, VectorFloat &probabilites);
    bool loadLegacyModelFromFile( std::fstream &file );
    
    struct svm_model *deepCopyModel() const;
    bool deepCopyProblem( const struct svm_problem &source_problem, struct svm_problem &target_problem, const unsigned int numInputDimensions ) const;
    bool deepCopyParam( const svm_parameter &source_param, svm_parameter &target_param ) const;
    
 bool problemSet;
 struct svm_model *model;
 struct svm_parameter param;
 struct svm_problem prob;
 UINT kFoldValue;
 Float classificationThreshold;
 Float crossValidationResult;
 bool useAutoGamma;
    bool useCrossValidation;
    
    static RegisterClassifierModule< SVM > registerModule;
    
public:
    enum SVMTypes{ C_SVC = 0, NU_SVC, ONE_CLASS, EPSILON_SVR, NU_SVR };
    enum SVMKernelTypes{ LINEAR_KERNEL = 0, POLY_KERNEL, RBF_KERNEL, SIGMOID_KERNEL, PRECOMPUTED_KERNEL };

};
    
GRT_END_NAMESPACE

#endif //GRT_SVM_HEADER