main_train.cpp

/*
    This example reads the entry data, sets the SOM parameters, trains the net, prints the training quality and the elapsed time for training, and then saves the net's map.

        
        This program takes as parameters:
                - the path to a file of type txt (e.g.: \data\IrisInputTrain.txt);
                - the type of learning (e.g.: 'batch' or 'online');
                - the two dimensions of the SOM (e.g.: 10 15);
                - the number of iterations (e.g.: 1000)
                - the name of the output file where the net will be saved
                
        ./somcode <file path> <learning type> <dimension one> <dimension two> <numIte> <output file name>

        Example of how to execute this program: ./somcode ./data/IrisInputTrain.txt batch 10 15 1000 map10_15.txt       

        This is just an example. The values of the parameters must be adjusted to each situation.
        
*/



#pragma warning(disable: 4786)

#include <cstdlib>
#include <iostream>
#include <vector>
#include <string>

//inclusion of the libraries from somcode needed to compile this example correctly

#include "RepositorySOMDataXML.h"
#include "RepositoryMapcodeXML.h"
#include "RepositorySOMDataFile.h"
#include "RepositoryMapcodeFile.h"



#include "Som.h"
#include "SOMDataCadastre.h"
#include "MapcodeCadastre.h"

#include "GraphSegmentation.h"
#include "CDbw.h"
#include "DaviesBouldin.h"

#include "BatchFactory.h"
#include "TwoDFactory.h"
#include "OnlineFactory.h"


using std::cout;

//creates the object constructors from abstract factory pattern

static OnlineFactory fact_online("Online");
static BatchFactory fact_batch("Batch");
static TwoDFactory fact_twoD("Two");



int main(int argc, char *argv[]) {  

  try {
    
          
          clock_t c0 = clock();
  
          //abstract class used as interface to the different ways to access data used for training.
          ISOMDataRepository *repD;  

          //concrete class used to isolate data from storing details.
          SOMDataCadastre *cadD;

          //attribution of the parameter which contains the name of the file that will be read.
          std::vector<std::string> params;
          params.push_back(argv[1]);    

          //creates an object of the concrete class that implements the way to access data through file systems
          repD = new RepositorySOMDataFile();
          repD->load(params,0);

           //instantiates an object of the concrete class SOMDataCadastre, which is used to isolate data from storing details
          cadD = new SOMDataCadastre(*repD);

          cout << "Starting SOMCode-1.0 ...\n\n";
 
          //reads the file through the concrete class SOMDataCadastre
          SOMData* data = cadD->load( std::vector<std::string>() );

          clock_t c1 = clock();
  
         
          clock_t c2 = clock();

          int dimL, dimC, numIte; 
          dimL = strtoint(argv[3]);
          dimC = strtoint(argv[4]);
          numIte = strtoint(argv[5]);

          //instantiates the object 'net', of type NetParams, which represents the net. 
          NetParams* net = new NetParams();

          //instantiates the object 'map', of type Mapcode, which represents the net's map
          Mapcode* map = new Mapcode();


          net->setData(data);
          net->setNumIterations( numIte );
          net->setInitType( LINEAR );
          net->setInitLearningRate( 0.5 );
          net->setInitNeighbor( 15 );

          if ( strcmp(argv[2],"online") == 0 ){
             net->setLearningType( ONLINE );
             net->setLearnType( "Online" );
          }

          if ( strcmp(argv[2],"batch") == 0 ) {
            net->setLearningType( BATCH );
            net->setLearnType( "Batch" );
          }

          net->setMapcode(map);


          /*
               Map's variables initialization
               
               setNumVar - sets the dimension of the entry vectors, i.e, the number of variables
               setDimensions - sets the size to a certain net dimension
               setLattice - sets the type of spatial arrangement
               setNeighborType - sets the type of neighborhood
               setTopolParamsText - sets the type of topology related to the number of dimensions
               setDimension - sets the number of dimensions
          */

          net->getMapcode()->setNumVar( data->getDimension() );
          net->getMapcode()->setDimensions( 0, dimL );
          net->getMapcode()->setDimensions( 1, dimC );
          net->getMapcode()->setLattice( "hexa" );      
          net->getMapcode()->setNeighborType( "gaussian" );
          net->getMapcode()->setTopolParamsText( Default_DimensionType );
          net->getMapcode()->setDimension(2);
  
          //instantiates the object mysom, of type SOM, which represents the SOM neural network
          SOM* mysom = new SOM(*net);


          /*
               Calls the SOM methods:
               - InitMapcode - initializes the map;
               - Learning - trains the net;
               - Quality - calculates the learning quality indexes;
               - Labeling -> labels the code vectors of the map;
          */

        
          mysom->InitMapcode();         
          mysom->Learning();            
          mysom->Quality();
          mysom->Labeling(); 
        
          clock_t c3 = clock();
        
            

          cout << "Quantization error = " << mysom->getQuantizationError() << std::endl;
          cout << "Topological error = " << mysom->getTopologicalError() << std::endl;
          cout << "Time elapsed Loading Data= " << (float) (c1 - c0)/CLOCKS_PER_SEC << std::endl;
          cout << "Time elapsed Computing Data = " << (float) (c3 - c2)/CLOCKS_PER_SEC << std::endl;

                
          //saves the net's map in a file with the name passed as the last parameter 
          RepositoryMapcodeFile repMapcode;
          repMapcode.save(mysom->getMapcode(),argv[6]);

                 
    
         delete data;
         delete mysom;

  } catch(std::exception& ex) {
    cout << ex.what() << std::endl;
  }
      
  return EXIT_SUCCESS;
  
};

---