main_caixeiro_viajante.cpp

/*
    Este exemplo encontra uma solucao para o problema do caixeiro viajante usando uma rede SOM unidimensional.

        Este programa tem como parametros:
                - o caminho para o arquivo de dados;
                - o raio da vizinhanca (dado como porcentagem);
                - o numero de iteracoes;
        
        ./somcode <caminho para o arquivo> <raio da vizinhanca> <numero de iteracoes> <tipo de aprendizado>

        Exemplo de chamada do programa: ./somcode ./data/cities.txt 10 1000 batch

        Este e somente um exemplo. Os valores dos parametros devem ser ajustados para cada situacao.
        
*/

#pragma warning(disable: 4786)

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

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

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

#include "BatchFactory.h"
#include <string>


#include <iomanip.h>
#include <fstream.h>
#include <stdio.h>

#include "RepositorySOMDataFile.h"

#include "OneDTFactory.h"
#include "OneDT.h"

#include "Data.h"  
#include "util.h"
#include "defs.h"


using std::cout;

//criacao dos objetos construtores do padrao abstract factory


static BatchFactory fact_batch("Batch");
static OneDTFactory fact_twoD("Two");


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

  try {         
          clock_t c0 = clock();
  

          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
          RepositorySOMDataFile repD;
          repD.load(params,0);

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

          
          OneDT* tsp;


          cout << "Iniciando SOMCode-1.0 ...\n";

          //leitura do arquivo atraves da classe concreta SOMDataCadastre
          SOMData* data = cadD.load( std::vector<std::string>() );

          clock_t c1 = clock();

          clock_t c2 = clock();

          SOM* mysom = new SOM();
          mysom->setData(data);


          int dimL, dimC, neig, iter; 
         
          dimL = data->getDataSize();   // rede neural com numero de neuronios igual ao numero
                                        // de cidades de entrada
          dimC = 1;                     // por possuir apenas uma dimensao
          neig = strtoint(argv[2]);
          iter = strtoint(argv[3]);

          mysom->getMapcode()->setNumVar( mysom->getData()->getDimension() );
          mysom->getMapcode()->setDimensions( 0, dimL );
          mysom->getMapcode()->setDimensions( 1, dimC );

          // tipo de vizinhanca para o problema do caixeiro viajante
          mysom->getMapcode()->setLattice( "toro" );   
          mysom->getMapcode()->setNeighborType( "bubble" );
          mysom->getMapcode()->CreateCodebook( dimL*dimC, mysom->getData()->getDimension() );   

          // nesse problema isto deve ser igual a (numero_de_cidades / 4)
          mysom->setInitNeighbor( dimL*(neig*0.01) );  

          // iniciacao colocando os nos em um quadro ao redor das cidades
          mysom->setInitType( WINDOW );  

          mysom->setNumIterations( iter );

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

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

          /*
             Metodos do SOM.
          */

         mysom->InitMapcode();  

         string SOM       = "Som" ;
         string PATH      = "Path" ;
         string INIT_ARRG = "InitialArrangement" ;
         string txt       = ".txt" ;
        
         // nome dos arquivos gerados (arranjo inicial, coordenadas finais dos neuronios e caminha gerado)
         // seguindo o padrao:
         // <arquivo gerado> N <numero de neuronios> P <porcentagem da vizinhanca> I <numero de iteracoes>

         string nick1 = INIT_ARRG + 'N' + inttostr(dimL) + 'P' + argv[2] + 'I' + argv[3] + txt ;

         tsp = new OneDT(mysom->getMapcode()->getTopolParams());

         // Gera o arquivo com o arranjo inicial dos neuronios (antes do treinamento)
         cout << "\nArquivo contendo o arranjo inicial : \n\t" ;
         tsp->Save(mysom->getMapcode()->getCodebook() , nick1 , dimL); 
         cout << "\n" ;

         mysom->Learning();             
         mysom->Quality();

          
          clock_t c3 = clock();
          cout << "Erro de quantizacao = " << mysom->getQuantizationError() << std::endl;
          cout << "Erro topologico = " << mysom->getTopologicalError() << std::endl;
          cout << "Tempo decorrido para carregar os dados = " << (float) (c1 - c0)/CLOCKS_PER_SEC << std::endl;
          cout << "Tempo decorrido para processar os dados = " << (float) (c3 - c2)/CLOCKS_PER_SEC << std::endl;


          mysom->Labeling();

          TLabel label = mysom->getMapcode()->getLabel();

        // impressao das coordenadas das cidades. 
        // descomentar se necessario
        /*
          int tsp_count = 1 ;
          for (int i = 0; i < label.size() ; i++) {
             cout << i+1 << ": " ;
             for (int j = 0; j < label[i].size(); j++){
                cout << mysom->getCities()[strtoint(rem_id(label[i][j]))][1] ;
                cout << "," << mysom->getCities()[strtoint(rem_id(label[i][j]))][2] << " " ;
                tsp_count++ ;
                }
             cout << "\n";
          }
         */
        
         string nick2, nick3 ;
         
         // nome dos arquivos gerados (arranjo inicial, coordenadas finais dos neuronios e caminha gerado)
         // seguindo o padrao:
         // <arquivo gerado> N <numero de neuronios> P <porcentagem da vizinhanca> I <numero de iteracoes>
         
         nick2 = PATH + 'N' + inttostr(dimL) + 'P' + argv[2] + 'I' + argv[3] + txt ;
         nick3 = SOM + 'N' + inttostr(dimL) + 'P' + argv[2] + 'I' + argv[3] + txt ;


         TMatrix path = tsp->Extract_Path(mysom->getMapcode()->getLabel() , mysom->getCities() , dimL) ;

         cout << "\nArquivo contendo o caminho gerado : \n\t" ;
         tsp->Save(path , nick2 , dimL);
         cout << "\nArquivo contendo as coordenadas dos neuronios : \n\t" ;
         tsp->Save(mysom->getMapcode()->getCodebook() , nick3 , dimL);


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

---