main_segmentation.cpp

/*
*        This example takes a saved net's map as parameter, segments the neural net and then prints the results
*
*       This program takes as parameters
*               - the path to a data file;
*               - the path to a file which contains the net's map;
*
*       ./somcode <file path> <file path>
*
*       Example of how to execute this program:  ./somcode ./data/IrinInputTrain.txt ./map10x15.txt
*
*/

#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 "util.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");

std::map<string, int>  makeTblEntry_Cluster(SOM* som,int* clusters,int dimL,int dimC);

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>() );
            
           
          //Abstract class used as interface to the different ways to access data related to a net's map
          IMapcodeRepository *repM;

          //concrete class used to isolate data from storing details
          MapcodeCadastre *cadM;
          
          //creates an object of the concrete class that implements the way to access data through file systems
          repM = new RepositoryMapcodeFile();
          repM->load(argv[2]);

          //instantiates an object of the concrete class MapcodeCadastre, which is used to isolate map data from storing details
          cadM = new MapcodeCadastre(*repM);

          //reads a file through the concrete class MapcodeCadastre
          Mapcode *map = cadM->load(argv[2]);
                 
          clock_t c1 = clock();
  
          

          clock_t c2 = clock();
            

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

          net->setData(data);
          net->setNumIterations( 2000 );
          
          net->setInitType(10); 
          //here the value 10, which doesn't correspond to any kind of existent initialization,
          //is set in order to not intialize the map, so that the data read from file is not modified
          
          
          net->setInitLearningRate( 0.5 );
          net->setInitNeighbor( 15 );
          net->setLearningType( BATCH );
          net->setLearnType( "Batch" );
          net->setMapcode(map);
  
          //instantiates the object mysom, of type SOM, which represents the SOM neural network
          SOM* mysom = new SOM(net,map);  
          

          cout << "\nNumber of neurons = " << mysom->getMapcode()->getMapSize();
          cout << "\nDimension of vectors = " <<  data->getDimension();
         
          /*
               Calls the SOM methods:
               - InitMapcode -> initializes the map;
               - Labeling -> labels the code vectors of the map;
          */


          mysom->InitMapcode(); 
          //the method used to initialize the map is called, but the map initialization isn't done once the kind of initialization set doesn't exist.
          //in this example, this method is called only to create the distance matrix.
          
          
          mysom->getLearningAlgorithm()->MakeBMU(data,map);
          //the method used to create the BMU matrix is usually called in the training method Learning()
          //because the training method is not called in this example it is needed to call the MakeBMU method directly
                

          mysom->Labeling(); 
       
          clock_t c3 = clock();
           
          //instantiates an object of the class for segmentation which implements the costa neto algorithm
          GraphSegmentation *cluster = new GraphSegmentation();

          //creates the vector to store the clusters generated by the segmentation
          TIntVector clusters = create_intvector(1, mysom->getMapcode()->getMapSize());


          //segments the net. It takes as parameters: the net to be segmented and the minimum number of neurons that each group must have.
          clusters = cluster->Segment( mysom, 3 );
          

          cout << "\n\n\nSegmented map: \n\n";
          printClusters(clusters,mysom->getMapcode()->getDimensions(0),mysom->getMapcode()->getDimensions(1));
          
          //CDbw index calculation
          CDbw *cdbw = new CDbw(mysom, clusters, cluster->getNumClusters());
          cout << "\nCDbw = " << cdbw->Index();


          //Davies Bouldin index calculation
          DaviesBouldin *db = new DaviesBouldin(mysom, clusters, cluster->getNumClusters());
          cout << "\nDavies Bouldin = " << db->Index(1,2) << "\n";


           /*
            The table relating each entry vector to its cluster may be too big depending on the amount of entry vectors, so the code to its creation and impression is commented in order to be used as the user needs it.
          */

          /* //begining of the code to create the table
          
          //method used to create the table relating each entry vector to its cluster
          std::map<string, int> tbl = makeTblEntry_Cluster(mysom,clusters,mysom->getMapcode()->getDimensions(0),mysom->getMapcode()->getDimensions(1));

          //vector that contains the labels of the entry vectors
          TvecLabel entryLabel = mysom->getData()->getId();

          cout << "\n\n\nTable relating each entry vector to its cluster...\n\n";
          for(int i = 0; i < entryLabel.size(); i++)
          cout << "Entry = " << i+1 << "\tCluster = " << tbl[ entryLabel[i] ] << "\n";

          //end of the code to create the table */  

      delete cdbw;
      delete data;
      delete mysom;

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



//implementation of the method used to create the table relating each entry vector to its cluster
std::map<string, int>  makeTblEntry_Cluster(SOM* som,int* clusters,int dimL,int dimC){          
          TLabel label = som->getMapcode()->getLabel();
          
          std::map<string, int> tbl;
          
          for(int i = 0; i < dimL*dimC; i++){
            for(int j = 0; j < label[i].size(); j++){
              string value = inttostr( clusters[i+1] );
              string id = label[i][j];
              tbl[ label[i][j] ] = clusters[i+1];
            }
          }  

          return tbl;
}

---