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