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