provo a ottimizzarlo con relu per farlo convergere prima. Addestrato al 99%

classificatore.c

@@ -4,8 +4,8 @@
 
 void main() {
     //input, layers, perc iniz, perc fin
-    //ReteNeurale rete = inizializza_rete_neurale(N_INPUTS, 10, 256, 10);
+    ReteNeurale rete = inizializza_rete_neurale(N_INPUTS, 2, 32, 10);
-    ReteNeurale rete = *caricaReteNeurale(file_pesi);
+    //ReteNeurale rete = *caricaReteNeurale(file_pesi);
     //stampa_pesi_rete(rete);
 
     //Dataset xor = *crea_dataset_xor();

percettroni.h

@@ -19,9 +19,9 @@ char *file_pesi = "rete_mnist.bin";
 
 typedef unsigned char byte;
 
-double LRE = 0.1;
+double LRE = 0.01;
 double soglia_sigmoide = 0.5;
-#define TOLLERANZA 97
+#define TOLLERANZA 99
 
 typedef struct
 {
@@ -312,20 +312,22 @@ double **elabora_gradienti(ReteNeurale *rete_neurale, byte output_corretto, doub
         gradienti[indice_layer] = (double *)malloc(sizeof(double) * rete_neurale->layers[indice_layer].size);
     }
 
+    //ULTIMO LAYER
     for (int indice_percettrone = 0; indice_percettrone < rete_neurale->layers[rete_neurale->size - 1].size; indice_percettrone++)
     {
-        double gradiente_errore = 0.0;
+        //double gradiente_errore = 0.0;
         if (indice_percettrone == output_corretto)
         {
-            gradiente_errore = 1 - sigmoidi[rete_neurale->size - 1][indice_percettrone];
+            gradienti[rete_neurale->size - 1][indice_percettrone] = 1 - sigmoidi[rete_neurale->size - 1][indice_percettrone];
         }
         else
         {
-            gradiente_errore = 0 - sigmoidi[rete_neurale->size - 1][indice_percettrone];
+            gradienti[rete_neurale->size - 1][indice_percettrone] = 0 - sigmoidi[rete_neurale->size - 1][indice_percettrone];
         }
 
-        gradienti[rete_neurale->size - 1][indice_percettrone] = gradiente_errore * derivata_sigmoide(sigmoidi[rete_neurale->size - 1][indice_percettrone]);
+        //gradienti[rete_neurale->size - 1][indice_percettrone] = gradiente_errore * derivata_sigmoide(sigmoidi[rete_neurale->size - 1][indice_percettrone]);
     }
+    //--------------
 
     discesa_gradiente(rete_neurale, sigmoidi, gradienti);
 
@@ -346,16 +348,20 @@ double sigmoide(Percettrone p, double *valori)
     // Sigmoide
     double risultato = 1.0 / (1.0 + exp(-sommatoria));
     // ReLU
-    // double risultato = sommatoria > 0 ? sommatoria : 0.0f;
+    //double risultato = sommatoria > 0 ? sommatoria : 0.0f;
 
-    // printf(" sommatoria %f -> %f\n",sommatoria, risultato);
+    //printf(" sommatoria %f -> %f\n",sommatoria, risultato);
 
     return risultato;
 }
 
 double derivata_sigmoide(double valore)
 {
+    //Sigmoide
     double derivata = valore * (1.0 - valore);
+    //ReLU
+    //double derivata = valore >= 0 ? 1.0f : 0.0f;
+
     return derivata;
 }
 
@@ -378,13 +384,13 @@ void softmax(double *input, int size)
         input[i] /= sum;
 }
 
-int previsione(double valore)
+/* int previsione(double valore)
 {
     if (valore >= soglia_sigmoide)
         return 1;
     else
         return 0;
-}
+} */
 
 int previsione_softmax(double *livello_percettroni, int size)
 {
@@ -529,7 +535,6 @@ char addestra(ReteNeurale *rete_neurale, Dataset set)
         memcpy(sigmoidi_softmax, sigmoidi[rete_neurale->size - 1], rete_neurale->layers[rete_neurale->size - 1].size * sizeof(double));
 
         double **gradienti = elabora_gradienti(rete_neurale, output_corretto, sigmoidi);
-
         int previsto = previsione_softmax(sigmoidi_softmax, rete_neurale->layers[rete_neurale->size - 1].size);
 
         if (previsto == output_corretto)
@@ -537,6 +542,8 @@ char addestra(ReteNeurale *rete_neurale, Dataset set)
             corrette++;
         }
 
+        //printf("Previsto: %d, output: %d\n", previsto, output_corretto);
+
         aggiorna_pesi(rete_neurale, sigmoidi, gradienti, set.istanze[indice_set]);
 
         for (int i = 0; i < rete_neurale->size; i++)
@@ -549,9 +556,9 @@ char addestra(ReteNeurale *rete_neurale, Dataset set)
         free(sigmoidi_softmax);
     }
 
-    int percentuale = (int)((corrette * 100) / set.size);
+    float percentuale = ((corrette * 100.0) / set.size);
 
-    printf("Risposte corrette: %d%%\n", percentuale);
+    printf("Risposte corrette: %.2f%%\n", percentuale);
 
     if (percentuale >= TOLLERANZA)
         return 1;