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 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 saveModelToFile( std::fstream &file ) const;
 
 virtual bool loadModelFromFile( 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);
 
 //Tell the compiler we are using the base class train method to stop hidden virtual function warnings
 using MLBase::saveModelToFile;
 using MLBase::loadModelFromFile;
 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;
 
 static RegisterClassifierModule< HMM > registerModule;
};
 
GRT_END_NAMESPACE

#endif //GRT_HMM_HEADER