150 lines
4.9 KiB
C
150 lines
4.9 KiB
C
#include <time.h>
|
|
#include "percettroni.h"
|
|
|
|
// Scelgo quale categoria voglio identificare. nel caso dello xor -1
|
|
#define CATEGORIA 7
|
|
#define NUM_LAYERS 2
|
|
#define PERCETTRONI_LAYER_0 2
|
|
#define MAX_EPOCHE 1
|
|
|
|
// 1 relu, 2 sigmoide
|
|
#define TIPO_FUNZIONE 2
|
|
|
|
byte get_out_corretto(byte);
|
|
void stampa_layer_indirizzo(Layer *);
|
|
void stampa_tempo(time_t[], int);
|
|
|
|
void main()
|
|
{
|
|
srand(time(NULL));
|
|
time_t tempo_epoche[MAX_EPOCHE];
|
|
|
|
/*
|
|
################# Inizializzazione rete e caricamento Dataset ################################
|
|
*/
|
|
|
|
Dataset *set_appoggio = get_dataset(file_immagini, file_label);
|
|
|
|
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_feed_forward(NUM_LAYERS, PERCETTRONI_LAYER_0, N_INPUTS);
|
|
}
|
|
else
|
|
{
|
|
rete_neurale = *puntatore_rete;
|
|
free(puntatore_rete);
|
|
printf("Caricate impostazioni rete neurale da file\n");
|
|
}
|
|
|
|
// rete_neurale = inizializza_rete_neurale(NUM_LAYERS, PERCETTRONI_LAYER_0, N_INPUTS);
|
|
|
|
printf("Numero elementi nel dataset: %d\n", set.size);
|
|
|
|
/*
|
|
################# Addestramento ################################
|
|
*/
|
|
int corrette = 0;
|
|
|
|
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 < 1/* set.size */; indice_set++)
|
|
{
|
|
double **funzioni_attivazione = elabora_funzioni_attivazione(rete_neurale, set.istanze[indice_set], TIPO_FUNZIONE);
|
|
|
|
byte output_corretto = get_out_corretto(set.istanze[indice_set].classificazione);
|
|
if (previsione(funzioni_attivazione[rete_neurale.size - 1][0]) == output_corretto)
|
|
corrette++;
|
|
|
|
// Derivata funzione di perdita
|
|
double errore = (output_corretto - funzioni_attivazione[rete_neurale.size - 1][0]);
|
|
|
|
// Sommo la funzione di perdita a errore_totale per stampare alla fine dell'epoca l'errore medio
|
|
errore_totale += pow(errore, 2) * 0.5;
|
|
|
|
double **gradienti = discesa_gradiente(rete_neurale, funzioni_attivazione, errore, TIPO_FUNZIONE);
|
|
aggiorna_pesi(rete_neurale, gradienti, funzioni_attivazione, set.istanze[indice_set]);
|
|
|
|
//debug_matrice(&rete_neurale, funzioni_attivazione);
|
|
}
|
|
|
|
errore_totale /= set.size;
|
|
double percentuale = (corrette * 100) / set.size;
|
|
printf("Errore: %f, accuratezza: %.2f%, corrette: %d\n", errore_totale, percentuale, corrette);
|
|
}
|
|
|
|
// 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);
|
|
}
|
|
}
|
|
|
|
/* if (i == MAX_EPOCHE - 1)
|
|
{
|
|
printf("\nUltima epoca (%d), stato della rete:\n", i);
|
|
double **risultato;
|
|
for (int j = 0; j < 4; j++)
|
|
{
|
|
risultato = elabora_funzioni_attivazione(rete_neurale, set.istanze[j]);
|
|
printf("Input: [%d,%d] -> probabilità: %f -> previsione: %d -> risultato attesto: %d\n", set.istanze[j].dati[0], set.istanze[j].dati[1], risultato[NUM_LAYERS - 1][0], previsione(risultato[NUM_LAYERS - 1][0]), set.istanze[j].classificazione);
|
|
for (int k = 0; k < rete_neurale.size; k++)
|
|
for (int j = 0; j < rete_neurale.layers[k].size; j++)
|
|
printf("sigmoide[%d][%d] = %f\n", k, j, risultato[k][j]);
|
|
}
|
|
} */
|