MLBase.h

Go to the documentation of this file.

#ifndef GRT_MLBASE_HEADER
#define GRT_MLBASE_HEADER

#include "GRTBase.h"
#include "../Util/Metrics.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 GRT_API TrainingResultsObserverManager : public ObserverManager< TrainingResult >
{
    public:
    TrainingResultsObserverManager(){
    }
    virtual ~TrainingResultsObserverManager(){}
    
};

class GRT_API TestResultsObserverManager : public ObserverManager< TestInstanceResult >
{
    public:
    TestResultsObserverManager(){
    }
    virtual ~TestResultsObserverManager(){}
    
};

class GRT_API MLBase : public GRTBase, public Observer< TrainingResult >, public Observer< TestInstanceResult >
{
public:
    enum BaseType{BASE_TYPE_NOT_SET=0,CLASSIFIER,REGRESSIFIER,CLUSTERER,PRE_PROCSSING,POST_PROCESSING,FEATURE_EXTRACTION,CONTEXT}; 

    MLBase( const std::string &id = "", const BaseType type = BASE_TYPE_NOT_SET );
    
    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(RegressionData trainingData,RegressionData validationData);
    
    virtual bool train_(RegressionData &trainingData,RegressionData &validationData);
    
    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 save(std::fstream &file) const;
    
    virtual bool load(std::fstream &file);
    
    GRT_DEPRECATED_MSG( "saveModelToFile(std::string filename) is deprecated, use save(const std::string &filename) instead", virtual bool saveModelToFile(const std::string &filename) const );
    
    GRT_DEPRECATED_MSG( "saveModelToFile(std::fstream &file) is deprecated, use save(std::fstream &file) instead", virtual bool saveModelToFile(std::fstream &file) const );
    
    GRT_DEPRECATED_MSG( "loadModelFromFile(std::string filename) is deprecated, use load(const std::string &filename) instead",virtual bool loadModelFromFile(const std::string &filename) );
    
    GRT_DEPRECATED_MSG( "loadModelFromFile(std::fstream &file) is deprecated, use load(std::fstream &file) instead",virtual bool loadModelFromFile(std::fstream &file) );

    virtual bool getModel(std::ostream &stream) const;
    
    virtual std::string getModelAsString() const;
    
    DataType getInputType() const;
    
    DataType getOutputType() const;
    
    BaseType getType() const;
    
    UINT getNumInputFeatures() const;
    
    UINT getNumInputDimensions() const;
    
    UINT getNumOutputDimensions() const;
    
    UINT getMinNumEpochs() const;
    
    UINT getMaxNumEpochs() const;

    UINT getBatchSize() const;

    UINT getNumRestarts() const;
    
    UINT getValidationSetSize() const;
    
    UINT getNumTrainingIterationsToConverge() const;
    
    Float getMinChange() const;
    
    Float getLearningRate() const;

    Float getRMSTrainingError() const;
    
    GRT_DEPRECATED_MSG( "getRootMeanSquaredTrainingError() is deprecated, use getRMSTrainingError() instead", Float getRootMeanSquaredTrainingError() const );
    
    Float getTotalSquaredTrainingError() const;

    Float getRMSValidationError() const;
    
    Float getValidationSetAccuracy() const;
    
    VectorFloat getValidationSetPrecision() const;
    
    VectorFloat getValidationSetRecall() const;
    
    bool getUseValidationSet() const;
    
    bool getRandomiseTrainingOrder() const;
    
    bool getTrained() const;
    
    GRT_DEPRECATED_MSG( "getModelTrained() is deprecated, use getTrained() instead", bool getModelTrained() const );
    
    bool getConverged() const;
    
    bool getScalingEnabled() const;
    
    bool getIsBaseTypeClassifier() const;
    
    bool getIsBaseTypeRegressifier() const;
    
    bool getIsBaseTypeClusterer() const;

    bool getTrainingLoggingEnabled() const;

    bool getTestingLoggingEnabled() const;
    
    bool enableScaling(const bool useScaling);
    
    bool setMaxNumEpochs(const UINT maxNumEpochs);

    bool setBatchSize(const UINT batchSize);
    
    bool setMinNumEpochs(const UINT minNumEpochs);

    bool setNumRestarts(const UINT numRestarts);
    
    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 setTestingLoggingEnabled(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;
    bool converged;
    DataType inputType;
    DataType outputType;
    BaseType baseType;
    UINT numInputDimensions;
    UINT numOutputDimensions;
    UINT numTrainingIterationsToConverge;
    UINT minNumEpochs;
    UINT maxNumEpochs;
    UINT batchSize;
    UINT validationSetSize;
    UINT numRestarts;
    Float learningRate;
    Float minChange;
    Float rmsTrainingError;
    Float rmsValidationError;
    Float totalSquaredTrainingError;
    Float validationSetAccuracy;
    bool useValidationSet;
    bool randomiseTrainingOrder;
    VectorFloat validationSetPrecision;
    VectorFloat validationSetRecall;
    Random random;
    Vector< TrainingResult > trainingResults;
    TrainingResultsObserverManager trainingResultsObserverManager;
    TestResultsObserverManager testResultsObserverManager;
    TrainingLog trainingLog;
    TestingLog testingLog;
    
};

GRT_END_NAMESPACE

#endif //GRT_MLBASE_HEADER