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