GestureRecognitionPipeline.h

Go to the documentation of this file.

#ifndef GRT_GESTURE_RECOGNITION_PIPELINE_HEADER
#define GRT_GESTURE_RECOGNITION_PIPELINE_HEADER

#include "../Util/GRTCommon.h"
#include "PreProcessing.h"
#include "FeatureExtraction.h"
#include "Classifier.h"
#include "Regressifier.h"
#include "Clusterer.h"
#include "PostProcessing.h"
#include "Context.h"
#include "../DataStructures/ClassificationDataStream.h"
#include "../Util/ClassificationResult.h"
#include "../Util/TestResult.h"

GRT_BEGIN_NAMESPACE
 
#define INSERT_AT_END_INDEX 99999

class GestureRecognitionPipeline : public GRTBase
{
public:
 enum ContextLevels{START_OF_PIPELINE=0,AFTER_PREPROCESSING,AFTER_FEATURE_EXTRACTION,AFTER_CLASSIFIER,END_OF_PIPELINE,NUM_CONTEXT_LEVELS};

 GestureRecognitionPipeline(void);
 
 GestureRecognitionPipeline(const GestureRecognitionPipeline &rhs);
 
 virtual ~GestureRecognitionPipeline(void);
 
 GestureRecognitionPipeline& operator=(const GestureRecognitionPipeline &rhs);

 GestureRecognitionPipeline& operator << (const PreProcessing &module);

 GestureRecognitionPipeline& operator << (const FeatureExtraction &module);

 GestureRecognitionPipeline& operator << (const Classifier &module);

 GestureRecognitionPipeline& operator << (const Regressifier &module);

 GestureRecognitionPipeline& operator << (const Clusterer &module);

 GestureRecognitionPipeline& operator << (const PostProcessing &module);
 
 bool train(const ClassificationData &trainingData);

 bool train(const ClassificationData &trainingData,const UINT kFoldValue,const bool useStratifiedSampling = false );

 bool train(const TimeSeriesClassificationData &trainingData);
 
 bool train(const TimeSeriesClassificationData &trainingData,const UINT kFoldValue,const bool useStratifiedSampling = false);

 bool train(const ClassificationDataStream &trainingData);

 bool train(const RegressionData &trainingData);
 
 bool train(const RegressionData &trainingData,const UINT kFoldValue);
 
 bool train(const UnlabelledData &trainingData);
 
 bool test(const ClassificationData &testData);

 bool test(const TimeSeriesClassificationData &testData);

 bool test(const ClassificationDataStream &testData);

 bool test(const RegressionData &testData);
 
 bool predict(const VectorFloat &inputVector);
 
 bool predict(const MatrixFloat &inputMatrix);

 bool map(const VectorFloat &inputVector);
 
 bool reset();

 bool clear();

 bool clearModel();

 bool save(const std::string &filename) const;
 
 bool savePipelineToFile(const std::string &filename) const;

 bool load(const std::string &filename);
 
 bool loadPipelineFromFile(const std::string &filename);
 
 bool preProcessData(VectorFloat inputVector,bool computeFeatures = true);
 
 bool getIsInitialized() const;

 bool getTrained() const;

 bool getIsPreProcessingSet() const;

 bool getIsFeatureExtractionSet() const;

 bool getIsClassifierSet() const;

 bool getIsRegressifierSet() const;
 
 bool getIsClustererSet() const;

 bool getIsPostProcessingSet() const;

 bool getIsContextSet() const;

 bool getIsPipelineModeSet() const;

 bool getIsPipelineInClassificationMode() const;

 bool getIsPipelineInRegressionMode() const;
 
 UINT getInputVectorDimensionsSize() const;

 UINT getOutputVectorDimensionsSize() const;

 UINT getNumClassesInModel() const;
 
 UINT getNumClasses() const;

 UINT getNumPreProcessingModules() const;

 UINT getNumFeatureExtractionModules() const;

 UINT getNumPostProcessingModules() const;

 UINT getPredictionModuleIndexPosition() const;

 UINT getPredictedClassLabel() const;

 UINT getUnProcessedPredictedClassLabel() const;
 
 UINT getNumTrainingSamples() const;
 
 UINT getNumTestSamples() const;
 
 Float getMaximumLikelihood() const;
 
 Float getPhase() const;

 Float getCrossValidationAccuracy() const;

 Float getTestAccuracy() const;

 Float getTestRMSError() const;

 Float getTestSSError() const;

 Float getTestFMeasure(const UINT classLabel) const;

 Float getTestPrecision(const UINT classLabel) const;

 Float getTestRecall(const UINT classLabel) const;

 Float getTestRejectionPrecision() const;

 Float getTestRejectionRecall() const;

 Float getTestTime() const;

 Float getTrainingTime() const;

 Float getTrainingRMSError() const;

 Float getTrainingSSError() const;

 MatrixFloat getTestConfusionMatrix() const;
 
 TestResult getTestResults() const;
 
 VectorFloat getTestPrecision() const;
 
 VectorFloat getTestRecall() const;
 
 VectorFloat getTestFMeasure() const;

 VectorFloat getClassLikelihoods() const;

 VectorFloat getClassDistances() const;

 VectorFloat getNullRejectionThresholds() const;

 VectorFloat getRegressionData() const;

 VectorFloat getUnProcessedRegressionData() const;

 VectorFloat getPreProcessedData() const;

 VectorFloat getPreProcessedData(UINT moduleIndex) const;

 VectorFloat getFeatureExtractionData() const;

 VectorFloat getFeatureExtractionData(const UINT moduleIndex) const;

 Vector< UINT > getClassLabels() const;

 Vector< TestInstanceResult > getTestInstanceResults() const;

 Vector< TestResult > getCrossValidationResults() const;

 PreProcessing* getPreProcessingModule(const UINT moduleIndex) const;

 FeatureExtraction* getFeatureExtractionModule(const UINT moduleIndex) const;

 Classifier* getClassifier() const;

 Regressifier* getRegressifier() const;
 
 Clusterer* getClusterer() const;

 PostProcessing* getPostProcessingModule(UINT moduleIndex) const;

 Context* getContextModule(const UINT contextLevel,const UINT moduleIndex) const;
 
 template <class T> T* getPreProcessingModule(const UINT moduleIndex) const{
 if( moduleIndex < preProcessingModules.size() ){
 return (T*)preProcessingModules[ moduleIndex ];
 }
 return NULL;
 }
 
 template <class T> T* getFeatureExtractionModule(const UINT moduleIndex) const{
 if( moduleIndex < featureExtractionModules.size() ){
 return (T*)featureExtractionModules[ moduleIndex ];
 }
 return NULL;
 }

 template <class T> T* getClassifier() const{
 
 if( classifier == NULL ) return NULL;
 
 T temp;
 
 if( temp.getClassifierType() == classifier->getClassifierType() ){
 return dynamic_cast<T*>(classifier);
 }
 
 return NULL;
 }

 template <class T> T* getRegressifier() const{
 
 if( regressifier == NULL ) return NULL;
 
 T temp;
 
 if( temp.getRegressifierType() == regressifier->getRegressifierType() ){
 return (T*)regressifier;
 }
 
 return NULL;
 }
 
 template <class T> T* getCluster() const{
 
 if( clusterer == NULL ) return NULL;
 
 T temp;
 
 if( temp.getClassifierType() == clusterer->getClustererType() ){
 return (T*)clusterer;
 }
 
 return NULL;
 }
 
 template <class T> T* getPostProcessingModule(const UINT moduleIndex) const{
 if( moduleIndex < postProcessingModules.getSize() ){
 return (T*)postProcessingModules[ moduleIndex ];
 }
 return NULL;
 }
 
 template <class T> T* getContextModule(const UINT contextLevel,const UINT moduleIndex) const{
 if( contextLevel < contextModules.getSize() ){
 if( moduleIndex < contextModules[ contextLevel ].getSize() ){
 return (T*)contextModules[ contextLevel ][ moduleIndex ];
 }
 }
 return NULL;
 }
 
 std::string getModelAsString() const;
 
 std::string getPipelineModeAsString() const;
 
 /*
 Gets the pipeline info text as a string.
 
 @return returns the pipeline info as a string
 */
 std::string getInfo() const;

 UINT getPipelineModeFromString(std::string pipelineMode) const;
 
 bool addPreProcessingModule(const PreProcessing &preProcessingModule,UINT insertIndex = INSERT_AT_END_INDEX);

 bool setPreProcessingModule(const PreProcessing &preProcessingModule);

 bool addFeatureExtractionModule(const FeatureExtraction &featureExtractionModule,UINT insertIndex = INSERT_AT_END_INDEX);

 bool setFeatureExtractionModule(const FeatureExtraction &featureExtractionModule);

 bool setClassifier(const Classifier &classifier);

 bool setRegressifier(const Regressifier &regressifier);

 bool setClusterer(const Clusterer &clusterer);
 
 bool addPostProcessingModule(const PostProcessing &postProcessingModule,UINT insertIndex = INSERT_AT_END_INDEX);

 bool setPostProcessingModule(const PostProcessing &postProcessingModule);
 
 bool addContextModule(const Context &contextModule,UINT contextLevel,UINT insertIndex = INSERT_AT_END_INDEX);
 
 bool updateContextModule(bool value,UINT contextLevel = 0,UINT moduleIndex = 0);

 bool removeAllPreProcessingModules();

 bool removePreProcessingModule(UINT moduleIndex);

 bool removeAllFeatureExtractionModules();

 bool removeFeatureExtractionModule(UINT moduleIndex);

 bool removeClassifier(){ deleteClassifier(); return true; }

 bool removeRegressifier(){ deleteRegressifier(); return true; }

 bool removeClusterer(){ deleteClusterer(); return true; }

 bool removeAllPostProcessingModules();

 bool removePostProcessingModule(const UINT moduleIndex);
 
 bool removeAllContextModules();

 bool removeContextModule(const UINT contextLevel,const UINT moduleIndex);

 GRT_DEPRECATED_MSG( "use clear() instead.", bool clearAll() );
 
 bool clearTestResults();
 
 bool setInfo(const std::string &info);

protected:
 bool predict_classifier(const VectorFloat &inputVector);
 bool predict_timeseries( const MatrixFloat &input );
 bool predict_frame( const MatrixFloat &input );
 bool predict_regressifier(const VectorFloat &inputVector);
 bool predict_clusterer(const VectorFloat &inputVector);
 bool init();
 void deleteAllPreProcessingModules();
 void deleteAllFeatureExtractionModules();
 void deleteClassifier();
 void deleteRegressifier();
 void deleteClusterer();
 void deleteAllPostProcessingModules();
 void deleteAllContextModules();
 bool updateTestMetrics(const UINT classLabel,const UINT predictedClassLabel,VectorFloat &precisionCounter,VectorFloat &recallCounter,Float &rejectionPrecisionCounter,Float &rejectionRecallCounter,VectorFloat &confusionMatrixCounter);
 bool computeTestMetrics(VectorFloat &precisionCounter,VectorFloat &recallCounter,Float &rejectionPrecisionCounter,Float &rejectionRecallCounter,VectorFloat &confusionMatrixCounter,const UINT numTestSamples);
 
 bool initialized;
 bool trained;
 std::string info;
 UINT inputVectorDimensions;
 UINT outputVectorDimensions;
 UINT predictedClassLabel;
 UINT predictedClusterLabel;
 UINT pipelineMode;
 UINT predictionModuleIndex;
 UINT numTrainingSamples;
 UINT numTestSamples;
 Float testAccuracy;
 Float testRMSError;
 Float testSquaredError;
 Float testTime;
 Float trainingTime;
 VectorFloat testFMeasure;
 VectorFloat testPrecision;
 VectorFloat testRecall;
 VectorFloat regressionData;
 Float testRejectionPrecision;
 Float testRejectionRecall;
 MatrixFloat testConfusionMatrix;
 Vector< TestResult > crossValidationResults;
 Vector< TestInstanceResult > testResults;
 
 Vector< PreProcessing* > preProcessingModules;
 Vector< FeatureExtraction* > featureExtractionModules;
 Classifier *classifier;
 Regressifier *regressifier;
 Clusterer *clusterer;
 Vector< PostProcessing* > postProcessingModules;
 Vector< Vector< Context* > > contextModules;
 
 enum PipelineModes{PIPELINE_MODE_NOT_SET=0,CLASSIFICATION_MODE,REGRESSION_MODE,CLUSTER_MODE};
};

GRT_END_NAMESPACE

#endif //GRT_GESTURE_RECOGNITION_PIPELINE_HEADER