OnlineLearning.h

#ifndef OnlineLearning_H
#define OnlineLearning_H

#include <cstdlib>

#include "LearningAlgorithm.h"
#include "util.h"
#include "TopolParams.h"
#include <math.h>



class OnlineLearning : public LearningAlgorithm {



public:
        OnlineLearning(const TopolParams& s):LearningAlgorithm(s) {};

        int Learning ( NetParams& net );
        
        const char* className(); //dev-cpp implementation

};


int 
OnlineLearning::Learning ( NetParams& net ) {

        int i, i1, j, bmu, t, order_pos, mod, pick, temp;
        Value_Type h, r, alpha_init, alpha;     
        Value_Type      d                       = net.getData()->getDimension(); 
        int             m                       = net.getMapcode()->getMapSize();
        int             n                       = net.getData()->getDataSize(); 
        
        int             num_iterations          = net.getNumIterations();
        int             neighboor               = net.getMapcode()->getNeighborType();
        
        TMatrix entries                 = net.getData()->getEntries();
        SOMData * data                  = net.getData();
        TMatrix delta                   = net.getDelta();

        TMatrix codebook                = net.getMapcode()->getCodebook();
        Mapcode * mapcode               = net.getMapcode();
        
        BMUnode  * winr;

        //initialization of vector order
        vector<int> order;
        for (int i = 0; i < n; i++) {
          order.push_back(i+1);
        }
        srand( (unsigned) time ( NULL ) );

        
        r = net.getInitNeighbor();
        alpha_init = net.getInitLearningRate();
        alpha = alpha_init;

        for (t=1; t<= num_iterations; t++ ) {
              
              setActualIteraction( t );
                        
              mod = n;
              
              for (i = 1; i <= n; i++) {
                  order_pos = ( rand() % mod );
                  pick = order[order_pos];

                  winr = winner(data, mapcode, pick);

                  for (i1=1; i1<=m; i1++) 
                  {
                          h = getTopology()->H( delta[i1][winr->i], r, neighboor );
                          
                          for ( j=1; j<=d; j++) 
                            codebook[i1][j] += h*alpha*( entries[pick][j] - codebook[i1][j] );
                  } 
                  mapcode->setCodebook( codebook );


                  if (order_pos != mod) 
                  {
                    temp = order[mod - 1];
                    order[mod - 1] = order[order_pos];
                    order[order_pos] = temp;
                  } 
                  mod--;
              }

              //radius and learning rate atualizations

              r = radius( r, num_iterations, t);
              alpha = LearningAlgorithm::alpha( alpha_init, num_iterations, t);
        }
        net.getMapcode()->setCodebook( codebook );
        MakeBMU(data,mapcode);

        return 0;
};

#endif

---