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 MLP : public Regressifier{
public:
    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 saveModelToFile( std::fstream &file ) const;
    
    virtual bool loadModelFromFile( 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 UINT inputLayerActivationFunction,
              const UINT hiddenLayerActivationFunction, const UINT outputLayerActivationFunction);
    
    void printNetwork() const;
    
    bool checkForNAN() const;
    
 std::string activationFunctionToString(const UINT activationFunction) const;
    
 UINT activationFunctionFromString(const std::string activationName) const;
    
 bool validateActivationFunction(const UINT avactivationFunction) const;

 UINT getNumInputNeurons() const;
    
 UINT getNumHiddenNeurons() const;
    
 UINT getNumOutputNeurons() const;
    
 UINT getInputLayerActivationFunction() const;
    
 UINT getHiddenLayerActivationFunction() const;
    
 UINT getOutputLayerActivationFunction() const;
    
 UINT getNumRandomTrainingIterations() 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 UINT activationFunction);
    
 bool setHiddenLayerActivationFunction(const UINT activationFunction);
    
 bool setOutputLayerActivationFunction(const UINT activationFunction);
 
    bool setTrainingRate(const Float trainingRate);
    
 bool setMomentum(const Float momentum);
    
 bool setGamma(const Float gamma);
 
    bool setNumRandomTrainingIterations(const UINT numRandomTrainingIterations);
    
    bool setNullRejection(const bool useNullRejection);
    
    bool setNullRejectionCoeff(const Float nullRejectionCoeff);
    
    //Tell the compiler we are using the following functions from the MLBase class to stop hidden virtual function warnings
    using MLBase::saveModelToFile;
    using MLBase::loadModelFromFile;
    using MLBase::train;
    using MLBase::train_;
    using MLBase::predict;
    using MLBase::predict_;
    
protected:
    bool inline isNAN(const Float v) const;
    
    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 &inputNeuronsOuput,VectorFloat &hiddenNeuronsOutput,VectorFloat &outputNeuronsOutput);
    
    UINT numInputNeurons;
    UINT numHiddenNeurons;
    UINT numOutputNeurons;
    UINT inputLayerActivationFunction;
    UINT hiddenLayerActivationFunction;
    UINT outputLayerActivationFunction;
    UINT numRandomTrainingIterations;
    UINT trainingMode;
 Float momentum;
 Float gamma;
    Float trainingError;
    bool initialized;
    Random random;
    
    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;
    
    static RegisterRegressifierModule< MLP > registerModule;
    
    //Temp Training Stuff
    VectorFloat inputNeuronsOuput;
    VectorFloat hiddenNeuronsOutput;
    VectorFloat outputNeuronsOutput;
    VectorFloat deltaO;
    VectorFloat deltaH;
    
public:
    enum TrainingModes{ONLINE_GRADIENT_DESCENT};
    
};

GRT_END_NAMESPACE

#endif //GRT_MLP_HEADER