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 GRT_API GestureRecognitionPipeline : public MLBase
{
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);
 
 virtual bool train_(ClassificationData &trainingData) override;

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

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

 virtual bool train_(TimeSeriesClassificationData &trainingData) override;

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

 virtual bool train_(ClassificationDataStream &trainingData) override;

 virtual bool train_(RegressionData &trainingData) override;
 
 virtual bool train_(RegressionData &trainingData,RegressionData &validationData) override;

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

 virtual bool test(const TimeSeriesClassificationData &testData);

 virtual bool test(const ClassificationDataStream &testData);

 virtual bool test(const RegressionData &testData);
 
 virtual bool predict_(VectorFloat &inputVector) override;
 
 virtual bool predict_(MatrixFloat &inputMatrix) override;

 GRT_DEPRECATED_MSG( "map_(VectorFloat &inputVector) is deprecated, use predict_(VectorFloat &inputVector) instead", virtual bool map_(VectorFloat &inputVector) override );
 
 virtual bool reset() override;

 virtual bool clear() override;

 virtual bool clearModel();

 virtual bool save(const std::string &filename) const override;
 
 GRT_DEPRECATED_MSG( "savePipelineToFile(std::string filename) is deprecated, use save(std::string &filename) instead", bool savePipelineToFile(const std::string &filename) const );

 virtual bool load(const std::string &filename) override;
 
 GRT_DEPRECATED_MSG( "loadPipelineFromFile(std::string filename) is deprecated, use load(std::string &filename) instead", bool loadPipelineFromFile(const std::string &filename) );
 
 bool preProcessData(VectorFloat inputVector,bool computeFeatures = true);
 
 virtual bool getIsInitialized() 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 getTrainingSetAccuracy() 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;
 
 Vector< TrainingResult > getTrainingResults() 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> const T* getPreProcessingModule(const UINT moduleIndex) const{
 if( moduleIndex < preProcessingModules.getSize() ){

 if( preProcessingModules[ moduleIndex ] == NULL ) return NULL;
 
 if( T::getId() == preProcessingModules[ moduleIndex ]->getId() ){
 return dynamic_cast<const T*>( preProcessingModules[ moduleIndex ] );
 }
 }

 return NULL;
 }

 template <class T> T* getPreProcessingModule(const UINT moduleIndex) {
 if( moduleIndex < preProcessingModules.getSize() ){

 if( preProcessingModules[ moduleIndex ] == NULL ) return NULL;
 
 if( T::getId() == preProcessingModules[ moduleIndex ]->getId() ){
 return dynamic_cast<T*>( preProcessingModules[ moduleIndex ] );
 }
 }

 return NULL;
 }
 
 template <class T> const T* getFeatureExtractionModule(const UINT moduleIndex) const{
 if( moduleIndex < featureExtractionModules.getSize() ){

 if( featureExtractionModules[ moduleIndex ] == NULL ) return NULL;
 
 if( T::getId() == featureExtractionModules[ moduleIndex ]->getId() ){
 return dynamic_cast<const T*>( featureExtractionModules[ moduleIndex ] );
 }
 }

 return NULL;
 }

 template <class T> T* getFeatureExtractionModule(const UINT moduleIndex){
 if( moduleIndex < featureExtractionModules.getSize() ){

 if( featureExtractionModules[ moduleIndex ] == NULL ) return NULL;
 
 if( T::getId() == featureExtractionModules[ moduleIndex ]->getId() ){
 return dynamic_cast<T*>( featureExtractionModules[ moduleIndex ] );
 }
 }

 return NULL;
 }

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

 template <class T> T* getClassifier(){
 
 if( classifier == NULL ) return NULL;
 
 if( T::getId() == classifier->getId() ){
 return dynamic_cast<T*>( classifier );
 }
 
 return NULL;
 }

 template <class T> const T* getRegressifier() const{
 
 if( regressifier == NULL ) return NULL;
 
 if( T::getId() == regressifier->getId() ){
 return dynamic_cast<const T*>( regressifier );
 }
 
 return NULL;
 }

 template <class T> T* getRegressifier(){
 
 if( regressifier == NULL ) return NULL;
 
 if( T::getId() == regressifier->getId() ){
 return dynamic_cast<T*>( regressifier );
 }
 
 return NULL;
 }
 
 template <class T> const T* getCluster() const{
 
 if( clusterer == NULL ) return NULL;
 
 if( T::getId() == clusterer->getId() ){
 return dynamic_cast<const T*>( clusterer );
 }
 
 return NULL;
 }

 template <class T> T* getCluster(){
 
 if( clusterer == NULL ) return NULL;
 
 if( T::getId() == clusterer->getId() ){
 return dynamic_cast<T*>( clusterer );
 }
 
 return NULL;
 }
 
 template <class T> const T* getPostProcessingModule(const UINT moduleIndex) const{
 if( moduleIndex < postProcessingModules.getSize() ){
 if( postProcessingModules[ moduleIndex ] == NULL ) return NULL;
 
 if( T::getId() == postProcessingModules[ moduleIndex ]->getId() ){
 return dynamic_cast<const T*>( postProcessingModules[ moduleIndex ] );
 }
 }
 return NULL;
 }

 template <class T> T* getPostProcessingModule(const UINT moduleIndex){
 if( moduleIndex < postProcessingModules.getSize() ){
 if( postProcessingModules[ moduleIndex ] == NULL ) return NULL;
 
 if( T::getId() == postProcessingModules[ moduleIndex ]->getId() ){
 return dynamic_cast<T*>( postProcessingModules[ moduleIndex ] );
 }
 }
 return NULL;
 }
 
 template <class T> T* const getContextModule(const UINT contextLevel,const UINT moduleIndex) const{
 if( contextLevel < contextModules.getSize() ){
 if( moduleIndex >= contextModules[ contextLevel ].getSize() ){
 return NULL;
 }

 if( contextModules[ contextLevel ][ moduleIndex ] == NULL ) return NULL;
 
 if( T::getId() == contextModules[ contextLevel ][ moduleIndex ]->getId() ){
 return dynamic_cast<const T*>(contextModules[ contextLevel ][ moduleIndex ]);
 }
 }
 return NULL;
 }

 template <class T> T* getContextModule(const UINT contextLevel,const UINT moduleIndex){
 if( contextLevel < contextModules.getSize() ){
 if( moduleIndex >= contextModules[ contextLevel ].getSize() ){
 return NULL;
 }

 if( contextModules[ contextLevel ][ moduleIndex ] == NULL ) return NULL;
 
 if( T::getId() == contextModules[ contextLevel ][ moduleIndex ]->getId() ){
 return dynamic_cast<T*>(contextModules[ contextLevel ][ moduleIndex ]);
 }
 }
 return NULL;
 }
 
 virtual std::string getModelAsString() const override;
 
 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);

 using MLBase::train;
 using MLBase::train_;
 using MLBase::predict;

protected:
 bool init();
 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);
 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;
 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