diff --git a/classificatore_singolo b/classificatore_singolo index 3d44c6e..31ab327 100755 Binary files a/classificatore_singolo and b/classificatore_singolo differ diff --git a/classificatore_singolo.c b/classificatore_singolo.c index e64b157..1518e8e 100644 --- a/classificatore_singolo.c +++ b/classificatore_singolo.c @@ -1,14 +1,11 @@ #include #include "percettroni.h" -//#include "mnist/mnist_manager.h" -//#include "cifar_10/cifar10_manager.h" -#include "xor_manager.h" //Scelgo quale categoria voglio identificare. nel caso dello xor -1 #define CATEGORIA -1 -#define NUM_LAYERS 2 -#define PERCETTRONI_LAYER_0 2 -#define MAX_EPOCHE 10000 +#define NUM_LAYERS 3 +#define PERCETTRONI_LAYER_0 4 +#define MAX_EPOCHE 1000000 byte get_out_corretto(byte); void stampa_layer_indirizzo(Layer*); @@ -29,7 +26,7 @@ void main() { ReteNeurale rete_neurale; ReteNeurale *puntatore_rete = caricaReteNeurale(file_pesi); if(puntatore_rete == NULL) { - rete_neurale = init_rete_neurale(NUM_LAYERS, PERCETTRONI_LAYER_0, N_INPUTS); + rete_neurale = inizializza_rete_neurale(NUM_LAYERS, PERCETTRONI_LAYER_0, N_INPUTS); } else { rete_neurale = *puntatore_rete; free(puntatore_rete); @@ -62,10 +59,8 @@ void main() { 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) { @@ -90,9 +85,13 @@ void main() { */ - double gradiente_errore = (output_corretto - sigmoidi[NUM_LAYERS-1][0]); + //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 @@ -100,20 +99,38 @@ void main() { /* 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--) { + 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++) { - correggi_pesi_percettrone(); + 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); + //correggi_layer_interni(&rete_neurale, gradienti, sigmoidi); + //correggi_layer_input(&rete_neurale.layers[0], gradienti, sigmoidi, set.istanze[indice_set].dati, NUM_LAYERS); } else { @@ -126,9 +143,8 @@ void main() { } } - printf("Errore: %f\n", errore_totale); - - //printf("\tRisposte corrette: %d\n", corrette); + printf("Errore: %f\n", errore_totale / 4); + printf("\tRisposte corrette: %d\n", corrette); if(corrette == set.size) { break; diff --git a/percettroni.h b/percettroni.h index ff653d4..284394c 100644 --- a/percettroni.h +++ b/percettroni.h @@ -6,11 +6,14 @@ char *file_pesi = "rete_pesi.bin"; char *file_immagini = "mnist/t10k-images.idx3-ubyte"; char *file_label = "mnist/t10k-labels.idx1-ubyte"; +//#include "mnist/mnist_manager.h" +//#include "cifar_10/cifar10_manager.h" +#include "xor_manager.h" + // Siccome il char è un byte che rappresenta il valore tra 0 e 255. Per evitare confusioni definisco il tipo "byte" come in Java typedef unsigned char byte; - -double LRE = 0.2; +double LRE = 0.5; double soglia_sigmoide = 0.5; typedef struct { @@ -32,8 +35,7 @@ typedef struct { double randomico(); Percettrone inzializza_percettrone(int); -//ReteNeurale inizializza_rete_neurale(int); -ReteNeurale init_rete_neurale(int, int, int); +ReteNeurale inizializza_rete_neurale(int, int, int); Layer inizializza_layer(int, int); double sigmoide_byte(Percettrone, byte*, int); @@ -44,8 +46,10 @@ double *funzioni_attivazione_layer_double(Layer, double*); void correggi_layer_interni(ReteNeurale*, double**, double**); void correggi_layer_input(Layer*, double**, double**, byte*, int); -double calcola_gradiente_layer(ReteNeurale, int, int, double**); void discesa_gradiente(ReteNeurale, double**, double**); +double calcola_gradiente_disceso(ReteNeurale, int, int, double**); +void correggi_pesi_percettrone_double(Percettrone*, int, double**, double); +void correggi_pesi_percettrone_byte(Percettrone*, Istanza, double, int); int previsione(double); @@ -74,16 +78,7 @@ Percettrone inizializza_percettrone(int n_pesi) { return p; } -//Questa funzione inizializza una rete neurale. Diamo il numero di layer desiderato e restituisce un ReteNeurale -/* ReteNeurale inizializza_rete_neurale(int n_layers) { - ReteNeurale r; - r.layers = (Layer*)malloc(sizeof(Layer) * n_layers); - r.size = n_layers; - - return r; -} */ - -ReteNeurale init_rete_neurale(int numero_layers, int numero_percettroni_iniziali, int numero_input) { +ReteNeurale inizializza_rete_neurale(int numero_layers, int numero_percettroni_iniziali, int numero_input) { ReteNeurale r; r.layers = (Layer*)malloc(sizeof(Layer) * numero_layers); r.size = numero_layers; @@ -109,7 +104,6 @@ ReteNeurale init_rete_neurale(int numero_layers, int numero_percettroni_iniziali return r; } - //Questa funzione serve ad inizializzare il singolo layer con il numero di percettroni che vogliamo //Ogni percettrone a sua volta viene automaticamente inizializzato con il numero di pesi che vogliamo e coi valori di partenza Layer inizializza_layer(int n_percettroni, int n_pesi) { @@ -198,6 +192,10 @@ int previsione(double valore) { return 0; } + + + + //Questa funzione prende la matrice dei gradienti e la matrice delle sigmoidi per correggere tutti i layer tranne quello di ingresso void correggi_layer_interni(ReteNeurale *rete, double **gradienti, double **sigmoidi) { @@ -230,6 +228,10 @@ void correggi_layer_input(Layer *layer, double **gradienti, double **sigmoidi, b } + + + + void discesa_gradiente(ReteNeurale rete, double **sigmoidi, double **gradienti) { //For che scorre i layer dal penultimo al primo QUINI SIZE -2 for(int indice_layer = rete.size -2; indice_layer >= 0; indice_layer--) { @@ -240,10 +242,10 @@ void discesa_gradiente(ReteNeurale rete, double **sigmoidi, double **gradienti) for(int indice_percettrone = 0; indice_percettrone < rete.layers[indice_layer].size; indice_percettrone++) { double derivata_attivazione = sigmoidi[indice_layer][indice_percettrone] * (1 - sigmoidi[indice_layer][indice_percettrone]); - //Passo anche l'indice del percettrone perchè corrisponde all'indice del peso del livello sopra - double gradiente_disceso = calcola_gradiente_layer(rete, indice_layer + 1, indice_percettrone, gradienti); - + //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; } } @@ -261,6 +263,31 @@ double calcola_gradiente_disceso(ReteNeurale rete, int livello, int indice_peso, return sommatoria; } +void correggi_pesi_percettrone_double(Percettrone *p, int layer, double **input, double gradiente_percettrone) { + + for (int indice_peso = 0; indice_peso < p->size; indice_peso++) { + //Determino il gradiente del peso + double gradiente_peso = gradiente_percettrone * input[layer - 1][indice_peso]; + + //Modifico il peso + p->pesi[indice_peso] -= (gradiente_peso * LRE); + } + + p->bias -= (gradiente_percettrone * LRE); +} + +void correggi_pesi_percettrone_byte(Percettrone *p, Istanza input, double gradiente_percettrone, int indice_percettrone) { + for (int indice_peso = 0; indice_peso < p->size; indice_peso++) { + //Determino il gradiente del peso + double gradiente_peso = gradiente_percettrone * (double)input.dati[indice_peso]; + + //Modifico il peso Qui si impalla perchè per qualche ragione arriva size elevatissimo + p->pesi[indice_peso] -= (gradiente_peso * LRE); + } + + p->bias -= (gradiente_percettrone * LRE); +} + //Una volta finito il ciclo delle epoche viene salvato lo stato della rete neurale void salvaReteNeurale(const char *filename, ReteNeurale *rete) { diff --git a/tempCodeRunnerFile.c b/tempCodeRunnerFile.c deleted file mode 100644 index da3cc5d..0000000 --- a/tempCodeRunnerFile.c +++ /dev/null @@ -1,3 +0,0 @@ -for(int indice_percettrone = 0; indice_percettrone < PERCETTRONI_LAYER_0; indice_percettrone++) { - printf("percettrone %d -> sigmoide: %f\n", indice_percettrone, sigmoidi[0][indice_percettrone]); - } \ No newline at end of file