ClassificationData.h

Go to the documentation of this file.

#ifndef GRT_CLASSIFICATION_DATA_HEADER
#define GRT_CLASSIFICATION_DATA_HEADER

#include "VectorFloat.h"
#include "../Util/GRTCommon.h"
#include "../CoreModules/GRTBase.h"
#include "ClassificationSample.h"
#include "RegressionData.h"
#include "UnlabelledData.h"

GRT_BEGIN_NAMESPACE

class ClassificationData : public GRTBase{
public:
    
    ClassificationData(UINT numDimensions = 0,std::string datasetName = "NOT_SET",std::string infoText = "");

    ClassificationData(const ClassificationData &rhs);

    virtual ~ClassificationData();

 ClassificationData& operator=(const ClassificationData &rhs);

    inline ClassificationSample& operator[] (const UINT &i){
        return data[i];
    }

    inline const ClassificationSample& operator[] (const UINT &i) const{
        return data[i];
    }

    void clear();
    
    bool setNumDimensions(UINT numDimensions);
    
    bool setDatasetName(std::string datasetName);
    
    bool setInfoText(std::string infoText);

    bool setClassNameForCorrespondingClassLabel(std::string className,UINT classLabel);
    
    bool setAllowNullGestureClass(bool allowNullGestureClass);

    bool addSample(UINT classLabel,const VectorFloat &sample);
    
    bool removeSample( const UINT index );
    
    bool removeLastSample();
    
    bool reserve(const UINT N);
    
    bool addClass(const UINT classLabel,const std::string className = "NOT_SET");
    
    UINT removeClass(const UINT classLabel);

    UINT eraseAllSamplesWithClassLabel(const UINT classLabel);
    
    bool relabelAllSamplesWithClassLabel(const UINT oldClassLabel,const UINT newClassLabel);
    
    bool setExternalRanges(const Vector< MinMax > &externalRanges,const bool useExternalRanges = false);
    
    bool enableExternalRangeScaling(const bool useExternalRanges);

    bool scale(const Float minTarget,const Float maxTarget);
    
    bool scale(const Vector<MinMax> &ranges,const Float minTarget,const Float maxTarget);
 
    bool save(const std::string &filename) const;
    
    bool load(const std::string &filename);
    
    bool saveDatasetToFile(const std::string &filename) const;
 
    bool loadDatasetFromFile(const std::string &filename);
    
    bool saveDatasetToCSVFile(const std::string &filename) const;
 
    bool loadDatasetFromCSVFile(const std::string &filename,const UINT classLabelColumnIndex = 0);
    
    bool printStats() const;

    bool sortClassLabels();
    
    bool merge(const ClassificationData &data);
    
    ClassificationData partition(const UINT partitionPercentage,const bool useStratifiedSampling = false);
    
    bool spiltDataIntoKFolds(const UINT K,const bool useStratifiedSampling = false);
    
    ClassificationData getTrainingFoldData(const UINT foldIndex) const;
    
    ClassificationData getTestFoldData(const UINT foldIndex) const;
    
    ClassificationData getClassData(const UINT classLabel) const;
    
    ClassificationData getBootstrappedDataset(UINT numSamples=0, bool balanceDataset=false ) const;
    
    RegressionData reformatAsRegressionData() const;
    
    UnlabelledData reformatAsUnlabelledData() const;
    
    std::string getDatasetName() const{ return datasetName; }
    
    std::string getInfoText() const{ return infoText; }

    std::string getStatsAsString() const;
    
 UINT inline getNumDimensions() const{ return numDimensions; }
 
 UINT inline getNumSamples() const{ return totalNumSamples; }
 
 UINT inline getNumClasses() const{ return classTracker.getSize(); }
    
    UINT getMinimumClassLabel() const;
    
    UINT getMaximumClassLabel() const;
    
    UINT getClassLabelIndexValue(const UINT classLabel) const;
    
    std::string getClassNameForCorrespondingClassLabel(const UINT classLabel) const;
    
    Vector<MinMax> getRanges() const;

    Vector< UINT > getClassLabels() const;

    Vector< UINT > getNumSamplesPerClass() const;

    Vector< ClassTracker > getClassTracker() const{ return classTracker; }

    MatrixFloat getClassHistogramData(const UINT classLabel,const UINT numBins) const;

    Vector< MatrixFloat > getHistogramData(const UINT numBins) const;
    
 Vector< ClassificationSample > getClassificationData() const{ return data; }
    
    VectorFloat getClassProbabilities() const;
    
    VectorFloat getClassProbabilities( const Vector< UINT > &classLabels ) const;

    VectorFloat getMean() const;
 
    VectorFloat getStdDev() const;

    MatrixFloat getClassMean() const;
 
    MatrixFloat getClassStdDev() const;
 
    MatrixFloat getCovarianceMatrix() const;

    Vector< UINT > getClassDataIndexes(const UINT classLabel) const;

    MatrixDouble getDataAsMatrixDouble() const;

    MatrixFloat getDataAsMatrixFloat() const;
    
    static bool generateGaussDataset( const std::string filename, const UINT numSamples = 10000, const UINT numClasses = 10, const UINT numDimensions = 3, const Float range = 10, const Float sigma = 1 );

private:
    
    std::string datasetName;                                
    std::string infoText;                                   
 UINT numDimensions;          
 UINT totalNumSamples;                                   
    UINT kFoldValue;                                        
    bool crossValidationSetup;                              
    bool useExternalRanges;                                 
    bool allowNullGestureClass;                             
    Vector< MinMax > externalRanges;                        
 Vector< ClassTracker > classTracker;     
 Vector< ClassificationSample > data;                    
    Vector< Vector< UINT > >    crossValidationIndexs;      
};

GRT_END_NAMESPACE

#endif //GRT_CLASSIFICATION_DATA_HEADER