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