MLBase.h

Go to the documentation of this file.

#ifndef GRT_MLBASE_HEADER
#define GRT_MLBASE_HEADER

#include "GRTBase.h"
#include "../DataStructures/UnlabelledData.h"
#include "../DataStructures/ClassificationData.h"
#include "../DataStructures/ClassificationDataStream.h"
#include "../DataStructures/RegressionData.h"
#include "../DataStructures/TimeSeriesClassificationData.h"

GRT_BEGIN_NAMESPACE

#define DEFAULT_NULL_LIKELIHOOD_VALUE 0
#define DEFAULT_NULL_DISTANCE_VALUE 0
    
class TrainingResultsObserverManager : public ObserverManager< TrainingResult >
{
public:
    TrainingResultsObserverManager(){
    }
    virtual ~TrainingResultsObserverManager(){}
    
};
    
class TestResultsObserverManager : public ObserverManager< TestInstanceResult >
{
public:
    TestResultsObserverManager(){
    }
    virtual ~TestResultsObserverManager(){}
    
};

class MLBase : public GRTBase, public Observer< TrainingResult >, public Observer< TestInstanceResult >
{
public:
 MLBase(void);

 virtual ~MLBase(void);

    bool copyMLBaseVariables(const MLBase *mlBase);
    
    virtual bool train(ClassificationData trainingData);
    
    virtual bool train_(ClassificationData &trainingData);
    
    virtual bool train(RegressionData trainingData);
    
    virtual bool train_(RegressionData &trainingData);
    
    virtual bool train(TimeSeriesClassificationData trainingData);
    
    virtual bool train_(TimeSeriesClassificationData &trainingData);
    
    virtual bool train(ClassificationDataStream trainingData);
    
    virtual bool train_(ClassificationDataStream &trainingData);
    
    virtual bool train(UnlabelledData trainingData);
    
    virtual bool train_(UnlabelledData &trainingData);
    
    virtual bool train(MatrixFloat data);
    
    virtual bool train_(MatrixFloat &data);

    virtual bool predict(VectorFloat inputVector);
    
    virtual bool predict_(VectorFloat &inputVector);
    
    virtual bool predict(MatrixFloat inputMatrix);
    
    virtual bool predict_(MatrixFloat &inputMatrix);
    
    virtual bool map(VectorFloat inputVector);
    
    virtual bool map_(VectorFloat &inputVector);
    
    virtual bool reset();
    
    virtual bool clear();
    
    virtual bool print() const;
    
    virtual bool save(const std::string filename) const;
    
    virtual bool load(const std::string filename);
    
    virtual bool saveModelToFile(std::string filename) const;
    
    virtual bool saveModelToFile(std::fstream &file) const;
    
    virtual bool loadModelFromFile(std::string filename);
    
    virtual bool loadModelFromFile(std::fstream &file);
    
    virtual bool getModel(std::ostream &stream) const;
    
    Float inline scale(const Float &x,const Float &minSource,const Float &maxSource,const Float &minTarget,const Float &maxTarget,const bool constrain=false){
        if( constrain ){
            if( x <= minSource ) return minTarget;
            if( x >= maxSource ) return maxTarget;
        }
        if( minSource == maxSource ) return minTarget;
        return (((x-minSource)*(maxTarget-minTarget))/(maxSource-minSource))+minTarget;
    }
    
    virtual std::string getModelAsString() const;

    DataType getInputType() const;

    DataType getOutputType() const;

    UINT getBaseType() const;

    UINT getNumInputFeatures() const;
    
    UINT getNumInputDimensions() const;
    
    UINT getNumOutputDimensions() const;
    
 UINT getMinNumEpochs() const;
    
 UINT getMaxNumEpochs() const;
    
 UINT getValidationSetSize() const;
    
    UINT getNumTrainingIterationsToConverge() const;
    
 Float getMinChange() const;
    
    Float getLearningRate() const;
    
    Float getRootMeanSquaredTrainingError() const;
    
    Float getTotalSquaredTrainingError() const;

    Float getValidationSetAccuracy() const;

    VectorFloat getValidationSetPrecision() const;

    VectorFloat getValidationSetRecall() const;
    
 bool getUseValidationSet() const;
    
 bool getRandomiseTrainingOrder() const;
    
    bool getTrained() const;

    bool getModelTrained() const;
    
    bool getScalingEnabled() const;
    
    bool getIsBaseTypeClassifier() const;
    
    bool getIsBaseTypeRegressifier() const;
    
    bool getIsBaseTypeClusterer() const;
    
    bool enableScaling(const bool useScaling);
    
    bool setMaxNumEpochs(const UINT maxNumEpochs);
    
    bool setMinNumEpochs(const UINT minNumEpochs);
    
    bool setMinChange(const Float minChange);
    
    bool setLearningRate(const Float learningRate);
    
    bool setUseValidationSet(const bool useValidationSet);
    
    bool setValidationSetSize(const UINT validationSetSize);
    
    bool setRandomiseTrainingOrder(const bool randomiseTrainingOrder);
    
    bool setTrainingLoggingEnabled(const bool loggingEnabled);
    
    bool registerTrainingResultsObserver( Observer< TrainingResult > &observer );
    
    bool registerTestResultsObserver( Observer< TestInstanceResult > &observer );
    
    bool removeTrainingResultsObserver( const Observer< TrainingResult > &observer );
    
    bool removeTestResultsObserver( const Observer< TestInstanceResult > &observer );
    
    bool removeAllTrainingObservers();
    
    bool removeAllTestObservers();
    
    bool notifyTrainingResultsObservers( const TrainingResult &data );
    
    bool notifyTestResultsObservers( const TestInstanceResult &data );
    
    MLBase* getMLBasePointer();
    
    const MLBase* getMLBasePointer() const;
    
    Vector< TrainingResult > getTrainingResults() const;

protected:
    
    bool saveBaseSettingsToFile( std::fstream &file ) const;
    
    bool loadBaseSettingsFromFile( std::fstream &file );
    
    bool trained;
    bool useScaling;
    DataType inputType;
    DataType outputType;
    UINT baseType;
    UINT numInputDimensions;
    UINT numOutputDimensions;
    UINT numTrainingIterationsToConverge;
    UINT minNumEpochs;
    UINT maxNumEpochs;
    UINT validationSetSize;
    Float learningRate;
    Float minChange;
    Float rootMeanSquaredTrainingError;
    Float totalSquaredTrainingError;
    Float validationSetAccuracy;
    bool useValidationSet;
    bool randomiseTrainingOrder;
    VectorFloat validationSetPrecision;
    VectorFloat validationSetRecall;
    Random random;
    std::vector< TrainingResult > trainingResults;
    TrainingResultsObserverManager trainingResultsObserverManager;
    TestResultsObserverManager testResultsObserverManager;
    
public:

    enum BaseTypes{BASE_TYPE_NOT_SET=0,CLASSIFIER,REGRESSIFIER,CLUSTERER};
};

GRT_END_NAMESPACE

#endif //GRT_MLBASE_HEADER