main_segmentacao.cpp

/*

        Este programa tem como objetivo, a partir de um mapa de uma rede salvo, segmentar a rede e imprimir os resultados.

        Este programa tem como entrada:
                - o caminho para o arquivo de dados;
                - o caminho para o arquivo do mapa da rede;

        Exemplo de chamada do programa: ./somcode ./data/IrinInputTrain.txt ./mapa10x15.txt

*/

#pragma warning(disable: 4786)

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

//inclusao das bibliotecas do somcode necessarias para a execucao do programa

#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;


//criacao dos objetos construtores do padrao abstract factory

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();

          //classe abstrata que serve como interface para os diferentes tipos de forma de acesso a dados para treinamento.      
          ISOMDataRepository *repD; 

          //classe concreta usada para isolar os dados dos detalhes de armazenamento 
          SOMDataCadastre *cadD;
        
        //atribuicao do parametro que contem o nome do arquivo a ser lido.
          std::vector<std::string> params;
          params.push_back(argv[1]);    
          
          //criacao do objeto da classe concreta que implementa o tipo de acesso a dados atraves de sistema de arquivos
          repD = new RepositorySOMDataFile();
          repD->load(params,0);

          //instanciacao do objeto da classe concreta SOMDataCadastre, que serve para isolar os dados dos detalhes de armazenamento
          cadD = new SOMDataCadastre(*repD);

        cout << "Iniciando o SOMCode-1.0 ...\n\n";
 
          //leitura do arquivo atraves da classe concreta SOMDataCadastre
          SOMData* data = cadD->load( std::vector<std::string>() );
            
           

          //classe abstrata que serve como interface para os diferentes tipos de forma de acesso a dados relativos ao Mapa de uma rede
          IMapcodeRepository *repM;

          //classe concreta usada para isolar os dados dos detalhes de armazenamento 
          MapcodeCadastre *cadM;
          
          //criacao do objeto da classe concreta que implementa o tipo de acesso a dados atraves de sistema de arquivos
          repM = new RepositoryMapcodeFile();
          repM->load(argv[2]);

          //instanciacao do objeto da classe concreta MapcodeCadastre, que serve para isolar os dados do Mapa dos detalhes de armazenamento
          cadM = new MapcodeCadastre(*repM);

          //leitura do arquivo atraves da classe concreta MapcodeCadastre
          Mapcode *map = cadM->load(argv[2]);
                 
          clock_t c1 = clock();
  
          

          clock_t c2 = clock();
            

            
          

          // Instanciacao do objeto net, do tipo NetParams, que representa a rede.
          NetParams* net = new NetParams();
           

          net->setData(data);
          net->setNumIterations( 2000 );
          
          net->setInitType(10);                         
          //eh atribuido o valor 10 que nao corresponde a um tipo de inicializacao existente
          //isso eh feito para que o mapa nao seja inicializado, de forma que os dados lidos 
          //do arquivo nao sejam modificados
          
          net->setInitLearningRate( 0.5 );
          net->setInitNeighbor( 15 );
          net->setLearningType( BATCH );
          net->setLearnType( "Batch" );
          net->setMapcode(map);
  
             
          //Instanciacao do objeto mysom, do tipo SOM, que representa a rede neural SOM
          SOM* mysom = new SOM(net,map);  
          

          cout << "\nNumero de neuronios = " << mysom->getMapcode()->getMapSize();
          cout << "\nDimensao dos vetores = " <<  data->getDimension();
         
          mysom->InitMapcode(); 
          //o metodo de inicializacao eh chamado, mas a inicializacao do mapa nao eh feita jah que o tipo de inicializacao nao existe 
          //nesse exemplo nesse metodo eh chamado apenas para a criacao da matriz de distancias.
          
          mysom->getLearningAlgorithm()->MakeBMU(data,map);
          //o metodo para criacao da matriz de BMUs por padrao eh chamado dentro do metodo de treinamento Learning()
          //como o metodo de treinamento da rede nao eh executado, eh necessario chamar diretamente o metodo MakeBMU
                

          mysom->Labeling(); 
       
          clock_t c3 = clock();
           
           
          //Instanciacao da classe para segmentacao usando o algoritmo costa neto
          GraphSegmentation *cluster = new GraphSegmentation();

          //criacao do vetor para armazenamento dos clusters da segmentacao
          TIntVector clusters = create_intvector(1, mysom->getMapcode()->getMapSize());


        //segmenta a rede. Tem como parametros a rede a ser segmentada e o numero minimo de neuronios que cada grupo deve ter
          clusters = cluster->Segment( mysom, 3 );
          

          cout << "\n\n\nMapa segmentado: \n\n";
          printClusters(clusters,mysom->getMapcode()->getDimensions(0),mysom->getMapcode()->getDimensions(1));
          

          //calculo do Indice CDbw
          CDbw *cdbw = new CDbw(mysom, clusters, cluster->getNumClusters());
          cout << "\nCDbw = " << cdbw->Index();


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

         

          /*
            A tabela relacionando cada vetor de entrada ao seu grupo pode ser muito grande a depender da quantidade de vetores de entrada, portanto o codigo para criacao e impressao dessa tabela fica comentado para uso de acordo com a necessidade do usuario.
          */


          /* //inicio do codigo para a criaca da tabela

          //metodo para criacao da tabela relacionando cada vetor de entrada ao seu grupo
          std::map<string, int> tbl = makeTblEntry_Cluster(mysom,clusters,mysom->getMapcode()->getDimensions(0),mysom->getMapcode()->getDimensions(1));

          //vetor com os rotulos dos vetores de entrada
          TvecLabel entryLabel = mysom->getData()->getId();

          cout << "\n\n\nTabela relacionando cada vetor de entrada ao seu grupo...\n\n";
          for(int i = 0; i < entryLabel.size(); i++)
          cout << "Entrada = " << i+1 << "\tGrupo = " << tbl[ entryLabel[i] ] << "\n";

          //Fim do codigo para criacao da tabela */

      delete cdbw;
      delete data;
      delete mysom;

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



//implementacao do metodo usado para criar a tabela relacionando cada entrada ao seu grupo
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;
}

---