/*** Função que confere um procedimento ***/
int procedimento() {
if(match(PROCEDURE)) {
if(ident()) {
if(parametros()) {
if(declaracao()) {
if(bloco()) {
return 1;
} else return 0;
} else return 0;
} else return 0;
} else return 0;
} else return 0;
}
int main(int ari,char **arc)//./a.out wlan0 -r 5-2 -s localhost -u usuario -c clave -b basedatos -i ip -m mac
{
int paquete=socket(AF_PACKET,SOCK_RAW,htons(ETH_P_ALL)),j;
char **miarg=(char **)malloc(4*sizeof(char));
if(paquete==-1)
{
puts("error al abrir el socket");
return 1;
}
else
{
cabr=NULL;
// memset(tuip,0x63,4);
// memset(tumac,0xcc,6);
for(j=0; j<4; j++)
miarg[j]=(char *)malloc(50*sizeof(char));
ipm=(unsigned char *)malloc(4*sizeof(unsigned char));
macm=(unsigned char *)malloc(6*sizeof(unsigned char));
memset(macpadre+0,0xff,6);
memcpy(miarg[0],"localhost",9);
memcpy(miarg[1],"root",4);
memcpy(miarg[2],"toor",4);
memcpy(miarg[3],"scaner",6);
parametros(ari,arc,miarg);
cabr=datosred(arc[1],paquete);
putdatos();
system("service mysql start");
conecta(miarg);
usebase(miarg[3]);
pthread_mutex_init(&mutex,NULL);
pthread_mutex_init(&mutex2,NULL);
pthread_create(&hres[0],NULL,resivearp,NULL);
pthread_join(hres[0],NULL);
}
return 0;
}
/*!
* \brief main
* Guia de Trabajos Practicos 3
* \param argc
* \param argv
* \return
*/
int main(int argc, char *argv[])
{
QApplication a( argc, argv );
QMainWindow main;
a.connect( &a, SIGNAL(lastWindowClosed()), &a, SLOT(quit()) );
main.showMaximized();
QMdiArea *mdiArea = new QMdiArea;
mdiArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
mdiArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
main.setCentralWidget(mdiArea);
GraficadorMdi *grafFuncion = new GraficadorMdi( mdiArea );
grafFuncion->setearTitulo( QString::fromUtf8( "Funcion" ) );
grafFuncion->setearTituloEjeX( QString::fromUtf8( "X" ) );
grafFuncion->setearTituloEjeY( QString::fromUtf8( "Y" ) );
mdiArea->addSubWindow( grafFuncion );
grafFuncion->show();
mdiArea->tileSubWindows();
GraficadorMdi *grafFitnes = new GraficadorMdi( mdiArea );
grafFitnes->setearTitulo( QString::fromUtf8( "Evolucion Mejor Fitness" ) );
grafFitnes->setearTituloEjeX( QString::fromUtf8( "Generacion" ) );
grafFitnes->setearTituloEjeY( QString::fromUtf8( "fitness" ) );
mdiArea->addSubWindow( grafFitnes );
grafFitnes->show();
mdiArea->tileSubWindows();
grafFitnes->setearParaSOM();
GraficadorMdi *grafPuntos = new GraficadorMdi( mdiArea );
grafPuntos->setearTitulo( QString::fromUtf8( "Puntos a evaluar" ) );
grafPuntos->setearTituloEjeX( QString::fromUtf8( "Posicion" ) );
grafPuntos->setearTituloEjeY( QString::fromUtf8( "Y" ) );
mdiArea->addSubWindow( grafPuntos );
grafPuntos->show();
mdiArea->tileSubWindows();
//grafPuntos->setearParaSOM();
// grafPuntos->setearEjesEnGrafico();
GraficadorMdi *grafPromedio = new GraficadorMdi( mdiArea );
grafPromedio->setearTitulo( QString::fromUtf8( "Fitness Promedio" ) );
grafPromedio->setearTituloEjeX( QString::fromUtf8( "Posicion" ) );
grafPromedio->setearTituloEjeY( QString::fromUtf8( "Y" ) );
mdiArea->addSubWindow( grafPromedio );
grafPromedio->show();
mdiArea->tileSubWindows();
grafPromedio->setearParaSOM();
// barra de progreso para mostrar el avance del tiempo
QDockWidget *dockBarra = new QDockWidget( QString::fromUtf8( "Evaluaciones" ) );
main.addDockWidget( Qt::BottomDockWidgetArea, dockBarra );
QProgressBar *PBTiempo = new QProgressBar( dockBarra );
dockBarra->setWidget( PBTiempo );
//Inicializo con una semilla aleatoria para la generacion de Aleatorios
qsrand( QTime::currentTime().msec() );
// Cargo los parametros del ejercicio
QSettings parametros( "parametros.cfg", QSettings::IniFormat );
// Inicializo la poblacion
Poblacion<GenomaX> pob;
int cant_total = parametros.value( "cantidad_elementos" ).toInt();
pob.setearTotal( cant_total );
pob.setearElitismo( parametros.value( "elitismo", false ).toBool() );
pob.setearBrechaGeneracional( parametros.value( "brecha_generacional" ).toDouble() );
pob.setearProbabilidadMutacion( parametros.value( "probabilidad_mutacion").toDouble() );
pob.setearModoSeleccionPadres( (Poblacion<GenomaX>::MetodoSeleccion)parametros.value( "metodo_seleccion" ).toInt() );
pob.setearPorcentajeCantidadDePadres( parametros.value( "cantidad_padres" ).toDouble() );
double max = parametros.value( "max" ).toDouble();
double min = parametros.value( "min" ).toDouble();
pob.setearMinMax( min, max );
for( int i=0; i<cant_total; i++ ) {
GenomaX temp;
double valor = valor_random( min, max );
temp.setX( valor );
temp.setMinMax( min, max );
pob.append( temp );
}
// Grafico la funcion
QVector<double> posy, posx;
for( double i=min; i<max; i+=0.05 ) {
posx.append( i );
posy.append( evaluar( i ) );
}
grafFuncion->agregarCurva( posx, posy, "funcion" );
a.processEvents();
/*GenomaX p1;
p1.setX( 128.0 );
p1.mostrarGenotipo();
p1.mutar( 9 );
p1.mostrarGenotipo();
p1.mutar( 1 );
p1.mostrarGenotipo();
p1.mutar( 2 );
p1.mostrarGenotipo();
p1.mutar( 15 );
p1.mostrarGenotipo();
p1.mutar( 10 );
p1.mostrarGenotipo();
p1.mutar( 11 );
p1.mostrarGenotipo();*/
double fitnes_necesario = parametros.value( "fitnes_necesario", 0.0 ).toDouble();
int iteracciones_maximas = parametros.value( "iteracciones_maximas", 1000 ).toInt();
int iteracciones = 0;
PBTiempo->setRange( 0, iteracciones_maximas );
pob.evaluarPoblacion();
a.processEvents();
QVector<double> histFitness;
QVector<int> histIteracion;
QVector<double> histPromFitnes;
histFitness.append( pob.mejorFitnes() );
histIteracion.append( 0 );
histPromFitnes.append( pob.mejorFitnes() );
double mejor_fitness = 0.0;
double pos_mejor_fitness = 0.0;
int generacion_mejor_fitness = -1;
while( pob.mejorFitnes() <= fitnes_necesario
&& iteracciones <= iteracciones_maximas ) {
pob.seleccionarPadres();
a.processEvents();
pob.generarHijos();
a.processEvents();
pob.evaluarPoblacion();
a.processEvents();
iteracciones++;
PBTiempo->setValue( iteracciones );
histFitness.append( pob.mejorFitnes() );
histIteracion.append( iteracciones );
grafFitnes->setearPuntos( histFitness, histIteracion );
a.processEvents();
QVector<double> x, y;
double sumatoria = 0.0;
for( int i=0; i<pob.size(); i++ ) {
y.append( i );
x.append( pob.at( i ).getX() );
sumatoria += (-1.0)*evaluar( pob.at( i ).getX() );
}
sumatoria /= pob.size();
histPromFitnes.append( sumatoria );
grafPuntos->agregarCurva( x, y, QString( "Gen%1" ).arg( iteracciones ) );
if( mejor_fitness <= pob.mejorFitnes() ) {
mejor_fitness = pob.mejorFitnes();
pos_mejor_fitness = pob.elementoMinimo().getX();
generacion_mejor_fitness = iteracciones;
}
grafPromedio->setearPuntos( histPromFitnes, histIteracion );
}
qDebug() << "Mejor Fitness: " << mejor_fitness;
qDebug() << "Posicion Minimo: " << pos_mejor_fitness;
qDebug() << "Minimo: " << evaluar( pos_mejor_fitness );
qDebug() << "Generacion: " << generacion_mejor_fitness;
return a.exec();
}
int main (int argc, char *argv[])
{
t_sistema *sis;
t_simulacao *sim;
sis = ( t_sistema * ) calloc( 1, sizeof ( t_sistema ) ) ;
sim = ( t_simulacao * ) calloc( 1, sizeof ( t_simulacao ) ) ;
double enei, enef, dene, x2d;
long int i, part, x, xv, eta, etav, salto, x2;
parametros( argc, argv );
// inicio da simulacao
// calculo dos dados iniciais
calcula_dados_sistema();
for (sim.pmc=0;sim.pmc<sim.PMC;sim.pmc++)
{
for (sim.imp=0;sim.imp<sis.N*sim.IMP;sim.imp++)
{
// sorteio da particula
part = (long int) floor( (double) sis.N*RAND )+1;
x = sis.p[part];
// sorteio da movimentacao da rede
do
{
salto = (long int) floor(SRAND);
} while ( !salto );
xv = (x + salto + sis.L )%sis.L;
if ( !sis.r[xv] ) // NÃO COLIDIU
{
// criterio de Metropolis
enei = energia_local(x);
sis.r[xv] = sis.r[x];
sis.r[x] = 0;
enef = energia_local(x);
dene = enef - enei;
if ( RAND > exp(-dene/sis.t) ) // Não passou por Metrópolis
{
sis.r[x] = sis.r[xv];
sis.r[xv] = 0;
} else // Passou por Metrópolis -- > Atualizacao dos valores
{
sis.p[part] = xv;
sis.d[part] += salto;
sis.energia += dene;
}
}
} // fim do laco de impressao
x2 = 0; // Deslocamento quadrático médio
for ( i=1;i<sis.N+1;i++)
{
x2 += sis.d[i]*sis.d[i];
}
x2d = (double) x2/sis.N;
fprintf(sim.arq_simulacao,"%ld %.6f %.6f \n", sim.pmc*sim.IMP, sis.energia, x2d);
if ( sim.PGRAVA && !( sim.pmc % (sim.PGRAVA+1) ) ) imprime_configuracao( sis.r, sis.L, sim.arq_simulacao); // ver impressao de arquivo
} // fim do laco da corrida
}
int main (int argc, char *argv[])
{
FILE *f_inicial=NULL, *f_simulacao=NULL, *f_relatorio=NULL;
double enei, enef, dene, x2d;
long int i, part, x, xv, eta, etav, salto, x2;
parametros( argc, argv );
f_simulacao = ( sim.arq_simulacao == NULL ) ? stdout : fopen(sim.arq_inicial, "w");
f_relatorio = ( sim.arq_relatorio == NULL ) ? stdout : fopen(sim.arq_relatorio, "w");
if ( sim.arq_inicial == NULL )
configuracao_aleatoria( );
else
if ( !le_configuracao_inicial(sis.r, sim.arq_inicial) )
{
printf("O arquivo com a configuracao inicial: %s, esta com algum problema!\n", sim.arq_inicial);
exit(0);
}
// inicio da simulacao
// calculo dos dados iniciais
calcula_dados_sistema();
//* printf("\n");
// inicio da corrida
for (sim.pmc=0;sim.pmc<sim.PMC;sim.pmc++)
{
//* printf("\n* %ld\n", sim.pmc); //
for (sim.imp=0;sim.imp<sis.N*sim.IMP;sim.imp++)
{
// sorteio da particula
part = (long int) floor( (double) sis.N*RAND )+1;
x = sis.p[part];
// sorteio da movimentacao da rede
do
{
salto = (long int) floor(SRAND);
} while ( !salto );
//*printf("%ld %ld %+ld ", sim.imp, part, salto ); // *
xv = (x + salto + sis.L )%sis.L;
if ( !sis.r[xv] ) // NÃO COLIDIU
{
// criterio de Metropolis
enei = energia_local(x);
sis.r[xv] = sis.r[x];
sis.r[x] = 0;
enef = energia_local(x);
dene = enef - enei;
//* printf("%+2.2f %+2.2f & ", enei, enef); //*
if ( RAND > exp(-dene/sis.t) ) // Não passou por Metrópolis
{
sis.r[x] = sis.r[xv];
sis.r[xv] = 0;
} else // Passou por Metrópolis -- > Atualizacao dos valores
{
sis.p[part] = xv;
sis.d[part] += salto;
sis.energia += dene;
}
} //* else printf(" ",dene); //*
//*imprime_configuracao(sis.r,sis.L,stdout); // ver impressao de arquivo // *
} // fim do laco de impressao
x2 = 0; // Deslocamento quadrático médio
for ( i=1;i<sis.N+1;i++)
{
x2 += sis.d[i]*sis.d[i];
}
x2d = (double) x2/sis.N;
fprintf(f_simulacao,"%ld %.6f %.6f \n", sim.pmc*sim.IMP, sis.energia, x2d);
if ( sim.PGRAVA && !( sim.pmc % (sim.PGRAVA+1) ) ) imprime_configuracao( sis.r, sis.L, f_simulacao); // ver impressao de arquivo
} // fim do laco da corrida
}
/*!
* \brief main
* Ejercicio 2 Guia de Trabajos Practicos 1
* \param argc
* \param argv
* \return
*/
int main(int argc, char *argv[])
{
QApplication a( argc, argv );
QMainWindow main;
a.connect( &a, SIGNAL(lastWindowClosed()), &a, SLOT(quit()) );
main.showMaximized();
QMdiArea *mdiArea = new QMdiArea;
mdiArea->setHorizontalScrollBarPolicy(Qt::ScrollBarAsNeeded);
mdiArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
main.setCentralWidget(mdiArea);
//Inicializo con una semilla aleatoria para la generacion de Aleatorios
qsrand( QTime::currentTime().msec() );
// Cargo los parametros del ejercicio
QSettings parametros( "parametros.cfg", QSettings::IniFormat );
// Archivo de entrada
QString archivo = QCoreApplication::applicationDirPath().append( QDir::separator() ).append( parametros.value( "archivo_entrada" ).toString() );
// Cargo los datos de los archivos que corresponda
matriz entradas( parametros.value( "cantidad_entradas" ).toInt() );
QVector<int> salidas;
qDebug() << endl << "--------------- /Datos del entrenamiento/ -----------------" << endl;
qWarning() << "Archivo de lectura de datos originales: "<< archivo;
if( ! leer_archivo_entrenamiento( archivo,
&entradas,
&salidas,
parametros.value( "cantidad_entradas" ).toInt() ) ) {
qDebug() << "No se pudo encontrar el archivo de entrenamiento! cancelando!";
abort();
}
// particionamos los datos
Particionador particiones;
particiones.setearCantidadDatos( entradas.size() );
particiones.setearCantidadDeParticiones( parametros.value( "cantidad_particiones" ).toInt() );
particiones.setearPorcentajeEntrenamiento( parametros.value( "porcentaje_entrenamiento" ).toDouble() );
particiones.setearPorcentajeValidacion( parametros.value("porcentaje_validacion").toDouble() );
particiones.setearK(parametros.value("k").toInt());
particiones.particionarDatos();
// Inicializo la red neuronal
QVector<int> neuronas_por_capas;
// Primer parametro es la cantidad de clases
neuronas_por_capas << parametros.value( "cant_clases" ).toInt();
neuronas_por_capas << stringAQVector( parametros.value( "codificacion_salida" ).toString() ).size();
// Inicilizo la red radial
RedNeuronalRadial red( neuronas_por_capas.at(0),
neuronas_por_capas.at(1),
parametros.value("cantidad_entradas").toInt(),
parametros.value( "cant_clases" ).toInt() );
red.setearTasaAprendizaje( parametros.value( "tasa_aprendizaje" ).toDouble() );
qDebug() << "Tasa de aprendizaje: " << parametros.value( "tasa_aprendizaje" ).toDouble();
red.setearCodificacion( stringAQVector( parametros.value( "codificacion_salida" ).toString() ) );
qDebug() << "Codificacion salida: " << red.mostrarCodificacionSalida();
int max_epocas = parametros.value( "epocas_maximas", 20 ).toInt();
qDebug() << "Epocas: " << max_epocas;
double tolerancia_error = parametros.value( "tolerancia_error" ).toDouble();
qDebug() << "Error de corte: " << ( tolerancia_error ) << "%";
qDebug() << endl << "---------------- /Comienza el entrenamiento/ ----------------";
int epoca = 0; /* Contador de epocas */
double porcentaje_error = 100.0; /* Mucho sino sale */
int cantidad_particiones_exitosas = 0;
GraficadorMdi *graf1 = new GraficadorMdi( mdiArea );
graf1->setearTitulo( QString::fromUtf8( "Porcentaje de error según particion ( entrenamiento )" ) );
graf1->setearTituloEjeX( QString::fromUtf8( "Epoca" ) );
graf1->setearTituloEjeY( QString::fromUtf8( "Porcentaje error" ) );
mdiArea->addSubWindow( graf1 );
mdiArea->tileSubWindows();
if( stringAQVector( parametros.value( "codificacion_salida" ).toString() ).size() <= 2 ) {
GraficadorMdi *graf2 = new GraficadorMdi( mdiArea );
mdiArea->addSubWindow( graf2 );
graf2->showMaximized();
graf2->setearTitulo( "Datos originales" );
graf2->setearEjesEnGrafico();
graf2->setearTituloEjeX( " X " );
graf2->setearTituloEjeY( " y " );
graf2->agregarPuntosClasificados( entradas, salidas, 0.5 );
mdiArea->tileSubWindows();
} else {
matriz entradas1, entradas2;
vector salidas1, salidas2;
for( int i=0; i < entradas.size(); i++ ) {
vector temp;
temp.append( entradas.at(i).at(0) );
temp.append( entradas.at(i).at(1) );
entradas1.append( temp );
vector temp2;
temp2.append( entradas.at(i).at(2) );
temp2.append( entradas.at(i).at(3) );
entradas2.append( temp2 );
salidas1.append( salidas.at( i ) );
salidas2.append( salidas.at( i ) );
}
GraficadorMdi *graf2 = new GraficadorMdi( mdiArea );
mdiArea->addSubWindow( graf2 );
graf2->showMaximized();
graf2->setearTitulo( "Datos originales" );
//graf2->setearEjesEnGrafico();
graf2->setearTituloEjeX( "Longitud" );
graf2->setearTituloEjeY( "Ancho" );
graf2->agregarPuntosClasificados( entradas1, salidas1, stringAQVector( parametros.value( "codificacion_salida" ).toString() ) );
GraficadorMdi *graf3 = new GraficadorMdi( mdiArea );
mdiArea->addSubWindow( graf3 );
graf3->showMaximized();
graf3->setearTitulo( "Datos originales" );
graf3->setearTituloEjeX( "Petalos" );
graf3->setearTituloEjeY( "Sepalos" );
graf3->agregarPuntosClasificados( entradas2, salidas2, stringAQVector( parametros.value( "codificacion_salida" ).toString() ) );
mdiArea->tileSubWindows();
}
QDockWidget *dockBarra1 = new QDockWidget( "Progreso de Particiones" );
main.addDockWidget( Qt::BottomDockWidgetArea, dockBarra1 );
QProgressBar *PBParticiones = new QProgressBar( dockBarra1 );
dockBarra1->setWidget( PBParticiones );
QDockWidget *dockBarra2 = new QDockWidget( "Progreso de Epocas" );
main.addDockWidget( Qt::BottomDockWidgetArea, dockBarra2 );
QProgressBar *PBEpocas = new QProgressBar( dockBarra2 );
dockBarra2->setWidget( PBEpocas );
QVector<double> errores_particiones;
PBParticiones->setRange( 0, particiones.cantidadDeParticiones() );
PBParticiones->setValue( 0 );
PBParticiones->setFormat( "Particion %v de %m - %p%" );
PBEpocas->setRange( 0, max_epocas );
PBEpocas->setFormat( "Epoca %v de %m - %p%" );
// Mido el tiempo
QElapsedTimer medidor_tiempo;
medidor_tiempo.start();
// Busco los centroides
red.setearDatosOriginales( entradas, &salidas );
red.buscarCentroides();
// Grafico la agrupacion que hizo
GraficadorMdi *graf = new GraficadorMdi( mdiArea );
mdiArea->addSubWindow( graf );
graf->setearTitulo( QString( "Agrupamientos según RB" ) );
graf->setearEjesEnGrafico();
graf->setearTituloEjeX( " X " );
graf->setearTituloEjeY( " Y " );
red.graficarClusters( graf );
mdiArea->tileSubWindows();
//return a.exec();
for( int p=0; p<particiones.cantidadDeParticiones(); p++ ) {
Particionador::particion part_local = particiones.getParticion( p );
qDebug() << endl << "Utilizando Particion: " << p ;
//pongo nuevamente en los valores iniciales las variables de corte para que entre en todas las particiones
epoca = 0;
porcentaje_error = 100.0;
red.inicializarPesos();
QVector<double> errores_epocas;
//std::cout << "Epoca: " << std::endl;
PBEpocas->setValue( 0 );
while ( epoca < max_epocas
&& porcentaje_error > tolerancia_error )
{
// Inicio la etapa de entrenamiento
for(int i = 0; i < part_local.entrenamiento.size(); i++ )
{
vector prueba = entradas.at( part_local.entrenamiento.at(i) );
int salida = salidas.at( part_local.entrenamiento.at( i ) );
red.entrenarCapaNeuronalComun( prueba, salida );
}
// Verifico el error
int errores = 0;
int correcto = 0;
for( int i = 0; i < part_local.validacion.size(); i++ ) {
int pos = part_local.validacion.at( i );
vector entrada_a_evaluar = entradas.at( pos );
int salida_red = red.probarPatron( entrada_a_evaluar ) ;
//double salida_mapeada = red.mapeadorSalidas( salida_red );
double salida_deseada = salidas.at( pos );
if( salida_red != salida_deseada ) {
errores++;
} else {
correcto++;
}
}
porcentaje_error = ( (double) errores * 100 ) / (double) part_local.validacion.size();
errores_epocas.push_back( porcentaje_error );
// Aumento el contador de epocas
epoca++;
PBEpocas->setValue( epoca );
QApplication::processEvents();
}
graf1->agregarCurva( errores_epocas, QString( "Particion %1" ).arg( p ) );
qDebug() << " Epoca de finalizacion: " << epoca+1 << " - Error de salida de entrenamiento: " << porcentaje_error << "%";
// Genero las estadisticas con los datos de prueba
porcentaje_error = 0.0;
int errores = 0;
int correcto = 0;
for( int i = 0; i < part_local.prueba.size(); i++ ) {
if( red.probarPatron( entradas.at( part_local.prueba.at( i ) ) ) != salidas.at( part_local.prueba.at( i ) ) ) {
errores++;
} else {
correcto++;
}
}
porcentaje_error = ( (double) errores * 100 ) / (double) part_local.prueba.size();
errores_particiones.push_back( porcentaje_error );
//Aumento el contador de las no exitosas
if (epoca < max_epocas)
{
cantidad_particiones_exitosas++;
}
//qDebug() << errores_epocas;
qDebug() <<"Terminada particion " << p << "- Error de prueba: " << errores_particiones.at( p ) << "%";
//Calculo el error promedio y la desviacion estandar para la particion
// double error_promedio = 0.0;
// double desviacion_estandar = 0.0;
// double error_aux = 0.0;
// for (int i = 0 ; i < errores_epocas.size() ; i++ ) { error_promedio += errores_epocas.at(i);}
// error_promedio /= errores_epocas.size();
// qDebug() <<"Error Promedio: " << error_promedio << "%";
// for (int i = 0 ; i < errores_epocas.size() ; i++ ) { error_aux += exp(errores_epocas.at(i) - error_promedio);}
// desviacion_estandar = sqrt( (1.0 / (errores_epocas.size() - 1.0) ) * error_aux );
// qDebug() <<"Desviacion Estandar: " << desviacion_estandar << "%";
errores_epocas.clear();
PBParticiones->setValue( PBParticiones->value() + 1 );
QVector<int> nueva_salida;
matriz nueva_entrada;
for( int i=0; i<part_local.prueba.size(); i++ ) {
nueva_salida.append( red.probarPatron( entradas.at( part_local.prueba.at( i ) ) ) );
nueva_entrada.append( entradas.at( part_local.prueba.at( i ) ) );
}
/*if( particiones.cantidadDeParticiones() <= 5 ) {
GraficadorMdi *graf = new GraficadorMdi( mdiArea );
mdiArea->addSubWindow( graf );
graf->show();
graf->setearTitulo( QString( "Datos de prueba evaluados con red neuronal - Particion %1" ).arg( p+1 ) );
graf->setearEjesEnGrafico();
graf->setearTituloEjeX( " X " );
graf->setearTituloEjeY( " y " );
graf->agregarPuntosClasificados( nueva_entrada, nueva_salida, stringAQVector( parametros.value( "codificacion_salida" ).toString() ) );
mdiArea->tileSubWindows();
}*/
QApplication::processEvents();
}
qint64 milisegundos = medidor_tiempo.elapsed();
//std::cout << std::endl;
// Calculo el promedio de todos los errores
double sumatoria = 0.0;
for( int i=0; i<errores_particiones.size(); i++ ) {
sumatoria+=errores_particiones.at(i);
}
qDebug() << endl << "--------------- /Resumen/ -----------------";
qDebug() << endl << "Error total: " << sumatoria/errores_particiones.size() << "%";
qDebug() << endl << "Cantidad de Particiones que convergen: " << cantidad_particiones_exitosas ;
qDebug() << endl << "Cantidad de Particiones sin converger: " << (particiones.cantidadDeParticiones() - cantidad_particiones_exitosas) ;
//Calculo el error promedio y la desviacion estandar para todo
double error_promedio = sumatoria/errores_particiones.size();
double desviacion_estandar = 0.0;
double error_aux = 0.0;
for (int i = 0 ; i < errores_particiones.size() ; i++ ) { error_aux += exp(errores_particiones.at(i) - error_promedio);}
desviacion_estandar = sqrt( (1.0 / (errores_particiones.size() - 1.0) ) * error_aux );
qDebug() <<"Desviacion Estandar: " << desviacion_estandar << "%";
qDebug() << "Tiempo medido: " << milisegundos << " ms";
if( particiones.cantidadDeParticiones() != 1 ) {
GraficadorMdi *graf3 = new GraficadorMdi( mdiArea );
mdiArea->addSubWindow( graf3 );
graf3->showMaximized();
graf3->setearTitulo( "Errores por particion( datos de prueba )" );
graf3->setearTituloEjeX( "Particion" );
graf3->setearTituloEjeY( "Error" );
graf3->agregarCurva( errores_particiones, "Errores" );
mdiArea->tileSubWindows();
}
QVector<int> nueva_salida;
for( int i=0; i<entradas.size(); i++ ) {
nueva_salida.append( red.probarPatron( entradas.at(i) ) );
}
matriz entradas1, entradas2;
vector salidas1, salidas2;
for( int i=0; i < entradas.size(); i++ ) {
vector temp;
temp.append( entradas.at(i).at(0) );
temp.append( entradas.at(i).at(1) );
entradas1.append( temp );
if( entradas.at(i).size() > 2 ) {
vector temp2;
temp2.append( entradas.at(i).at(2) );
temp2.append( entradas.at(i).at(3) );
entradas2.append( temp2 );
}
salidas1.append( nueva_salida.at( i ) );
salidas2.append( nueva_salida.at( i ) );
}
if( stringAQVector( parametros.value( "codificacion_salida" ).toString() ).size() == 2 ) {
GraficadorMdi *graf4 = new GraficadorMdi( mdiArea );
mdiArea->addSubWindow( graf4 );
graf4->showMaximized();
graf4->setearTitulo( "Datos evaluados con red neuronal" );
graf4->setearEjesEnGrafico();
graf4->setearTituloEjeX( " X " );
graf4->setearTituloEjeY( " y " );
graf4->agregarPuntosClasificados( entradas, nueva_salida, stringAQVector( parametros.value( "codificacion_salida" ).toString() ) );
//graf4->agregarPuntosClasificados( entradas, nueva_salida );
} else if( stringAQVector( parametros.value("codificacion_salida").toString() ).size() == 1 ) {
GraficadorMdi *graf4 = new GraficadorMdi( mdiArea );
mdiArea->addSubWindow( graf4 );
graf4->showMaximized();
graf4->setearTitulo( "Datos evaluados con red neuronal" );
graf4->setearEjesEnGrafico();
graf4->setearTituloEjeX( " X " );
graf4->setearTituloEjeY( " y " );
//graf4->agregarPuntosClasificados( entradas, nueva_salida, stringAQVector( parametros.value( "codificacion_salida" ).toString() ) );
graf4->agregarPuntosClasificados( entradas, nueva_salida );
} else {
GraficadorMdi *graf4 = new GraficadorMdi( mdiArea );
mdiArea->addSubWindow( graf4 );
graf4->showMaximized();
graf4->setearTitulo( "Datos evaluados con red neuronal" );
graf4->setearTituloEjeX( "Largo" );
graf4->setearTituloEjeY( "Ancho" );
graf4->agregarPuntosClasificados( entradas1, salidas1, stringAQVector( parametros.value( "codificacion_salida" ).toString() ) );
GraficadorMdi *graf5 = new GraficadorMdi( mdiArea );
mdiArea->addSubWindow( graf5 );
graf5->showMaximized();
graf5->setearTitulo( "Datos evaluados con red neuronal" );
graf5->setearTituloEjeX( "Petalos" );
graf5->setearTituloEjeY( "Sepalos" );
graf5->agregarPuntosClasificados( entradas2, salidas2, stringAQVector( parametros.value( "codificacion_salida" ).toString() ) );
}
mdiArea->tileSubWindows();
return a.exec();
}
