HMM.h

Go to the documentation of this file.

#ifndef GRT_HMM_HEADER
#define GRT_HMM_HEADER

#include "HMMEnums.h"
#include "DiscreteHiddenMarkovModel.h"
#include "ContinuousHiddenMarkovModel.h"
#include "../../CoreModules/Classifier.h"

GRT_BEGIN_NAMESPACE

class GRT_API HMM : public Classifier
{
public:
    HMM(const UINT hmmType=HMM_CONTINUOUS,const UINT modelType=HMM_LEFTRIGHT,const UINT delta=1,const bool useScaling = false,const bool useNullRejection = false);
    
    HMM(const HMM &rhs);
    
    virtual ~HMM(void);
    
    HMM& operator=(const HMM &rhs);
    
    virtual bool deepCopyFrom(const Classifier *classifier);
    
    virtual bool train(ClassificationData trainingData);
    
    virtual bool train_(TimeSeriesClassificationData &trainingData);
    
    virtual bool predict_(VectorFloat &inputVector);
    
    virtual bool predict_(MatrixFloat &timeseries);
    
    virtual bool reset();
    
    virtual bool clear();
    
    virtual bool print() const;
    
    virtual bool save( std::fstream &file ) const;
    
    virtual bool load( std::fstream &file );
    
    UINT getHMMType() const;
    
    UINT getModelType() const;
    
    UINT getDelta() const;
    
    UINT getNumStates() const;
    
    UINT getNumSymbols() const;
    
    UINT getNumRandomTrainingIterations() const;
    
    Vector< DiscreteHiddenMarkovModel > getDiscreteModels() const;
    
    Vector< ContinuousHiddenMarkovModel > getContinuousModels() const;
    
    bool setHMMType(const UINT hmmType);
    
    bool setModelType(const UINT modelType);
    
    bool setDelta(const UINT delta);
    
    bool setDownsampleFactor(const UINT downsampleFactor);
    
    bool setCommitteeSize(const UINT committeeSize);
    
    bool setNumStates(const UINT numStates);
    
    bool setNumSymbols(const UINT numStates);
    
    bool setNumRandomTrainingIterations(const UINT numRandomTrainingIterations);
    
    bool setSigma(const Float sigma);
    
    bool setAutoEstimateSigma(const bool autoEstimateSigma);

    static std::string getId();
    
    //Tell the compiler we are using the base class train method to stop hidden virtual function warnings
    using MLBase::save;
    using MLBase::load;
    using MLBase::train;
    using MLBase::train_;
    using MLBase::predict_;
    
protected:
    bool train_discrete(TimeSeriesClassificationData &trainingData);
    bool train_continuous(TimeSeriesClassificationData &trainingData);
    bool predict_discrete( VectorFloat &inputVector );
    bool predict_continuous( VectorFloat &inputVector );
    bool predict_discrete(MatrixFloat &timeseries);
    bool predict_continuous(MatrixFloat &timeseries);
    bool convertDataToObservationSequence( TimeSeriesClassificationData &classData, Vector< Vector< UINT > > &observationSequences );
    bool loadLegacyModelFromFile( std::fstream &file );
    
    UINT hmmType;           
    UINT modelType;         //Set if the model is ERGODIC or LEFTRIGHT
    UINT delta;             //The number of states a model can move to in a LeftRight model
    
    //Discrete HMM variables
    UINT numStates;         //The number of states for each model
    UINT numSymbols;        //The number of symbols for each model
    UINT numRandomTrainingIterations;
    Vector< DiscreteHiddenMarkovModel > discreteModels;
    
    //Continuous HMM variables
    UINT downsampleFactor;
    UINT committeeSize;
    Float sigma;
    bool autoEstimateSigma;
    Vector< ContinuousHiddenMarkovModel > continuousModels;
    
private:
    static RegisterClassifierModule< HMM > registerModule;
    static const std::string id;
};

GRT_END_NAMESPACE

#endif //GRT_HMM_HEADER