ottimizzato il codice, messo relu(ma non attivato), pronto per prossima sessione di test

percettroni.h

@@ -3,8 +3,12 @@
 #include <math.h>
 
 char *file_pesi = "rete_pesi.bin";
-char *file_immagini = "mnist/t10k-images.idx3-ubyte";
-char *file_label = "mnist/t10k-labels.idx1-ubyte";
+char *file_immagini = "mnist/train-images.idx3-ubyte";
+char *file_label = "mnist/train-labels.idx1-ubyte";
+
+//Test dataset
+/* 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"
@@ -13,7 +17,7 @@ char *file_label = "mnist/t10k-labels.idx1-ubyte";
 // 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 = 2;
+double LRE = 1.414;
 double soglia_sigmoide = 0.5;
 
 typedef struct
@@ -41,14 +45,18 @@ Percettrone inzializza_percettrone(int);
 ReteNeurale inizializza_rete_neurale(int, int, int);
 Layer inizializza_layer(int, int);
 
-double sigmoide(Percettrone p, double*);
-double **elabora_sigmoidi(ReteNeurale, Istanza);
-void discesa_gradiente(ReteNeurale, double **, double **);
+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 **);
 void correggi_pesi_percettrone_double(Percettrone *, int, double **, double);
 void correggi_pesi_percettrone_byte(Percettrone *, Istanza, double, int);
 
 int previsione(double);
+double sigmoide(double);
+double derivata_sigmoide(double);
+double relu(double);
+double derivata_relu(double);
 
 void salvaReteNeurale(const char *, ReteNeurale *);
 ReteNeurale *caricaReteNeurale(const char *);
@@ -126,8 +134,8 @@ ReteNeurale inizializza_rete_neurale(int numero_layers, int numero_percettroni_i
     ################# PREVISIONI ################################
 */
 
-
-double sigmoide(Percettrone p, double *valori)
+//Tipo 1 = relu, tipo 2 = sigmoide
+double funzione_attivazione(Percettrone p, double *valori, int tipo)
 {
     double sommatoria = 0.0;
     for (int i = 0; i < p.size; i++) {
@@ -136,10 +144,20 @@ double sigmoide(Percettrone p, double *valori)
     }
 
     sommatoria += p.bias;
-    double risultato = 1.0 / (1.0 + exp(-sommatoria));
     //printf(" sommatoria %f -> %f\n",sommatoria, risultato);
 
-    return risultato;
+    if(tipo == 1)
+        return relu(sommatoria);
+    
+    return sigmoide(sommatoria);
+}
+
+double sigmoide(double valore) {
+    return 1.0 / (1.0 + exp(-valore));
+}
+
+double derivata_sigmoide(double valore) {
+    return valore * (1.0 - valore);
 }
 
 int previsione(double valore)
@@ -149,31 +167,42 @@ int previsione(double valore)
     else
         return 0;
 }
- 
-void discesa_gradiente(ReteNeurale rete, double **sigmoidi, double **gradienti)
+
+double relu(double valore) {
+    if(valore > 0)
+        return valore;
+    
+    return 0;
+}
+
+double derivata_relu(double valore) {
+    if(valore > 0)
+        return 1;
+
+    return 0;
+}
+
+void discesa_gradiente(ReteNeurale rete, double **funzioni, double **gradienti, int tipo_derivata)
 {
-    //printf("Qui?\n");
-    // For che scorre i layer dal penultimo al primo QUINI SIZE -2
     for (int indice_layer = rete.size - 2; indice_layer >= 0; indice_layer--)
     {
-        //printf("layer: %d ", indice_layer);
-        // printf("Mi trovo nel layer %d, ho %d percettroni\n", indice_layer, rete.layers[indice_layer].size);
-
-        // For che scorre i percettroni del layer partendo dal primo
-        // Per ogni percettrone mi devo prendere il gradiente disceso dal livello sopra e moltiplicarlo per la derivata di attivazione
         for (int indice_percettrone = 0; indice_percettrone < rete.layers[indice_layer].size; indice_percettrone++)
         {
-            //printf("percettrone: %d ", indice_percettrone);
-            double derivata_attivazione = sigmoidi[indice_layer][indice_percettrone] * (1.0 - sigmoidi[indice_layer][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
             double gradiente_disceso = calcola_gradiente_disceso(rete, indice_layer + 1, indice_percettrone, gradienti);
 
             gradienti[indice_layer][indice_percettrone] = gradiente_disceso * derivata_attivazione;
         }
-        //printf("\n");
     }
-    //printf("Qui ?\n");
 }
 
 double calcola_gradiente_disceso(ReteNeurale rete, int livello, int indice_peso, double **gradienti)
@@ -190,29 +219,34 @@ double calcola_gradiente_disceso(ReteNeurale rete, int livello, int indice_peso,
     return sommatoria;
 }
 
-double **elabora_sigmoidi(ReteNeurale rete, Istanza istanza)
+//tipo_funzione 1: relu, 2:sigmoide
+double **elabora_funzioni_attivazione(ReteNeurale rete, Istanza istanza, int tipo_funzione)
 {
-    // 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 *) * rete.size);
+
+    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];
     }
 
-    sigmoidi[0] = (double *)malloc(sizeof(double) * rete.layers[0].size);
+    funzioni[0] = (double *)malloc(sizeof(double) * rete.layers[0].size);
     for(int indice_percettrone = 0; indice_percettrone < rete.layers[0].size; indice_percettrone ++) {
-        sigmoidi[0][indice_percettrone] = sigmoide(rete.layers[0].percettroni[indice_percettrone], inputs);
+        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 ++) {
-        sigmoidi[indice_layer] = (double *)malloc(sizeof(double) * rete.layers[indice_layer].size);
+        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 ++) {
-            sigmoidi[indice_layer][indice_percettrone] = sigmoide(rete.layers[indice_layer].percettroni[indice_percettrone], sigmoidi[indice_layer-1]);
+            //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 sigmoidi;
+    return funzioni;
 }