main_treinamento.cpp

/*

        O objetivo deste programa eh ler os dados de entrada, configurar os parametros da rede Som, treina-la, exibir a qualidade do treinamento e o tempo decorrido para treinamento, e salvar a rede.  


        Este programa tem como parametros:
                - o caminho do arquivo tipo txt (ex.: /data/IrisInputTrain.txt);
                - tipo de aprendizagem ('batch' ou 'online');
                - as duas dimensoes da rede Som (ex.: 10 15);
                - o numero de epocas (ex.: 1000).
                - o nome do arquivo de saida para salvar a rede.

        ./somcode <caminho para o arquivo> <tipo de aprendizagem> <dimensao um> <dimensao dois> <numero de iteracoes> <nome do arquivo de saida>

        Exemplo de chamada do programa: ./somcode ./data/IrisInputTrain.txt batch 10 15 1000 mapa10_15.txt
        
        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>
#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 "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");



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

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

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


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

        // Instanciacao do objeto map, do tipo Mapcode, que representa o mapa da rede.
          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);

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

          //Instanciacao do objeto mysom, do tipo SOM, que representa a rede neural SOM
          SOM* mysom = new SOM(*net);


          mysom->InitMapcode();         
          mysom->Learning();            
          mysom->Quality();
          mysom->Labeling(); 
        
          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;

                

          //salva o mapa da rede no arquivo com o nome passado no ultimo parametro
          RepositoryMapcodeFile repMapcode;
          repMapcode.save(mysom->getMapcode(),argv[6]);
           

                 
    
         delete data;
         delete mysom;

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

---