Som.h

#ifndef Som_H
#define Som_H

#include <math.h>
#include <iostream>
#include "defs.h"
#include "util.h"
#include "eigensystems.h"
#include "NetParams.h"
#include "LearningFactory.h"


class SOM {
public:
        SOM( NetParams n );     

        SOM();

        
        SOM( NetParams * n, Mapcode * map);

        ~SOM();
        
        NetParams netParams;
        
        LearningAlgorithm * getLearningAlgorithm();     
        
protected:
        Value_Type              _quantization_error;
        Value_Type              _topological_error;
        void            setQuantizationError( Value_Type q );
        void            setTopologicalError( Value_Type t );
        LearningAlgorithm * _learningAlgorithm; 
        void            RandomInit();
        void            LinearInit();
        void            WindowInit();
        
        

public: 
        void Quality();
        
        int AutomaticParametrization();

        void Learning();

        int EECNI( int fi );

        void InitMapcode();     
        
        Value_Type getQuantizationError();

        Value_Type getTopologicalError();

        void Labeling();

        void setParams( NetParams n );

        void setMapcode( Mapcode * mapcode );

        void setData( SOMData * data );
        
        void setDelta( TMatrix delta );

        TMatrix getDelta() const;

        Mapcode * getMapcode() const;

        SOMData * getData() const;

        int       getNumIterations();

        void    setNumIterations( int i );

        int             getInitType();

        void    setInitType( int init );

        Value_Type      getInitLearningRate();

        void    setInitLearningRate( Value_Type init_rate );

        Value_Type      getInitNeighbor();

        void    setInitNeighbor( Value_Type init_neighbor );

        int             getLearningType();

        void    setLearningType( int t );

        void setLearnType( string str );

        string getLearnType();

        Value_Type getEigenValue( int index, int d, int n, TMatrix entries );

        vector<int> getNeighbors( int i );

        TMatrix getCities() ;

private:
        TVector eigenvalue;

};

vector<int> 
SOM::getNeighbors( int i )
{
        return getLearningAlgorithm()->getTopology()->getNeighbors( i, getMapcode()->getLattice(), getMapcode()->getDimensions() );
};

Value_Type 
SOM::getEigenValue( int index, int d, int n, TMatrix entries ) {
        
        if ( ( index >= 1 ) && ( index <= d ) ) {
                int i, j, k;
                Value_Type soma = 0.0;
                TVector mean_vector;
                TMatrix Data_tmp;
                TMatrix A;  // Autocorrelation matrix of Data   

                // init A, Data_tmp and mean_vector
                A = create_matrix( 1, d, 1, d );
                for (i=1; i<= d; i++ ) for (j=1; j<= d; j++) A[i][j] = 0.0;
                mean_vector = create_vector( 1, d ); for (i=1; i<= d; i++) mean_vector[i] = 0.0;
        

                Data_tmp = create_matrix( 1, n, 1, d ); 
                for (i=1; i<= n; i++) for (j=1; j<= d; j++) Data_tmp[i][j] = entries[i][j];


                for (j=1; j<= d; j++) for (i=1; i<=n; i++) mean_vector[j] += entries[i][j];
                for (i=1; i<= d; i++) mean_vector[i] = mean_vector[i]/n;

                for (i=1; i<= n; i++ ) for (j=1; j<= d; j++) Data_tmp[i][j] -= mean_vector[j]; 

                for (i=1; i<= d; i++) for (j=i; j<= d; j++) { for (k=1; k<= n; k++) soma += Data_tmp[k][i]*Data_tmp[k][j];
                        A[i][j] = A[j][i] = soma/n; soma = 0.0; };      
        
                TVector eigenvalue = create_vector(1, d);
                TMatrix eigenvectors = create_matrix( 1, d, 1, d );
                int *nrot = 0;

                jacobi( A, d, eigenvalue, eigenvectors, nrot );
                eigsrt( eigenvalue, eigenvectors, d );

                return eigenvalue[index];
        }       
        return 0;
};

void 
SOM::setParams( NetParams n ) {
        netParams = n;

        _learningAlgorithm = LearningFactory::make(n.getLearnType(), n.getMapcode()->getTopolParams() );
        
        TMatrix codebook = create_matrix( 1, n.getMapcode()->getMapSize(), 1, n.getData()->getDimension() );
        netParams.getMapcode()->setCodebook( codebook );
};


void 
SOM::Labeling() {
        int i;
        int m                           = netParams.getMapcode()->getMapSize();
        int n                           = netParams.getData()->getDataSize();
        TBMU * bmu                      = getLearningAlgorithm()->getBMU();
        TLabel mapLabel                 = netParams.getMapcode()->getLabel();



        TvecLabel dataLabel             = netParams.getData()->getId(); 
        
        TvecLabel vec; vec.clear();

        
        mapLabel.clear();

        for (i=0; i<m; i++) mapLabel.push_back( vec );

        for (i=0; i<n; i++) {           
                mapLabel[ bmu[0][i][0].i - 1 ].push_back( dataLabel[i] );
        }

        netParams.getMapcode()->setLabel( mapLabel );

        /*      
        TvecLabel::iterator j;
        for (i=0; i<m; i++) {
                cout << endl; cout << "No " << " " << i+1 << " ";               
                jj = 0;
                for (j=mapLabel[i].begin(); j< mapLabel[i].end(); j++) {
                        cout << *j << " "; ++jj;
                }
        }
        */
        
};

Value_Type 
SOM::getQuantizationError() {
        return _quantization_error;
};

Value_Type 
SOM::getTopologicalError() {
        return _topological_error;
};

void 
SOM::setQuantizationError( Value_Type q ) {
        _quantization_error = q;
};

void 
SOM::setTopologicalError( Value_Type t ) {
        _topological_error = t;
};

void 
SOM::Quality() {

        Value_Type topol_error  = 0.0;
        Value_Type quant_error  = 0.0;
        int i;  
        int n                           = netParams.getData()->getDataSize();   
        TBMU * bmu                      = getLearningAlgorithm()->getBMU();
        TMatrix delta           = netParams.getDelta();
        
        for (i=1; i<=n; i++) {
                if ( delta[bmu[0][i-1][0].i][bmu[0][i-1][1].i] > 1.4 ) ++topol_error;           
                quant_error += bmu[0][i-1][0].dist;
        }

        topol_error /= (Value_Type)n;
        quant_error /= (Value_Type)n;

        setQuantizationError( quant_error );
        setTopologicalError( topol_error  );
};


SOM::SOM( NetParams n ) 
{
        netParams = n;
        
        _learningAlgorithm = LearningFactory::make(n.getLearnType(), n.getMapcode()->getTopolParams() );
        
        TMatrix codebook = create_matrix( 1, n.getMapcode()->getMapSize(), 1, n.getData()->getDimension() );
        netParams.getMapcode()->setCodebook( codebook );
        
};

//adicionada para o exemplo em que eh feita a leitura do mapcode
SOM::SOM( NetParams * n, Mapcode * map)
{
        netParams = *n;
        
        _learningAlgorithm = LearningFactory::make(n->getLearnType(), n->getMapcode()->getTopolParams() );
        
        netParams.setMapcode( map );
}


SOM::SOM()
{
        getMapcode()->setDimension( DTWO );
        TopolParams Default_TopolParam( Default_DimensionType );
        setLearnType( Default_LearningType );
        netParams.setLearningType( BATCH );
        

        _learningAlgorithm = LearningFactory::make( Default_LearningType, Default_TopolParam );
};

SOM::~SOM() {
        free( _learningAlgorithm );
};


LearningAlgorithm * 
SOM::getLearningAlgorithm() { return _learningAlgorithm; };

void 
SOM::Learning() {
   getLearningAlgorithm()->Learning( netParams );
   //Quality();
};

int 
SOM::EECNI( int fi ) {    
  return getLearningAlgorithm()->EECNI( netParams, fi );
};

void 
SOM::RandomInit() {
   TVector vector_min; 
   TVector vector_max; 
   TVector vector_inc;
   int i, j;
   int d = netParams.getData()->getDimension();
   int n = netParams.getData()->getDataSize();
   int m = netParams.getMapcode()->getMapSize();

   TMatrix entries = netParams.getData()->getEntries();
   TMatrix codebook = netParams.getMapcode()->getCodebook();

   // create vectors
   vector_min = create_vector( 1, d );
   vector_max = create_vector( 1, d );
   vector_inc = create_vector( 1, d );

   // init vectors
   for (i=1; i<= d; i++ )  {
            vector_min[i] = entries[1][i];
                vector_max[i] = entries[1][i]; };
   
   // find the min vector and the max vector
   for (i=2; i<= n; i++) {                 
           for (j=1; j<= d; j++) {
                   if ( entries[i][j] < vector_min[j] ) vector_min[j] = entries[i][j];
                   if ( entries[i][j] > vector_max[j] ) vector_max[j] = entries[i][j]; }; };
   
   // init inc vector   
   for (i=1; i<= d; i++ )  vector_inc[i] = (vector_max[i] - vector_min[i])/(m - 1);

   // create the random mapcode based in a simple interporlation
   for (i=1; i<= d; i++ ) codebook[1][i] = vector_min[i];
   for (i=1; i<= d; i++ ) codebook[m][i] = vector_max[i];
   for (i=2; i<= (m-1); i++) for (j=1; j<= d; j++) 
                                codebook[i][j] = vector_min[j] + (i-1)*vector_inc[j];
   // free memory
   free_vector( vector_min, 1, d );
   free_vector( vector_max, 1, d );
   free_vector( vector_inc, 1, d );
};

void 
SOM::LinearInit() {
        int i, j, k;
        Value_Type soma = 0.0;
        
        int d                           = netParams.getData()->getDimension();  // data dimension       
        int m                           = netParams.getMapcode()->getMapSize();
        int n                           = netParams.getData()->getDataSize();
        TMatrix entries         = netParams.getData()->getEntries();    
        TMatrix codebook        = netParams.getMapcode()->getCodebook();
        TVector mean_vector;
        TMatrix Data_tmp;
        TMatrix A;  // Autocorrelation matrix of Data   


        // init A, Data_tmp and mean_vector
        A = create_matrix( 1, d, 1, d );
        for (i=1; i<= d; i++ ) for (j=1; j<= d; j++) A[i][j] = 0.0;
        mean_vector = create_vector( 1, d ); for (i=1; i<= d; i++) mean_vector[i] = 0.0;
        

        Data_tmp = create_matrix( 1, n, 1, d ); 
        for (i=1; i<= n; i++) for (j=1; j<= d; j++) Data_tmp[i][j] = entries[i][j];


        for (j=1; j<= d; j++) for (i=1; i<=n; i++) mean_vector[j] += entries[i][j];
        for (i=1; i<= d; i++) mean_vector[i] = mean_vector[i]/n;

        for (i=1; i<= n; i++ ) for (j=1; j<= d; j++) Data_tmp[i][j] -= mean_vector[j]; 

        for (i=1; i<= d; i++) for (j=i; j<= d; j++) { for (k=1; k<= n; k++) soma += Data_tmp[k][i]*Data_tmp[k][j];
                        A[i][j] = A[j][i] = soma/n; soma = 0.0; };      
        
        TVector eigenvalues = create_vector(1, d);
        TMatrix eigenvectors = create_matrix( 1, d, 1, d );
        int *nrot = 0;

        jacobi( A, d, eigenvalues, eigenvectors, nrot );
        eigsrt( eigenvalues, eigenvectors, d );

        for (i=1; i<=d; i++)
                for (j=1; j<=d; j++ )
                        eigenvectors[j][i] = eigenvectors[j][i]*sqrt( eigenvalues[i] ); 
        
        //eigenvectors[1][1] *= -1.0;
        //eigenvectors[2][1] *= -1.0;
        //eigenvectors[3][1] *= -1.0;

        eigenvalue = eigenvalues;

        for (i=1; i<=d;i++)
                for (j=1; j<=m; j++)
                        codebook[j][i] = mean_vector[i];

        int dimension = netParams.getMapcode()->getDimension();         
        TMatrix const_lininit = getLearningAlgorithm()->getTopology()->LinInitCoords(m,netParams.getMapcode()->getDimensions());
        
        for (i=1;i<=m;i++)
                for (j=1;j<=dimension;j++)
                   for (k=1;k<=d;k++)
                     codebook[i][k] += eigenvectors[k][j]*const_lininit[i][j];                          
};
 
void 
SOM::InitMapcode() {
        netParams.setDelta( getLearningAlgorithm()->getTopology()->CreateDelta( netParams.getMapcode()->getDimensions(), netParams.getMapcode()->getLattice(), netParams.getMapcode()->getMapSize() ) );
        switch( netParams.getInitType() ) {
        case RANDOMIZED :       RandomInit();            
                                                break;
        case LINEAR:            LinearInit();
                                                break;
        case WINDOW:            WindowInit();
                                                break;
        };      

};


void 
SOM::setMapcode( Mapcode * mapcode ) 
{
        netParams.setMapcode( mapcode );
};


void 
SOM::setData( SOMData * data ) 
{
        netParams.setData( data );
};
        

void 
SOM::setDelta( TMatrix delta ) 
{
        netParams.setDelta( delta );
};


TMatrix 
SOM::getDelta() const
{
        return netParams.getDelta();
};



Mapcode * 
SOM::getMapcode() const 
{
        return netParams.getMapcode();
};


SOMData * 
SOM::getData() const
{
        return netParams.getData();
};


int             
SOM::getNumIterations() 
{
        return netParams.getNumIterations();
};


void    
SOM::setNumIterations( int i ) 
{
        netParams.setNumIterations( i );
};


int             
SOM::getInitType() 
{
        return netParams.getInitType();
};


void    
SOM::setInitType( int init ) 
{
        netParams.setInitType( init );
};


Value_Type      
SOM::getInitLearningRate() 
{
        return netParams.getInitLearningRate();
};


void    
SOM::setInitLearningRate( Value_Type init_rate ) 
{
        netParams.setInitLearningRate( init_rate );
};


Value_Type      
SOM::getInitNeighbor() 
{
        return netParams.getInitNeighbor();
};


void    
SOM::setInitNeighbor( Value_Type init_neighbor ) 
{
        netParams.setInitNeighbor( init_neighbor );
};


int             
SOM::getLearningType()
{
        return netParams.getLearningType();
};


void    
SOM::setLearningType( int t )
{
        netParams.setLearningType( t );
};


void 
SOM::setLearnType( string str )
{
        netParams.setLearnType( str );

        //_learningAlgorithm = LearningFactory::make( getLearnType(), getMapcode()->getTopolParams() );

};


string 
SOM::getLearnType()
{
        return netParams.getLearnType();
};



TMatrix
SOM::getCities()
{
        return netParams.getData()->getEntries();
};


void 
SOM::WindowInit() {
   int i;
   int d = netParams.getData()->getDimension();
   int n = netParams.getData()->getDataSize();  // the total of cities 
   int m = netParams.getMapcode()->getMapSize(); // the total of neurons on the toros
   int total = m ;
   Value_Type x_min , x_max , y_min , y_max ;

   TMatrix entries = netParams.getData()->getEntries();
   TMatrix codebook = netParams.getMapcode()->getCodebook();

   // searching for the smaller and bigger x coordinate of all the cities
   x_min = entries[1][1] ;
   x_max = entries[1][1] ;
   for (i=2; i<=n ; i++) {
        if (entries[i][1] < x_min) x_min = entries[i][1] ;
        if (entries[i][1] > x_max) x_max = entries[i][1] ;
        };
   // searching for the smaller and bigger y coordinate of all the cities
   y_min = entries[1][2] ;
   y_max = entries[1][2] ;
   for (i=2; i<=n ; i++) {
        if (entries[i][2] < y_min) y_min = entries[i][2] ;
        if (entries[i][2] > y_max) y_max = entries[i][2] ;
        };

   // create the frame mapcode based in the x_min , x_max , y_min , y_max coordinates

   Value_Type perimeter = 2*(x_max - x_min) + 2*(y_max - y_min); // calculates the lenght of the frame
   Value_Type space = perimeter/total ;                              // space between the nodes on the frame
   char side = 'W' ;                                             // side of the frame 
   Value_Type x_factor , y_factor , rest_factor ,                // variables that regulate the coordinates of
              x_cur_node , y_cur_node ;                          // the nodes on the frame during its initialization
   int half_path = 1 ;                                           // indicates if the process is before or after the half path
   x_factor = 0.0 ;
   y_factor = space ;
   rest_factor = 0.0 ;
   int current_node = 0 ; // <-- which is the initial index ?? 0 or 1 ??

   x_cur_node = x_min ;
   y_cur_node = y_min ;

   while (side == 'W')
      {
      codebook[current_node][1] = x_cur_node ;
      codebook[current_node][2] = y_cur_node ;
      //cout << current_node << ':' << x_cur_node << ',' << y_cur_node << '\n' ;
      y_cur_node += space*half_path ;
      if (y_cur_node > y_max )
         {
         side = 'N' ;
         rest_factor = y_cur_node - y_max ;
         }
      current_node++ ;
      }

   x_cur_node = x_min + rest_factor ;
   y_cur_node = y_max ;

   while (side == 'N')
      {
      codebook[current_node][1] = x_cur_node ;
      codebook[current_node][2] = y_cur_node ;
      //cout << current_node << ':' << x_cur_node << ',' << y_cur_node << '\n' ;
      x_cur_node += space*half_path ;
      if (x_cur_node > x_max)
         {
         side = 'E' ;
         rest_factor = x_cur_node - x_max ;
         }
      current_node++ ;
      }

   x_cur_node = x_max ;
   y_cur_node = y_max - rest_factor ;

   half_path = -1 ;

   while (side == 'E')
      {
      codebook[current_node][1] = x_cur_node ;
      codebook[current_node][2] = y_cur_node ;
      //cout << current_node << ':' << x_cur_node << ',' << y_cur_node << '\n' ;
      y_cur_node += space*half_path ;
      if (y_cur_node < y_min)
         {
         side = 'S' ;
         rest_factor = y_min - y_cur_node ;
         }
      current_node++ ;
      }

   x_cur_node = x_max - rest_factor ;
   y_cur_node = y_min ;

   while (side == 'S')
      {
      codebook[current_node][1] = x_cur_node ;
      codebook[current_node][2] = y_cur_node ;
      //cout << current_node << ':' << x_cur_node << ',' << y_cur_node << '\n' ;
      x_cur_node += space*half_path ;
      if (current_node >= total)
         {
         side = 'F' ;
         }
      current_node++ ;
      }
};




#endif

---