120 lines
3.5 KiB
C
120 lines
3.5 KiB
C
#include <time.h>
|
|
#include "percettroni.h"
|
|
|
|
// Scelgo quale categoria voglio identificare. nel caso dello xor -1
|
|
#define CATEGORIA 7
|
|
#define NUM_LAYERS 7
|
|
#define PERCETTRONI_LAYER_0 128
|
|
#define MAX_EPOCHE 50
|
|
|
|
byte get_out_corretto(byte);
|
|
void stampa_layer_indirizzo(Layer *);
|
|
void stampa_tempo(time_t[], int);
|
|
|
|
void main()
|
|
{
|
|
time_t tempo_epoche[MAX_EPOCHE];
|
|
|
|
srand(time(NULL));
|
|
|
|
Dataset *set_appoggio = get_dataset(file_immagini, file_label); //get_dataset(file_immagini);
|
|
|
|
if (set_appoggio == NULL)
|
|
return;
|
|
Dataset set = *set_appoggio;
|
|
free(set_appoggio);
|
|
|
|
ReteNeurale rete_neurale;
|
|
ReteNeurale *puntatore_rete = caricaReteNeurale(file_pesi);
|
|
if (puntatore_rete == NULL)
|
|
{
|
|
rete_neurale = inizializza_rete_neurale(NUM_LAYERS, PERCETTRONI_LAYER_0, N_INPUTS);
|
|
}
|
|
else
|
|
{
|
|
rete_neurale = *puntatore_rete;
|
|
free(puntatore_rete);
|
|
printf("Caricate impostazioni rete neurale da file\n");
|
|
}
|
|
|
|
int corrette = 0;
|
|
|
|
printf("Numero elementi nel dataset: %d\n", set.size);
|
|
|
|
// ADDESTRAMENTO
|
|
for (int i = 0; i < MAX_EPOCHE; i++)
|
|
{
|
|
printf("Epoca %d\n", i);
|
|
stampa_tempo(tempo_epoche, i);
|
|
corrette = 0;
|
|
double errore_totale = 0.0;
|
|
|
|
for (int indice_set = 0; indice_set < set.size; indice_set++)
|
|
{
|
|
double **sigmoidi = elabora_sigmoidi(rete_neurale, set.istanze[indice_set]);
|
|
|
|
byte output_corretto = get_out_corretto(set.istanze[indice_set].classificazione);
|
|
if (previsione(sigmoidi[rete_neurale.size - 1][0]) == output_corretto)
|
|
corrette++;
|
|
|
|
// Derivata funzione di perdita
|
|
double gradiente_errore = (output_corretto - sigmoidi[rete_neurale.size - 1][0]);
|
|
errore_totale += pow(gradiente_errore, 2);
|
|
|
|
double **gradienti = elabora_gradienti(rete_neurale, gradiente_errore, sigmoidi);
|
|
|
|
aggiorna_pesi(&rete_neurale, sigmoidi, gradienti, set.istanze[indice_set]);
|
|
|
|
}
|
|
|
|
printf("Errore: %f, risposte corrette: %d%\n", errore_totale / set.size, (corrette * 100) / set.size);
|
|
}
|
|
|
|
salvaReteNeurale(file_pesi, &rete_neurale);
|
|
}
|
|
|
|
// Questa funzione ritorna 1 se la categoria è quella che voglio individuare, altrimenti 0
|
|
byte get_out_corretto(byte categoria)
|
|
{
|
|
if (CATEGORIA != -1)
|
|
{
|
|
if (categoria == CATEGORIA)
|
|
return 1;
|
|
else
|
|
return 0;
|
|
}
|
|
else
|
|
return categoria;
|
|
}
|
|
|
|
void stampa_layer_indirizzo(Layer *layer)
|
|
{
|
|
for (int i = 0; i < layer->size; i++)
|
|
{
|
|
printf("Percettrone %d ->", i);
|
|
for (int j = 0; j < layer->percettroni->size; j++)
|
|
{
|
|
printf("\t peso %d, valore: %f", j, layer->percettroni[i].pesi[j]);
|
|
layer->percettroni[i].pesi[j] += 1;
|
|
}
|
|
printf("\n");
|
|
}
|
|
}
|
|
|
|
void stampa_tempo(time_t tempo_epoche[], int i)
|
|
{
|
|
|
|
time(&tempo_epoche[i]);
|
|
if (i > 0)
|
|
{
|
|
double tempo_trascorso_epoca = difftime(tempo_epoche[i], tempo_epoche[i - 1]);
|
|
double tempo_trascorso_totale = difftime(tempo_epoche[i], tempo_epoche[0]);
|
|
int minuti_epoca = (int)tempo_trascorso_epoca / 60;
|
|
int secondi_epoca = (int)tempo_trascorso_epoca % 60;
|
|
int minuti_totali = (int)tempo_trascorso_totale / 60;
|
|
int secondi_totali = (int)tempo_trascorso_totale % 60;
|
|
printf("Tempo dall'epoca precedente: %d:%d\n", minuti_epoca, secondi_epoca);
|
|
printf("Tempo dall'inizio: %d:%d\n", minuti_totali, secondi_totali);
|
|
}
|
|
}
|