192 lines
8.2 KiB
C
192 lines
8.2 KiB
C
#include <time.h>
|
|
#include "percettroni.h"
|
|
|
|
//Scelgo quale categoria voglio identificare. nel caso dello xor -1
|
|
#define CATEGORIA -1
|
|
#define NUM_LAYERS 3
|
|
#define PERCETTRONI_LAYER_0 4
|
|
#define MAX_EPOCHE 1000000
|
|
|
|
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 = crea_dataset_xor();//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(NUM_LAYERS, PERCETTRONI_LAYER_0, N_INPUTS);
|
|
} else {
|
|
rete_neurale = *puntatore_rete;
|
|
free(puntatore_rete);
|
|
printf("Caricate impostazioni rete neurale da file\n");
|
|
}
|
|
|
|
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);
|
|
int corrette = 0;
|
|
double errore_totale = 0.0;
|
|
|
|
for(int indice_set = 0; indice_set < set.size; indice_set++) {
|
|
|
|
//sigmoidi è un array bidimensionale, la prima dimensione identifica il layer, la seconda il percettrone nel layer
|
|
// sigmoidi[indice_layer][indice_percettrone]
|
|
double **sigmoidi = (double **)malloc(sizeof(double*) * NUM_LAYERS);
|
|
|
|
//Il layer di ingresso ha bisogno di una funzione a parte perchè prende byte come input
|
|
sigmoidi[0] = (double*)malloc(sizeof(double) * PERCETTRONI_LAYER_0);
|
|
sigmoidi[0] = funzioni_attivazione_layer_byte(rete_neurale.layers[0], set.istanze[indice_set].dati);
|
|
|
|
//Calcolo le sigmoidi in tutti gli altri layer
|
|
for(int j = 1; j < NUM_LAYERS; j++) {
|
|
sigmoidi[j] = (double*)malloc(sizeof(double) * rete_neurale.layers[j].size);
|
|
sigmoidi[j] = funzioni_attivazione_layer_double(rete_neurale.layers[j], sigmoidi[j-1]);
|
|
}
|
|
|
|
byte output_corretto = get_out_corretto(set.istanze[indice_set].classificazione);
|
|
|
|
//Se prevede male
|
|
if(previsione(sigmoidi[NUM_LAYERS-1][0]) != output_corretto) {
|
|
|
|
//gradienti è un array bidimensionale, la prima dimensione identifica il layer, la seconda il percettrone nel layer
|
|
//gradienti[indice_layer][indice_percettrone]
|
|
//Questo vettore identifica i gradienti dei percettroni
|
|
double **gradienti = (double**)malloc(sizeof(double*) * NUM_LAYERS);
|
|
|
|
//Alloco la dimensione per ogni layer
|
|
for(int indice_layer = 0; indice_layer < NUM_LAYERS; indice_layer++) {
|
|
gradienti[indice_layer] = (double*)malloc(sizeof(double) * rete_neurale.layers[indice_layer].size);
|
|
}
|
|
|
|
/* Gestione dell'errore
|
|
Funzione di perdita -> errore quadratico medio: (risultato_esatto - previsione)^2
|
|
Gradiente dell'errore rispetto all'attivazione = derivata(funzione_perdita) * derivata(sigmoide_out)
|
|
= -(risultato_esatto - previsione) * (sigmoide_out * (1 - sigmoide_out))
|
|
|
|
//Per ogni percettrone sugli altri layer:
|
|
- calcolare derivata della propria sigmoide
|
|
- gradiente dell'errore retropropagato = peso del ne
|
|
|
|
*/
|
|
|
|
//Derivata funzione di perdita
|
|
double gradiente_errore = -(output_corretto - sigmoidi[NUM_LAYERS-1][0]);
|
|
//Derivata funzione attivazione
|
|
double derivata_sigmoide_out = sigmoidi[NUM_LAYERS-1][0] * (1 - sigmoidi[NUM_LAYERS-1][0]);
|
|
if (derivata_sigmoide_out == 0.0) derivata_sigmoide_out = 1;
|
|
|
|
//Gradiente del percettrone output
|
|
gradienti[NUM_LAYERS-1][0] = gradiente_errore * derivata_sigmoide_out;
|
|
|
|
//Ricorda di partire dal penultimo layer in quanto l'ultimo è già fatto
|
|
discesa_gradiente(rete_neurale, sigmoidi, gradienti);
|
|
|
|
/* A questo punto ho tutti i gradienti dei percettroni, non mi resta che trovare i gradienti dei pesi e correggerli
|
|
*/
|
|
|
|
//Correggo il livello output
|
|
for(int indice_peso = 0; indice_peso < rete_neurale.layers[NUM_LAYERS-1].percettroni[0].size; indice_peso ++) {
|
|
//Determino gradiente del peso
|
|
double gradiente_peso = gradienti[NUM_LAYERS-1][0] * sigmoidi[NUM_LAYERS-2][indice_peso];
|
|
rete_neurale.layers[NUM_LAYERS-1].percettroni[0].pesi[indice_peso] -= gradiente_peso * LRE;
|
|
}
|
|
rete_neurale.layers[NUM_LAYERS-1].percettroni[0].bias -= gradienti[NUM_LAYERS-1][0] * LRE;
|
|
|
|
|
|
|
|
//Applico la correzione dal penultimo layer andando indietro fino al secondo (il primo si fa diverso)
|
|
for(int indice_layer = NUM_LAYERS - 2; indice_layer >= 0; indice_layer--) {
|
|
//Applico la correzione a tutti i percettroni del layer dal primo a seguire
|
|
for(int indice_percettrone = 0; indice_percettrone < rete_neurale.layers[indice_layer].size; indice_percettrone++) {
|
|
//Devo prendere il gradiente del percettrone e moltiplicarlo con gli input associati ai pesi
|
|
if(indice_layer != 0) {
|
|
correggi_pesi_percettrone_double(&rete_neurale.layers[indice_layer].percettroni[indice_percettrone], indice_layer, sigmoidi, gradienti[indice_layer][indice_percettrone]);
|
|
} else {
|
|
correggi_pesi_percettrone_byte(&rete_neurale.layers[0].percettroni[indice_percettrone], set.istanze[indice_set], gradienti[0][indice_percettrone], indice_percettrone);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//gradienti[NUM_LAYERS-1][0] = (output_corretto - sigmoidi[NUM_LAYERS-1][0]);
|
|
errore_totale += gradienti[NUM_LAYERS-1][0];
|
|
|
|
//correggi_layer_interni(&rete_neurale, gradienti, sigmoidi);
|
|
//correggi_layer_input(&rete_neurale.layers[0], gradienti, sigmoidi, set.istanze[indice_set].dati, NUM_LAYERS);
|
|
}
|
|
else
|
|
{
|
|
corrette++;
|
|
}
|
|
|
|
if(corrette == 4) {
|
|
printf("\tConvergo all'epoca %d\n", i);
|
|
break;
|
|
}
|
|
}
|
|
|
|
printf("Errore: %f\n", errore_totale / 4);
|
|
printf("\tRisposte corrette: %d\n", corrette);
|
|
|
|
if(corrette == set.size) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
//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);
|
|
}
|
|
} |