BernoulliRBM.h

Go to the documentation of this file.

#ifndef GRT_BERNOULLI_RBM_HEADER
#define GRT_BERNOULLI_RBM_HEADER

#include "../../Util/GRTTypedefs.h"
#include "../../DataStructures/MatrixFloat.h"
#include "../../CoreModules/MLBase.h"

GRT_BEGIN_NAMESPACE

class GRT_API BernoulliRBM : public MLBase{
    
    public:
    BernoulliRBM(const UINT numHiddenUnits = 100,const UINT maxNumEpochs = 1000,const Float learningRate = 1,const Float learningRateUpdate = 1,const Float momentum = 0.5,const bool useScaling = true,const bool randomiseTrainingOrder = true);
    
    virtual ~BernoulliRBM();
    
    bool predict_(VectorFloat &inputData);
    
    bool predict_(VectorFloat &inputData,VectorFloat &outputData);
    
    bool predict_(const MatrixFloat &inputData,MatrixFloat &outputData,const UINT rowIndex);
    
    virtual bool train_(MatrixFloat &data);
    
    virtual bool reset();
    
    virtual bool clear();
    
    virtual bool save( std::fstream &file ) const;
    
    virtual bool load( std::fstream &file );
    
    bool reconstruct(const VectorFloat &input,VectorFloat &output);
    
    virtual bool print() const;
    
    bool getRandomizeWeightsForTraining() const;
    UINT getNumVisibleUnits() const;
    UINT getNumHiddenUnits() const;
    VectorFloat getOutputData() const;
    const MatrixFloat& getWeights() const;
    
    bool setNumHiddenUnits(const UINT numHiddenUnits);
    bool setMomentum(const Float momentum);
    bool setLearningRateUpdate(const Float learningRateUpdate);
    bool setRandomizeWeightsForTraining(const bool randomizeWeightsForTraining);
    bool setBatchSize(const UINT batchSize);
    bool setBatchStepSize(const UINT batchStepSize);
    
    //Tell the compiler we are using the base class train method to stop hidden virtual function warnings
    using MLBase::save;
    using MLBase::load;
    using MLBase::train; 
    using MLBase::predict; 
    using MLBase::train_; 
    using MLBase::predict_; 
    
protected:
    bool loadLegacyModelFromFile( std::fstream &file );
    
    inline Float sigmoidRandom(const Float &x){
        return (1.0 / (1.0 + exp(-x)) > rand.getRandomNumberUniform(0.0,1.0)) ? 1.0 : 0.0;
    }
    
    bool randomizeWeightsForTraining;
    UINT numVisibleUnits;
    UINT numHiddenUnits;
    UINT batchSize;
    UINT batchStepSize;
    Float momentum;
    Float learningRateUpdate;
    MatrixFloat weightsMatrix;
    VectorFloat visibleLayerBias;
    VectorFloat hiddenLayerBias;
    VectorFloat ph_mean;
    VectorFloat ph_sample;
    VectorFloat nv_means;
    VectorFloat nv_samples;
    VectorFloat nh_means;
    VectorFloat nh_samples;
    VectorFloat outputData;
    Vector<MinMax> ranges;
    Random rand;
    
    struct BatchIndexs{
        UINT startIndex;
        UINT endIndex;
        UINT batchSize;
    };
    typedef struct BatchIndexs BatchIndexs;
    
};

GRT_END_NAMESPACE

#endif //GRT_BERNOULLI_RBM_HEADER