Classifier.h

Go to the documentation of this file.

#ifndef GRT_CLASSIFIER_HEADER
#define GRT_CLASSIFIER_HEADER

#include "MLBase.h"

GRT_BEGIN_NAMESPACE

#define DEFAULT_NULL_LIKELIHOOD_VALUE 0
#define DEFAULT_NULL_DISTANCE_VALUE 0

class GRT_API Classifier : public MLBase
{
public:
    enum ClassifierModes{STANDARD_CLASSIFIER_MODE=0,TIMESERIES_CLASSIFIER_MODE}; 

    Classifier( const std::string &classifierId = "" );
    
    virtual ~Classifier(void);
    
    virtual bool deepCopyFrom(const Classifier *classifier){ return false; }
    
    bool copyBaseVariables(const Classifier *classifier);
    
    virtual bool reset();
    
    virtual bool clear();

    virtual bool computeAccuracy( const ClassificationData &data, Float &accuracy );
    
    std::string getClassifierType() const;
    
    bool getSupportsNullRejection() const;
    
    bool getNullRejectionEnabled() const;
    
    Float getNullRejectionCoeff() const;
    
    Float getMaximumLikelihood() const;
    
    Float getBestDistance() const;
    
    Float getPhase() const;

    Float getTrainingSetAccuracy() const;
    
    virtual UINT getNumClasses() const;
    
    UINT getClassLabelIndexValue(const UINT classLabel) const;
    
    UINT getPredictedClassLabel() const;
    
    VectorFloat getClassLikelihoods() const;
    
    VectorFloat getClassDistances() const;
    
    VectorFloat getNullRejectionThresholds() const;
    
    Vector< UINT > getClassLabels() const;
    
    Vector<MinMax> getRanges() const;
    
    bool enableNullRejection(const bool useNullRejection);
    
    virtual bool setNullRejectionCoeff(const Float nullRejectionCoeff);
    
    virtual bool setNullRejectionThresholds(const VectorFloat &newRejectionThresholds);
    
    virtual bool recomputeNullRejectionThresholds(){ return false; }
    
    bool getTimeseriesCompatible() const{ return classifierMode==TIMESERIES_CLASSIFIER_MODE; }
    
    typedef std::map< std::string, Classifier*(*)() > StringClassifierMap;
    
    static Classifier* create( const std::string &id );
    
    Classifier* create() const;

    GRT_DEPRECATED_MSG( "createNewInstance is deprecated, use create instead.", Classifier* createNewInstance() const );
    GRT_DEPRECATED_MSG( "createInstanceFromString is deprecated, use create instead.", static Classifier* createInstanceFromString( const std::string &id ) );
    
    Classifier* deepCopy() const;
    
    const Classifier* getClassifierPointer() const;
    
    const Classifier& getBaseClassifier() const;
    
    static Vector< std::string > getRegisteredClassifiers();
    
protected:
    bool saveBaseSettingsToFile( std::fstream &file ) const;
    
    bool loadBaseSettingsFromFile( std::fstream &file );
    
    bool supportsNullRejection;
    bool useNullRejection;
    UINT numClasses;
    UINT predictedClassLabel;
    UINT classifierMode;
    Float nullRejectionCoeff;
    Float maxLikelihood;
    Float bestDistance;
    Float phase;
    Float trainingSetAccuracy;
    VectorFloat classLikelihoods;
    VectorFloat classDistances;
    VectorFloat nullRejectionThresholds;
    Vector< UINT > classLabels;
    Vector< MinMax > ranges;

    static StringClassifierMap *getMap() {
        if( !stringClassifierMap ){ stringClassifierMap = new StringClassifierMap; }
        return stringClassifierMap;
    }
    
private:
    static StringClassifierMap *stringClassifierMap;
    static UINT numClassifierInstances;
    
};

template< typename T >  
Classifier* createNewClassifierInstance() { return new T; } 

template< typename T >
class RegisterClassifierModule : public Classifier {
public:
    RegisterClassifierModule( std::string const &newModuleId ) {
        getMap()->insert( std::pair< std::string, Classifier*(*)() >(newModuleId, &createNewClassifierInstance<T> ) );
    }
};

GRT_END_NAMESPACE

#endif //GRT_CLASSIFIER_HEADER