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