MLP.h

Go to the documentation of this file.

#ifndef GRT_MLP_HEADER
#define GRT_MLP_HEADER

#include "Neuron.h"
#include "../../../CoreModules/Regressifier.h"

GRT_BEGIN_NAMESPACE

class GRT_API MLP : public Regressifier{
public:
 enum TrainingAlgorithm{ONLINE_GRADIENT_DESCENT=0}; 

 MLP();
 
 MLP(const MLP &rhs);
 
 virtual ~MLP();
 
 MLP &operator=(const MLP &rhs);
 
 virtual bool deepCopyFrom(const Regressifier *regressifier);
 
 virtual bool train_(ClassificationData &trainingData);
 
 virtual bool train_(RegressionData &trainingData);
 
 virtual bool predict_(VectorFloat &inputVector);
 
 virtual bool clear();
 
 virtual bool print() const;
 
 virtual bool save( std::fstream &file ) const;
 
 virtual bool load( std::fstream &file );
 
 UINT getNumClasses() const;
 
 bool init(const UINT numInputNeurons, const UINT numHiddenNeurons, const UINT numOutputNeurons);
 
 bool init(const UINT numInputNeurons, const UINT numHiddenNeurons, const UINT numOutputNeurons, 
 const Neuron::Type inputLayerActivationFunction,
 const Neuron::Type hiddenLayerActivationFunction, 
 const Neuron::Type outputLayerActivationFunction);
 
 void printNetwork() const;
 
 bool checkForNAN() const;
 
 std::string activationFunctionToString(const Neuron::Type activationFunction) const;
 
 Neuron::Type activationFunctionFromString(const std::string activationName) const;
 
 bool validateActivationFunction(const Neuron::Type avactivationFunction) const;
 
 UINT getNumInputNeurons() const;
 
 UINT getNumHiddenNeurons() const;
 
 UINT getNumOutputNeurons() const;

 UINT getNumRandomTrainingIterations() const;
 
 Neuron::Type getInputLayerActivationFunction() const;
 
 Neuron::Type getHiddenLayerActivationFunction() const;
 
 Neuron::Type getOutputLayerActivationFunction() const;
 
 Float getTrainingRate() const;
 
 Float getMomentum() const;
 
 Float getGamma() const;
 
 Float getTrainingError() const;
 
 bool getClassificationModeActive() const;
 
 bool getRegressionModeActive() const;
 
 Vector< Neuron > getInputLayer() const;
 
 Vector< Neuron > getHiddenLayer() const;
 
 Vector< Neuron > getOutputLayer() const;
 
 Vector< VectorFloat > getTrainingLog() const;
 
 bool getNullRejectionEnabled() const;
 
 Float getNullRejectionCoeff() const;
 
 Float getNullRejectionThreshold() const;
 
 Float getMaximumLikelihood() const;
 
 VectorFloat getClassLikelihoods() const;
 
 VectorFloat getClassDistances() const;
 
 UINT getPredictedClassLabel() const;
 
 bool setInputLayerActivationFunction(const Neuron::Type activationFunction);
 
 bool setHiddenLayerActivationFunction(const Neuron::Type activationFunction);
 
 bool setOutputLayerActivationFunction(const Neuron::Type activationFunction);
 
 bool setTrainingRate(const Float trainingRate);
 
 bool setMomentum(const Float momentum);
 
 bool setGamma(const Float gamma);
 
 GRT_DEPRECATED_MSG( "setNumRandomTrainingIterations() is deprecated, use setNumRestarts() instead",bool setNumRandomTrainingIterations(const UINT numRandomTrainingIterations));
 
 bool setNullRejection(const bool useNullRejection);
 
 bool setNullRejectionCoeff(const Float nullRejectionCoeff);

 static std::string getId();
 
 //Tell the compiler we are using the following functions from the MLBase class to stop hidden virtual function warnings
 using MLBase::save;
 using MLBase::load;
 using MLBase::train;
 using MLBase::train_;
 using MLBase::predict;
 using MLBase::predict_;
 
protected:
 bool inline isNAN(const Float &v) const;

 bool setOutputTargets();
 
 bool trainModel(RegressionData &trainingData);
 
 bool trainOnlineGradientDescentClassification(const RegressionData &trainingData,const RegressionData &validationData);
 
 bool trainOnlineGradientDescentRegression(const RegressionData &trainingData,const RegressionData &validationData);
 
 bool loadLegacyModelFromFile( std::fstream &file );
 
 Float back_prop(const VectorFloat &inputVector,const VectorFloat &targetVector,const Float alpha,const Float beta);
 
 VectorFloat feedforward(VectorFloat data);
 
 void feedforward(const VectorFloat &data,VectorFloat &inputNeuronsOutput,VectorFloat &hiddenNeuronsOutput,VectorFloat &outputNeuronsOutput);
 
 UINT numInputNeurons;
 UINT numHiddenNeurons;
 UINT numOutputNeurons;
 Neuron::Type inputLayerActivationFunction;
 Neuron::Type hiddenLayerActivationFunction;
 Neuron::Type outputLayerActivationFunction;
 UINT trainingMode;
 Float momentum;
 Float gamma;
 Float trainingError;
 MinMax outputTargets;
 bool initialized;
 
 Vector< Neuron > inputLayer;
 Vector< Neuron > hiddenLayer;
 Vector< Neuron > outputLayer;
 Vector< VectorFloat > trainingErrorLog;
 
 //Classifier Variables
 bool classificationModeActive;
 bool useNullRejection;
 UINT predictedClassLabel;
 Float nullRejectionThreshold;
 Float nullRejectionCoeff;
 Float maxLikelihood;
 VectorFloat classLikelihoods;
 
 //Temp Training Stuff
 VectorFloat inputNeuronsOutput;
 VectorFloat hiddenNeuronsOutput;
 VectorFloat outputNeuronsOutput;
 VectorFloat deltaO;
 VectorFloat deltaH;

private:
 static RegisterRegressifierModule< MLP > registerModule;
 static const std::string id;
 
};

GRT_END_NAMESPACE

#endif //GRT_MLP_HEADER