SelfOrganizingMap.h

Go to the documentation of this file.

#ifndef GRT_SELF_ORGANIZING_MAP_HEADER
#define GRT_SELF_ORGANIZING_MAP_HEADER

#include "../../Util/GRTCommon.h"
#include "../../CoreModules/Clusterer.h"
#include "../../Util/Random.h"

GRT_BEGIN_NAMESPACE
    
class GaussNeuron{
public:
    GaussNeuron(){
        numInputs = 0;
        sigma = 0;
        initialized = false;
    }
    
    ~GaussNeuron(){
        
    }
    
    Float& operator[](const UINT index){
        return weights[ index ];
    }

    const Float& operator[](const UINT index) const{
        return weights[ index ];
    }
    
    bool init(const UINT numInputs,const Float sigma = 2.0,const Float minWeightRange = -1.0,const Float maxWeightRange = 1.0){
        
        this->numInputs = numInputs;
        this->sigma = sigma;
        weights.resize( numInputs );
        
        //Set the random seed
        Random random;
        random.setSeed( (unsigned long long)time(NULL) );
        
        //Randomise the weights between [minWeightRange maxWeightRange]
        for(unsigned int i=0; i<numInputs; i++){
            weights[i] = random.getRandomNumberUniform(minWeightRange,maxWeightRange);
        }
        
        initialized = true;

        return true;
    }
    
    bool clear(){
        
        numInputs = 0;
        weights.clear();
        initialized = false;
        return true;
        
    }
    
    bool getInitialized() const {
        return initialized;
    }
    
    Float getWeightDistance( const VectorFloat &x ) const {
        
        Float dist = 0;
        
        for(UINT i=0; i<numInputs; i++){
            dist += x[i]- weights[i];
        }
        
        return dist;
    }
    
    Float getSquaredWeightDistance( const VectorFloat &x ) const {
        
        Float dist = 0;
        
        for(UINT i=0; i<numInputs; i++){
            dist += grt_sqr( x[i]- weights[i] );
        }
        
        return dist;
    }
    
    Float fire( const VectorFloat &x ) const {
        Float y = 0;
        
        for(UINT i=0; i<numInputs; i++){
            y += grt_sqr( x[i]- weights[i] );
        }
        
        return exp( - (y/(2*grt_sqr(sigma))) );
    }
    
    bool save( std::fstream &file ) const {
        
        if( !file.is_open() ){
            return false;
        }
        
        if( !initialized ){
            return false;
        }
        
        file << "GAUSS_NEURON\n";
        file << "NumInputs: " << numInputs << std::endl;
        file << "Weights: ";
        for(UINT i=0; i<numInputs; i++){
            file << weights[i];
            if( i < numInputs-1 ) file << "\t";
        }
        file << std::endl;
        file << "Sigma: " << sigma << std::endl;
        
        return true;
    }
    
    bool load( std::fstream &file ){
        
        if( !file.is_open() ){
            return false;
        }
    
        clear();
        
        std::string word;
        
        //Read the header
        file >> word;
        if( word != "GAUSS_NEURON" ){
            return false;
        }
        
        //Read the num inputs
        file >> word;
        if( word != "NumInputs:" ){
            return false;
        }
        file >> numInputs;
        
        //Resize the weight Vector
        weights.resize( numInputs );
        
        //Read the weights header
        file >> word;
        if( word != "Weights:" ){
            return false;
        }

        //Load the weights
        for(UINT i=0; i<numInputs; i++){
            file >> weights[i];
        }
        
        //Load the sigma value
        file >> word;
        if( word != "Sigma:" ){
            return false;
        }
        file >> sigma;
        
        initialized = true;
        
        return true;
    }

    UINT numInputs;
    VectorFloat weights;
    Float sigma;
    bool initialized;
};

class GRT_API SelfOrganizingMap : public Clusterer{
        
public:
    enum NetworkTypology{RANDOM_NETWORK=0};
    
 SelfOrganizingMap(const UINT networkSize = 5, const UINT networkTypology = RANDOM_NETWORK, const UINT maxNumEpochs = 1000,const Float sigmaWeight = 0.2, const Float alphaStart = 0.3, const Float alphaEnd = 0.1);
    
    SelfOrganizingMap(const SelfOrganizingMap &rhs);
    
    virtual ~SelfOrganizingMap();
    
    SelfOrganizingMap &operator=(const SelfOrganizingMap &rhs);
    
    virtual bool deepCopyFrom(const Clusterer *clusterer);
    
    virtual bool reset();
    
    virtual bool clear();
    
    virtual bool train_(MatrixFloat &trainingData);
    
    virtual bool train_(ClassificationData &trainingData);
    
 virtual bool train_(UnlabelledData &trainingData);
    
    virtual bool map_( VectorFloat &x );
    
    virtual bool save( std::fstream &file ) const;
    
    virtual bool load( std::fstream &file );
    
    bool validateNetworkTypology( const UINT networkTypology );
    
    UINT getNetworkSize() const;
    
    Float getAlphaStart() const;
    
    Float getAlphaEnd() const;
    
    VectorFloat getMappedData() const;
    
    Matrix< GaussNeuron > getNeurons() const;
    
    const Matrix< GaussNeuron > &getNeuronsRef() const;

    Matrix< VectorFloat > getWeightsMatrix() const;
    
    bool setNetworkSize( const UINT networkSize );
    
    bool setNetworkTypology( const UINT networkTypology );
    
    bool setAlphaStart( const Float alphaStart );
    
    bool setAlphaEnd( const Float alphaEnd );

    bool setSigmaWeight( const Float sigmaWeight );
    
    //Tell the compiler we are using the base class train method to stop hidden virtual function warnings
    using MLBase::save;
    using MLBase::load;

    static std::string getId();
    
protected:
    UINT networkTypology;
    Float sigmaWeight;
    Float alphaStart;
    Float alphaEnd;
    VectorFloat mappedData;
    Matrix< GaussNeuron > neurons;
    
private:
    static RegisterClustererModule< SelfOrganizingMap > registerModule;
    static const std::string id; 
};
    
GRT_END_NAMESPACE

#endif //GRT_SELF_ORGANIZING_MAP_HEADER