diff --git a/classificatore_singolo b/classificatore_singolo index 43dd1e0..2cb26d7 100755 Binary files a/classificatore_singolo and b/classificatore_singolo differ diff --git a/classificatore_singolo.c b/classificatore_singolo.c index 333ea7a..46f2d36 100644 --- a/classificatore_singolo.c +++ b/classificatore_singolo.c @@ -5,25 +5,30 @@ #define CATEGORIA 7 #define NUM_LAYERS 4 #define PERCETTRONI_LAYER_0 32 -#define MAX_EPOCHE 100 +#define MAX_EPOCHE 10 -//1 relu, 2 sigmoide +// 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 debug(int); void main() { + srand(time(NULL)); time_t tempo_epoche[MAX_EPOCHE]; - srand(time(NULL)); + /* + ################# 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); @@ -31,7 +36,7 @@ void main() ReteNeurale *puntatore_rete = caricaReteNeurale(file_pesi); if (puntatore_rete == NULL) { - rete_neurale = inizializza_rete_neurale(NUM_LAYERS, PERCETTRONI_LAYER_0, N_INPUTS); + rete_neurale = inizializza_rete_neurale_feed_forward(NUM_LAYERS, PERCETTRONI_LAYER_0, N_INPUTS); } else { @@ -40,31 +45,75 @@ void main() printf("Caricate impostazioni rete neurale da file\n"); } - //rete_neurale = inizializza_rete_neurale(NUM_LAYERS, PERCETTRONI_LAYER_0, N_INPUTS); - int corrette = 0; + // rete_neurale = inizializza_rete_neurale(NUM_LAYERS, PERCETTRONI_LAYER_0, N_INPUTS); printf("Numero elementi nel dataset: %d\n", set.size); - // ADDESTRAMENTO + /* + ################# Addestramento ################################ + */ + + int corrette = 0; + for (int i = 0; i < MAX_EPOCHE; i++) { + /* + ################# inizializzazione variabili per l'epoca in corso ################################ + */ + 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 -1; indice_set++) + + /* for (int xxx = 0; xxx < rete_neurale.size; xxx++) + { + for (int count = 0; count < rete_neurale.layers[xxx].size; count++) + { + for (int count_2 = 0; count_2 < rete_neurale.layers[xxx].percettroni[count].size; count_2++) + { + printf("[%d][%d]: %f\t", count, count_2, rete_neurale.layers[xxx].percettroni[count].pesi[count_2]); + } + printf("\n"); + } + } */ + + for (int indice_set = 0; indice_set < set.size; indice_set++) { - //printf("Qui ci arrivo %d\n", indice_set); - double **funzioni_attivazione = elabora_funzioni_attivazione(rete_neurale, set.istanze[indice_set], TIPO_FUNZIONE); + + /* + ################# Feed Forward ################################ + */ + // Elabora le funzioni di attivazione in base al tipo scelto. Ritorna un vettore bidimensionale dove la prima dimensione rappresenta l'indice del layer, la seconda quella del percettrone nel layer - /* 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, funzioni_attivazione[k][j]); */ + double **funzioni_attivazione = elabora_funzioni_attivazione(&rete_neurale, set.istanze[indice_set], TIPO_FUNZIONE); + /* + ################# Previsione ################################ + */ + // Siccome il dataset da il numero della categoria a cui appartiene l'immagine, se la categoria è quella che cerco io output_corretto varrà 1 altrimenti 0 byte output_corretto = get_out_corretto(set.istanze[indice_set].classificazione); - double **gradienti = (double **)malloc(sizeof(double *) * NUM_LAYERS); + if (previsione(funzioni_attivazione[rete_neurale.size - 1][0]) == output_corretto) + corrette++; + + /* + ################# Funzione di perdita (errore) ################################ + */ + + // printf("funzione_attivazione_out: %f", funzioni_attivazione[rete_neurale.size - 1][0]); + + // 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; + + /* + ################# Retropropagazione ################################ + */ + /* 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++) @@ -72,40 +121,43 @@ void main() gradienti[indice_layer] = (double *)malloc(sizeof(double) * rete_neurale.layers[indice_layer].size); } - - - // Derivata funzione di perdita - // printf("output_corretto = %d, previsione: %f\n", output_corretto, funzioni_attivazione[NUM_LAYERS - 1][0]); - double gradiente_errore = (output_corretto - funzioni_attivazione[NUM_LAYERS - 1][0]); - - errore_totale += pow(gradiente_errore, 2) * 0.5; - - - // Derivata funzione attivazione double derivata_funzione_out = derivata_sigmoide(funzioni_attivazione[NUM_LAYERS - 1][0]); // if (derivata_funzione_out == 0.0) derivata_funzione_out = 1; // Gradiente del percettrone output - gradienti[NUM_LAYERS - 1][0] = gradiente_errore * derivata_funzione_out; + gradienti[NUM_LAYERS - 1][0] = errore * derivata_funzione_out; //Crasha nella discesa del gradiente all'immagine indice 16 quando metto troppi percettroni - discesa_gradiente(rete_neurale, funzioni_attivazione, gradienti, TIPO_FUNZIONE); - - + discesa_gradiente(rete_neurale, funzioni_attivazione, gradienti, TIPO_FUNZIONE); */ + + double **gradienti = discesa_gradiente(rete_neurale, funzioni_attivazione, errore, TIPO_FUNZIONE); + + /* + ################# Aggiornamento dei pesi ################################ + */ + + /* + + **** SISTEMARE LA CORREZIONE IN VISTA DELLE ULTIME MODIFICHE PERCHÈ NON CORREGGE E MI SETTA TUTTI I PESI A NAN ***** + + */ + - // 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++) + for (int indice_peso = 0; indice_peso < rete_neurale.layers[rete_neurale.size - 1].percettroni[0].size; indice_peso++) { // Determino gradiente del peso - double gradiente_peso = gradienti[NUM_LAYERS - 1][0] * funzioni_attivazione[NUM_LAYERS - 2][indice_peso]; - rete_neurale.layers[NUM_LAYERS - 1].percettroni[0].pesi[indice_peso] += gradiente_peso * LRE; + double gradiente_peso = gradienti[rete_neurale.size - 1][0] * funzioni_attivazione[rete_neurale.size - 2][indice_peso]; + rete_neurale.layers[rete_neurale.size - 1].percettroni[0].pesi[indice_peso] += gradiente_peso * LRE; } - rete_neurale.layers[NUM_LAYERS - 1].percettroni[0].bias += gradienti[NUM_LAYERS - 1][0] * LRE; + rete_neurale.layers[rete_neurale.size - 1].percettroni[0].bias += gradienti[rete_neurale.size - 1][0] * LRE; - // Applico la correzione dal penultimo layer andando indietro fino al secondo (il primo si fa diverso) + + + + /* // 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 @@ -121,35 +173,25 @@ void main() correggi_pesi_percettrone_byte(&rete_neurale.layers[0].percettroni[indice_percettrone], set.istanze[indice_set], gradienti[0][indice_percettrone], indice_percettrone); } } - } - - if (previsione(funzioni_attivazione[NUM_LAYERS - 1][0]) == output_corretto) - { - corrette++; - } + } */ } - errore_totale /= 10000; + errore_totale /= set.size; double percentuale = (corrette * 100) / set.size; - printf("Errore: %f, accuratezza: %.2f%\n", errore_totale, percentuale); - // printf("\tRisposte corrette: %d\n", corrette); + printf("Errore: %f, accuratezza: %.2f%, corrette: %d\n", errore_totale, percentuale, corrette); - /* if (i == MAX_EPOCHE - 1) + // For di debug + /* for (int count = 0; count < rete_neurale.size; count++) { - printf("\nUltima epoca (%d), stato della rete:\n", i); - double **risultato; - for (int j = 0; j < 4; j++) + for (int count_2 = 0; count_2 < rete_neurale.layers[count].size; count_2++) { - 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]); + printf("[%d][%d]: %f\t", count, count_2, gradienti[count][count_2]); } + printf("\n"); } */ } - salvaReteNeurale(file_pesi, &rete_neurale); + // salvaReteNeurale(file_pesi, &rete_neurale); } // Questa funzione ritorna 1 se la categoria è quella che voglio individuare, altrimenti 0 @@ -181,6 +223,7 @@ void stampa_layer_indirizzo(Layer *layer) } void stampa_tempo(time_t tempo_epoche[], int i) + { time(&tempo_epoche[i]); @@ -195,4 +238,23 @@ void stampa_tempo(time_t tempo_epoche[], int i) printf("Tempo dall'epoca precedente: %d:%d\n", minuti_epoca, secondi_epoca); printf("Tempo dall'inizio: %d:%d\n", minuti_totali, secondi_totali); } -} \ No newline at end of file +} + +void debug(int indice) +{ + printf("qui ci arrivo %d", indice); +} + +/* 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]); + } + } */ diff --git a/mnist/dataset_sette.bin b/mnist/dataset_sette.bin new file mode 100644 index 0000000..66927d6 Binary files /dev/null and b/mnist/dataset_sette.bin differ diff --git a/mnist/mnist_manager b/mnist/mnist_manager new file mode 100755 index 0000000..0020d2c Binary files /dev/null and b/mnist/mnist_manager differ diff --git a/mnist/mnist_manager.h b/mnist/mnist_manager.h index 0d9516e..b67fd0d 100644 --- a/mnist/mnist_manager.h +++ b/mnist/mnist_manager.h @@ -27,6 +27,7 @@ typedef unsigned char byte; // Singola istanza del dataset. typedef struct { + int size; byte classificazione; byte dati[N_INPUTS]; } Istanza; @@ -39,6 +40,8 @@ typedef struct } Dataset; Dataset *get_dataset(char *, char *); +void salva_dataset(const char*, Dataset*); +Dataset *carica_dataset(const char*); // Questo metodo legge il file in questione e restituisce un puntatore a Dataset se il file esiste, altrimenti NULL // Ritorna un puntatore perchè in questo caso posso gestire il ritorno NULL. @@ -64,14 +67,16 @@ Dataset *get_dataset(char *path_mnist, char *path_categoria) int numero_righe = 0; //Leggo male il file, cambiare in base alle dichiarazioni sopra - if(fread(istanze[numero_righe].dati, sizeof(byte), 16, file) == 16 && fread(&istanze[numero_righe].classificazione, sizeof(byte), 8, categorie) == 8) + if(fread(istanze[numero_righe].dati, sizeof(byte), 16, file) == 16 && fread(&istanze[numero_righe].classificazione, sizeof(byte), 8, categorie) == 8) { while (fread(istanze[numero_righe].dati, sizeof(byte), N_INPUTS, file) == N_INPUTS) { if(fread(&istanze[numero_righe].classificazione, sizeof(byte), 1, categorie) == 1) { numero_righe++; istanze = (Istanza *)realloc(istanze, sizeof(Istanza) * (numero_righe + 1)); + istanze[numero_righe].size = N_INPUTS; } } + } // Dataset set; (*set).size = numero_righe; @@ -81,19 +86,19 @@ Dataset *get_dataset(char *path_mnist, char *path_categoria) //Trasformo tutto in 0 e 1 - /* for(int indice_immagine = 0; indice_immagine < set->size; indice_immagine++) { + for(int indice_immagine = 0; indice_immagine < set->size; indice_immagine++) { for(int indice_byte = 0; indice_byte < N_INPUTS; indice_byte++) { if(set->istanze[indice_immagine].dati[indice_byte] >= 128) set->istanze[indice_immagine].dati[indice_byte] = 1; else set->istanze[indice_immagine].dati[indice_byte] = 0; } - } */ + } return set; } -/* void salva_dataset(const char *filename, Dataset *set) +void salva_dataset(const char *filename, Dataset *set) { FILE *file = fopen(filename, "wb"); if (!file) @@ -104,21 +109,76 @@ Dataset *get_dataset(char *path_mnist, char *path_categoria) for (int indice_istanze = 0; indice_istanze < set->size; indice_istanze++) { - fwrite(&set->istanze[indice_istanze].classificazione, sizeof(byte), 1, file); - fwrite(&set->istanze[indice_istanze].dati, sizeof(byte), N_INPUTS, file); + if(set->istanze[indice_istanze].classificazione == 7) { + fwrite(&set->istanze[indice_istanze].classificazione, sizeof(byte), 1, file); + fwrite(&set->istanze[indice_istanze].dati, sizeof(byte), N_INPUTS, file); + } } fclose(file); -} */ +} + +Dataset *carica_dataset(const char *filename) { + FILE *file = fopen(filename, "rb"); + if (!file) { + perror("Errore nell'apertura del file"); + exit(EXIT_FAILURE); + } + + // Creazione di un dataset vuoto + Dataset *set = (Dataset *)malloc(sizeof(Dataset)); + if (!set) { + perror("Errore nell'allocazione del dataset"); + fclose(file); + exit(EXIT_FAILURE); + } + set->size = 0; + set->istanze = NULL; + + // Variabile temporanea per leggere ogni istanza + Istanza temp; + + // Leggi il file fino alla fine + while (1) { + // Prova a leggere la classificazione + size_t letti_classificazione = fread(&temp.classificazione, sizeof(byte), 1, file); + // Prova a leggere i dati + size_t letti_dati = fread(&temp.dati, sizeof(byte), N_INPUTS, file); + + // Se non riesci a leggere un'intera istanza, esci dal ciclo + if (letti_classificazione != 1 || letti_dati != N_INPUTS) { + break; + } + + // Aumenta la dimensione del dataset + set->size++; + // Rialloca la memoria per le istanze + set->istanze = (Istanza *)realloc(set->istanze, set->size * sizeof(Istanza)); + if (!set->istanze) { + perror("Errore nella riallocazione della memoria"); + fclose(file); + free(set); + exit(EXIT_FAILURE); + } + + // Aggiungi l'istanza letta al dataset + set->istanze[set->size - 1] = temp; + } + + fclose(file); + return set; +} /* void main() { - Dataset *set = get_dataset("t10k-images.idx3-ubyte", "t10k-labels.idx1-ubyte"); + Dataset *set = get_dataset(file_immagini, file_label); if(set == NULL) { printf("Nullo esco\n"); return; } + salva_dataset("dataset_sette.bin", set); + for(int i = 0; i < set->size; i++) { printf("immagine %d - valore rappresentato: %d\n", i, set->istanze[i].classificazione); } diff --git a/percettroni.h b/percettroni.h index 450355f..36dec8e 100644 --- a/percettroni.h +++ b/percettroni.h @@ -40,15 +40,20 @@ typedef struct } ReteNeurale; double randomico(); +double *get_double_from_bytes(Istanza); Percettrone inzializza_percettrone(int); -ReteNeurale inizializza_rete_neurale(int, int, int); Layer inizializza_layer(int, int); +ReteNeurale inizializza_rete_neurale_deep_feed_forward(int, int, int); +ReteNeurale inizializza_rete_neurale_feed_forward(int, int, int); -double funzione_attivazione(Percettrone p, double*, int); -double **elabora_funzioni_attivazione(ReteNeurale, Istanza, int); -void discesa_gradiente(ReteNeurale, double **, double **, int); -double calcola_gradiente_disceso(ReteNeurale, int, int, double **); + +double funzione_attivazione_percettrone(Percettrone p, double*, int); +double **elabora_funzioni_attivazione(ReteNeurale*, Istanza, int); +double *elabora_funzioni_attivazione_layer(Layer, double*, int); +double **discesa_gradiente(ReteNeurale, double **, double, int); +double *calcola_gradiente_output(Layer layer, double*, double, int); +double calcola_gradiente_disceso(ReteNeurale, int, int, double **, double); void correggi_pesi_percettrone_double(Percettrone *, int, double **, double); void correggi_pesi_percettrone_byte(Percettrone *, Istanza, double, int); @@ -62,7 +67,7 @@ void salvaReteNeurale(const char *, ReteNeurale *); ReteNeurale *caricaReteNeurale(const char *); /* - ################# INIZIALIZZAZIONI ################################ + ################# INIZIALIZZAZIONI E METODI UTILI ################################ */ // Questa funzione genera un valore reale random compreso nell'intervallo [-1, 1] double randomico() @@ -101,14 +106,13 @@ Layer inizializza_layer(int n_percettroni, int n_pesi) return layer; } -ReteNeurale inizializza_rete_neurale(int numero_layers, int numero_percettroni_iniziali, int numero_input) -{ +ReteNeurale inizializza_rete_neurale_feed_forward(int numero_layers, int numero_percettroni_iniziali, int numero_input) { ReteNeurale r; r.layers = (Layer *)malloc(sizeof(Layer) * numero_layers); r.size = numero_layers; // Funzione esponenziale inversa layer 5 - /* for (int livello = 0; livello < numero_layers; livello++) + for (int livello = 0; livello < numero_layers; livello++) { double esponente = (double)livello / (double)numero_layers; double frazione = (double)1 / (double)numero_percettroni_iniziali; @@ -124,7 +128,16 @@ ReteNeurale inizializza_rete_neurale(int numero_layers, int numero_percettroni_i r.layers[livello] = inizializza_layer(numero_percettroni_livello, numero_input); else r.layers[livello] = inizializza_layer(numero_percettroni_livello, r.layers[livello - 1].size); - } */ + } + + return r; +} + +ReteNeurale inizializza_rete_neurale_deep_feed_forward(int numero_layers, int numero_percettroni_iniziali, int numero_input) +{ + ReteNeurale r; + r.layers = (Layer *)malloc(sizeof(Layer) * numero_layers); + r.size = numero_layers; for (int livello = 0; livello < numero_layers; livello++) { @@ -132,28 +145,35 @@ ReteNeurale inizializza_rete_neurale(int numero_layers, int numero_percettroni_i printf("Layer %d -> percettroni: %d\n", livello, numero_percettroni_iniziali); r.layers[livello] = inizializza_layer(numero_percettroni_iniziali, numero_input); } - else if(livello < numero_layers -1) { printf("Layer %d -> percettroni: %d\n", livello, numero_percettroni_iniziali*2); r.layers[livello] = inizializza_layer(numero_percettroni_iniziali * 2, r.layers[livello - 1].size); } - else { printf("Layer %d -> percettroni: %d\n", livello, 1); r.layers[livello] = inizializza_layer(1, r.layers[livello - 1].size); } - } + } return r; } +double *get_double_from_bytes(Istanza istanza) { + double *inputs = (double *)malloc(sizeof(double *) * istanza.size); + for(int i = 0; i < istanza.size; i++) { + inputs[i] = (double)istanza.dati[i]; + } + return inputs; +} /* - ################# PREVISIONI ################################ + ################# FUNZIONI ATTIVAZIONE ################################ */ +//******************* I PESI SONO TUTTI NAN ******************************** + //Tipo 1 = relu, tipo 2 = sigmoide -double funzione_attivazione(Percettrone p, double *valori, int tipo) +double funzione_attivazione_percettrone(Percettrone p, double *valori, int tipo) { double sommatoria = 0.0; for (int i = 0; i < p.size; i++) { @@ -162,7 +182,7 @@ double funzione_attivazione(Percettrone p, double *valori, int tipo) } sommatoria += p.bias; - //printf(" sommatoria %f -> %f\n",sommatoria, risultato); + //printf(" sommatoria %f\n",sommatoria); if(tipo == 1) return relu(sommatoria); @@ -178,14 +198,6 @@ double derivata_sigmoide(double valore) { return valore * (1.0 - valore); } -int previsione(double valore) -{ - if (valore >= soglia_sigmoide) - return 1; - else - return 0; -} - double relu(double valore) { if(valore > 0) return valore; @@ -200,14 +212,67 @@ double derivata_relu(double valore) { return 0; } -void discesa_gradiente(ReteNeurale rete, double **funzioni, double **gradienti, int tipo_derivata) + +//tipo_funzione 1: relu, 2:sigmoide +double **elabora_funzioni_attivazione(ReteNeurale *rete, Istanza istanza, int tipo_funzione) { + /* for(int xxx = 0; xxx < rete->size; xxx++) { + for (int count = 0; count < rete->layers[xxx].size; count++) + { + for (int count_2 = 0; count_2 < rete->layers[xxx].percettroni[count].size; count_2++) + { + printf("[%d][%d]: %f\t", count, count_2, rete->layers[xxx].percettroni[count].pesi[count_2]); + } + printf("\n"); + } + } */ + + //Inizializzo il vettore bidimensionale che dovrò ritornare + double **funzioni = (double **)malloc(sizeof(double *) * rete->size); + + //Il primo layer devo farlo a parte perchè prende gli input dal dataset e non dal layer precedente + funzioni[0] = elabora_funzioni_attivazione_layer(rete->layers[0], get_double_from_bytes(istanza), tipo_funzione); + + for(int indice_layer = 1; indice_layer < rete->size - 1; indice_layer ++) { + funzioni[indice_layer] = elabora_funzioni_attivazione_layer(rete->layers[indice_layer], funzioni[indice_layer-1], tipo_funzione); + } + + funzioni[rete->size-1] = elabora_funzioni_attivazione_layer(rete->layers[rete->size-1], funzioni[rete->size-2], 2); + + return funzioni; +} + +//DA NAN +double *elabora_funzioni_attivazione_layer(Layer layer, double *inputs, int tipo_funzione) { + + double *funzioni = (double *)malloc(sizeof(double) * layer.size); + + for(int indice_percettrone = 0; indice_percettrone < layer.size; indice_percettrone ++) { + funzioni[indice_percettrone] = funzione_attivazione_percettrone(layer.percettroni[indice_percettrone], inputs, tipo_funzione); + } + + return funzioni; +} + +/* + ################# RETROPROPAGAZIONE ################################ +*/ + +double **discesa_gradiente(ReteNeurale rete, double **funzioni, double errore, int tipo_derivata) { + + double **gradienti = (double**)malloc(sizeof(double*) * rete.size); + + //Determino il gradiente di output a parte perchè non prende gradienti discesi dal livello superiore + gradienti[rete.size-1] = calcola_gradiente_output(rete.layers[rete.size-1], funzioni[rete.size-1], errore, tipo_derivata); + + //Determino gli altri livelli for (int indice_layer = rete.size - 2; indice_layer >= 0; indice_layer--) { + gradienti[indice_layer] = (double*)malloc(sizeof(double) * rete.layers[indice_layer].size); + for (int indice_percettrone = 0; indice_percettrone < rete.layers[indice_layer].size; indice_percettrone++) { //In base al tipo di funzione scelto, avvio relu o sigmoidi - double derivata_attivazione; if(tipo_derivata == 1) @@ -215,15 +280,32 @@ void discesa_gradiente(ReteNeurale rete, double **funzioni, double **gradienti, else derivata_attivazione = derivata_sigmoide(funzioni[indice_layer][indice_percettrone]); - // Passo anche l'indice del percettrone perchè corrisponde all'indice del peso del livello sopra - double gradiente_disceso = calcola_gradiente_disceso(rete, indice_layer + 1, indice_percettrone, gradienti); - - gradienti[indice_layer][indice_percettrone] = gradiente_disceso * derivata_attivazione; + gradienti[indice_layer][indice_percettrone] = calcola_gradiente_disceso(rete, indice_layer + 1, indice_percettrone, gradienti, derivata_attivazione); } } + + return gradienti; } -double calcola_gradiente_disceso(ReteNeurale rete, int livello, int indice_peso, double **gradienti) + double *calcola_gradiente_output(Layer layer, double *funzioni, double errore, int tipo_derivata) { + + double *gradienti = (double*)malloc(sizeof(double) * layer.size); + + //Qui darò per scontato che ci sia un singolo percettrone in uscita, da aggiornare in caso di multipercettrone + + double derivata_funzione; + + if(tipo_derivata == 1) + derivata_funzione = derivata_relu(funzioni[0]); + else + derivata_funzione = derivata_sigmoide(funzioni[0]); + + gradienti[0] = errore * derivata_funzione; + + return gradienti; +} + +double calcola_gradiente_disceso(ReteNeurale rete, int livello, int indice_peso, double **gradienti, double derivata_attivazione) { // printf("Qui ci arrivo\n"); double sommatoria = 0.0; @@ -234,44 +316,42 @@ double calcola_gradiente_disceso(ReteNeurale rete, int livello, int indice_peso, sommatoria += (gradienti[livello][indice_peso] * rete.layers[livello].percettroni[indice_percettrone].pesi[indice_peso]); } - return sommatoria; -} - -//tipo_funzione 1: relu, 2:sigmoide -double **elabora_funzioni_attivazione(ReteNeurale rete, Istanza istanza, int tipo_funzione) -{ - - double **funzioni = (double **)malloc(sizeof(double *) * rete.size); - double *inputs = (double *)malloc(sizeof(double *) * N_INPUTS); - for(int i = 0; i < N_INPUTS; i++) { - inputs[i] = (double)istanza.dati[i]; - } - - funzioni[0] = (double *)malloc(sizeof(double) * rete.layers[0].size); - for(int indice_percettrone = 0; indice_percettrone < rete.layers[0].size; indice_percettrone ++) { - funzioni[0][indice_percettrone] = funzione_attivazione(rete.layers[0].percettroni[indice_percettrone], inputs, tipo_funzione); - } - - //Taglio fuori l'ultimo layer perchè in ogni caso sarà sigmoide - for(int indice_layer = 1; indice_layer < rete.size; indice_layer ++) { - funzioni[indice_layer] = (double *)malloc(sizeof(double) * rete.layers[indice_layer].size); - for(int indice_percettrone = 0; indice_percettrone < rete.layers[indice_layer].size; indice_percettrone ++) { - //Se è il livello output in ogni caso deve fare sigmoide - if(indice_layer == rete.size-1) - funzioni[indice_layer][indice_percettrone] = funzione_attivazione(rete.layers[indice_layer].percettroni[indice_percettrone], funzioni[indice_layer-1], 2); - else - funzioni[indice_layer][indice_percettrone] = funzione_attivazione(rete.layers[indice_layer].percettroni[indice_percettrone], funzioni[indice_layer-1], tipo_funzione); - } - } - - return funzioni; + return sommatoria * derivata_attivazione; } /* - ################# CORREZIONI ################################ + ################# PREVISIONE E CORREZIONI ################################ */ +void aggiorna_pesi(ReteNeurale *rete_neurale, double **gradienti, double **funzioni_attivazione, Istanza istanza) { + + // Applico la correzione dal penultimo layer andando indietro fino al secondo (il primo si fa diverso) + for (int indice_layer = rete_neurale->size - 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, funzioni_attivazione, 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); + } + } + } +} + +int previsione(double valore) +{ + if (valore >= soglia_sigmoide) + return 1; + else + return 0; +} void correggi_pesi_percettrone_double(Percettrone *p, int layer, double **input, double gradiente_percettrone) { @@ -304,9 +384,12 @@ void correggi_pesi_percettrone_byte(Percettrone *p, Istanza input, double gradie + /* ################# IMPORT EXPORT ################################ */ + + void salvaReteNeurale(const char *filename, ReteNeurale *rete) { FILE *file = fopen(filename, "wb"); @@ -402,7 +485,14 @@ ReteNeurale *caricaReteNeurale(const char *filename) - +/* funzioni[indice_layer] = (double *)malloc(sizeof(double) * rete.layers[indice_layer].size); + for(int indice_percettrone = 0; indice_percettrone < rete.layers[indice_layer].size; indice_percettrone ++) { + //Se è il livello output in ogni caso deve fare sigmoide + if(indice_layer == rete.size-1) + funzioni[indice_layer][indice_percettrone] = funzione_attivazione(rete.layers[indice_layer].percettroni[indice_percettrone], funzioni[indice_layer-1], 2); + else + funzioni[indice_layer][indice_percettrone] = funzione_attivazione(rete.layers[indice_layer].percettroni[indice_percettrone], funzioni[indice_layer-1], tipo_funzione); + } */ /* double sigmoide_byte(Percettrone, byte *, int); double sigmoide_double(Percettrone, double *, int); @@ -520,4 +610,27 @@ double sigmoide_double(Percettrone p, double *valori, int n_input) return risultato; } - */ \ No newline at end of file + */ + + +//void discesa_gradiente(ReteNeurale, double **, double **, int); +/* void discesa_gradiente(ReteNeurale rete, double **funzioni, double **gradienti, int tipo_derivata) +{ + for (int indice_layer = rete.size - 2; indice_layer >= 0; indice_layer--) + { + for (int indice_percettrone = 0; indice_percettrone < rete.layers[indice_layer].size; indice_percettrone++) + { + //In base al tipo di funzione scelto, avvio relu o sigmoidi + + double derivata_attivazione; + + if(tipo_derivata == 1) + derivata_attivazione = derivata_relu(funzioni[indice_layer][indice_percettrone]); + else + derivata_attivazione = derivata_sigmoide(funzioni[indice_layer][indice_percettrone]); + + // Passo anche l'indice del percettrone perchè corrisponde all'indice del peso del livello sopra + gradienti[indice_layer][indice_percettrone] = calcola_gradiente_disceso(rete, indice_layer + 1, indice_percettrone, gradienti, derivata_attivazione); + } + } +} */ \ No newline at end of file diff --git a/rete_pesi_deep_feed_forward_93-100.bin b/rete_pesi_deep_feed_forward_93-100.bin new file mode 100644 index 0000000..ceea67a Binary files /dev/null and b/rete_pesi_deep_feed_forward_93-100.bin differ diff --git a/rete_pesi_feed_forward_93-100.bin b/rete_pesi_feed_forward_93-100.bin new file mode 100644 index 0000000..a227734 Binary files /dev/null and b/rete_pesi_feed_forward_93-100.bin differ diff --git a/visualizzatore b/visualizzatore index 1e5dfca..c61efc8 100755 Binary files a/visualizzatore and b/visualizzatore differ diff --git a/visualizzatore.c b/visualizzatore.c index d501fd5..8d47efc 100644 --- a/visualizzatore.c +++ b/visualizzatore.c @@ -49,16 +49,16 @@ void main() free(set_appoggio); free(rete_appoggio); - //Trasformo tutto in 0 e 1 + //Trasformo tutto in 0 e 255 - /* for(int indice_immagine = 0; indice_immagine < set.size; indice_immagine++) { + for(int indice_immagine = 0; indice_immagine < set.size; indice_immagine++) { for(int indice_byte = 0; indice_byte < N_INPUTS; indice_byte++) { if(set.istanze[indice_immagine].dati[indice_byte] == 0) set.istanze[indice_immagine].dati[indice_byte] = 0; else set.istanze[indice_immagine].dati[indice_byte] = 255; } - } */ + } int indice_set = rand() % set.size;