applicata regola nuova, continua a non andare bene nemmeno con lo xor

classificatore_singolo.c

@@ -1,14 +1,11 @@
 #include <time.h>
 #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 NUM_LAYERS 3
-#define PERCETTRONI_LAYER_0 2
+#define PERCETTRONI_LAYER_0 4
-#define MAX_EPOCHE 10000
+#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++) {
+                    for(int indice_percettrone = 0; indice_percettrone < rete_neurale.layers[indice_layer].size; indice_percettrone++) {
-                        correggi_pesi_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_interni(&rete_neurale, gradienti, sigmoidi);
-                correggi_layer_input(&rete_neurale.layers[0], gradienti, sigmoidi, set.istanze[indice_set].dati, NUM_LAYERS);
+                //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("Errore: %f\n", errore_totale / 4);
-        
+            printf("\tRisposte corrette: %d\n", corrette);
-        //printf("\tRisposte corrette: %d\n", corrette);
 
         if(corrette == set.size) {
             break;

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.5;
-double LRE = 0.2;
 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 inizializza_rete_neurale(int, int, int);
-ReteNeurale init_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 numero_layers, int numero_percettroni_iniziali, int numero_input) {
-/* 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 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) {

tempCodeRunnerFile.c

@@ -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]);
-            }