LearningAlgorithm.h

#ifndef LearningAlgorithm_H
#define LearningAlgorithm_H


#include  <math.h>
#include <iostream>
#include "TopologyImp.h"
#include "NetParams.h"
#include "TopologyFactory.h"
//#include "qobject.h"

#include "defs.h"

//class LearningAlgorithm : public QObject {


class LearningAlgorithm {
public: 
        virtual int Learning( NetParams& net) = 0;

        TopologyImp * getTopology();

        Value_Type alpha( Value_Type init, Value_Type ite, int t  );    

        Value_Type radius( Value_Type init, Value_Type ite, int t  );   

        TBMU * getBMU();

        TBMU * MakeBMU( const SOMData * data, const Mapcode * mapcode );

        BMUnode * winner( const SOMData* data, const Mapcode* mapcode, const int& pos );

        ~LearningAlgorithm();

        int getActualIteraction();


        int EECNI( NetParams& net, int fi );

        
protected:
    LearningAlgorithm(const TopolParams& par);

        int setActualIteraction( int ite );


private:
        TopologyImp * _topology;
        TBMU            * _bmu; 
        BMUnode    * _bestunit;
        int          _actualiteraction;
};

int 
LearningAlgorithm::EECNI( NetParams& net, int fi ) 
{       
        TLabel mapLabel = net.getMapcode()->getLabel();
        TMatrix delta   = net.getDelta();
        int m                   = net.getMapcode()->getMapSize();
        int d                   = net.getMapcode()->getNumVar();
        Value_Type diff, min_dist;
        int neighbor, ind_min;
        bool found;

        if (!mapLabel.empty()) {
                TMatrix tmp_codebook = net.getMapcode()->getCodebook();
                TMatrix codebook         = net.getMapcode()->getCodebook();
                for (int i = 1; i <= mapLabel.size(); i++ ) {
                        found = false;
                        if ( mapLabel[i].size() <= fi ) {                               
                                neighbor  =  1;                         
                                while (neighbor <= m ) {
                                        min_dist = 9999999;
                                        for (int j = 1; j <= m; j++ ) {
                                                if (( j != i ) && (mapLabel[j].size() > fi) && (delta[i][j]<= neighbor) && (delta[i][j] > (neighbor - 1)) ) {
                                                        diff = dist( codebook[i], codebook[j], d );
                                                        if ( diff < min_dist ) {
                                                                ind_min = j;
                                                                found = true;
                                                        }
                                                }
                                        }
                                        if (found) {
                                                for (int k=1; k<=d; k++) tmp_codebook[i][k] = codebook[ind_min][k];
                                                break;
                                        }
                                        else
                                                neighbor++;
                                };                                                              
                        }
                }
                net.getMapcode()->setCodebook( tmp_codebook );
                return 1;
        }
        return 0;
};


int 
LearningAlgorithm::getActualIteraction() 
{
        return _actualiteraction;
};

inline int 
LearningAlgorithm::setActualIteraction( int ite ) 
{
        _actualiteraction = ite;
        return _actualiteraction;
};

TBMU *
LearningAlgorithm::getBMU() 
{
        return _bmu;
};


BMUnode *
LearningAlgorithm::winner( const SOMData* data, const Mapcode* mapcode,const int& pos )
{
        int i,j, k, j_min, j_min2;   
        Value_Type dist, diff,dist_min, dist_min2;      
        int             d                       = data->getDimension();
        int             m                       = mapcode->getMapSize();
        TMatrix entries         = data->getEntries();
        TMatrix codebook        = mapcode->getCodebook();

        i = pos;

        j_min = 0;  j_min2 = 0;
        dist_min = 9999999; dist_min2 = 9999999;

        for (j = 1; j <= m; j++) {
                dist = 0;    
                for (k=1; k<= d; k++) {
                        diff = entries[i][k] - codebook[j][k]; 
                        dist += diff*diff;
                }
                if ( dist < dist_min ) {
                        j_min2 = j_min;
                        dist_min2 = dist_min;
                        j_min = j;
                        dist_min = dist;                        
                } else if ((j_min2 == 0)&&( dist < dist_min2)) {
                        j_min2 = j;
                        dist_min2 = dist;
                }               
        }               
        _bestunit = new BMUnode( j_min, sqrt(dist_min) );


        return _bestunit;
};





inline TBMU *
LearningAlgorithm::MakeBMU( const SOMData* data, const Mapcode* mapcode ) 
{       
        int i, j, k, j_min, j_min2;   
        Value_Type dist, diff,dist_min,dist_min2;       
        int             d                       = data->getDimension();
        int             n                       = data->getDataSize();
        int             m                       = mapcode->getMapSize();
        TMatrix entries         = data->getEntries();
        TMatrix codebook        = mapcode->getCodebook();
        TVecBMU vec;

        _bmu->clear();

        for (i=1; i<= n; i++) {
                j_min = 0;  j_min2 = 0;
                dist_min = 9999999; dist_min2 = 9999999;
                for (j=1; j<= m; j++) {
                        dist = 0;    
                        for (k=1; k<= d; k++) {
                                diff = entries[i][k] - codebook[j][k]; 
                                dist += diff*diff;
                        }
                        if ( dist < dist_min ) {
                                j_min2 = j_min;
                                dist_min2 = dist_min;
                                j_min = j;
                                dist_min = dist;                        
                        } else if ((j_min2 == 0)&&( dist < dist_min2)) {
                                j_min2 = j;
                                dist_min2 = dist;
                        }

                        //vec.push_back( BMUnode( j, sqrt(dist) )  );                                           
                }               
                vec.push_back( BMUnode( j_min, sqrt(dist_min) )  );
                vec.push_back( BMUnode( j_min2, sqrt(dist_min2) )  );
                //sort( vec.begin(), vec.end() );
                _bmu->push_back( vec );         
                vec.clear();
        }       
        return _bmu;
};


inline TopologyImp * 
LearningAlgorithm::getTopology() 
{
        return _topology;
};

Value_Type 
LearningAlgorithm::alpha( Value_Type init, Value_Type ite, int t  ) 
{
        return (init * exp( - (Value_Type)t/ (Value_Type)ite ));
};      

inline Value_Type 
LearningAlgorithm::radius( Value_Type init, Value_Type ite, int t  ) 
{
        return (1.0 + (init - 1.0) * (Value_Type)(ite - t)/ (Value_Type) ite);
};
        

LearningAlgorithm::~LearningAlgorithm() 
{
        free( _topology );
        free( _bmu );
};


LearningAlgorithm::LearningAlgorithm(const TopolParams& par) {

        _topology = TopologyFactory::make(par.dimension, par );
        _bmu = new TBMU;

};


#endif

---