Aggiunto qualche printf

classificatore.c

@@ -11,7 +11,7 @@ void main() {
     Dataset mnist = *get_dataset(file_immagini, file_label);
 
     for(int epoca = 0; epoca < EPOCHE; epoca++) {
-        //printf("\nEPOCA %d\n", epoca);
+        printf("\nEPOCA %d\n", epoca);
         if (addestra(&rete, mnist))
             break;
     }

percettroni.h

@@ -15,7 +15,7 @@ char *file_pesi = "rete_mnist.bin";
 //  char *file_immagini = "cifar-10/data_batch_5.bin";
 // char *file_immagini = "cifar-10/test_batch.bin";
 
-//#include "xor_manager.h"
+// #include "xor_manager.h"
 
 typedef unsigned char byte;
 
@@ -150,7 +150,7 @@ void discesa_gradiente(ReteNeurale *, double **, double **);
  * Questo è il "peso" dell'errore che deve essere corretto a questo livello.
  */
 double calcola_gradiente_disceso(ReteNeurale *, int, int, double **);
-//double trova_gradiente_errore_softmax(double *, int , int);
+// double trova_gradiente_errore_softmax(double *, int , int);
 
 /*
  * Aggiorna tutti i pesi della rete usando i gradienti calcolati (discesa del gradiente).
@@ -274,18 +274,21 @@ ReteNeurale inizializza_rete_neurale(int numero_input, int numero_layers, int nu
 
         if (livello == numero_layers - 1)
             numero_percettroni_livello = numero_percettroni_finali;
-        else {
-            double frazione = (double) (numero_layers - livello) / (double) numero_layers;
+        else
+        {
+            double frazione = (double)(numero_layers - livello) / (double)numero_layers;
             numero_percettroni_livello = (int)((double)(numero_percettroni_iniziali * frazione));
         }
 
         printf("Layer %d -> percettroni: %d\n", livello, numero_percettroni_livello);
 
-        if (livello == 0) {
+        if (livello == 0)
+        {
             r.layers[livello] = inizializza_layer(numero_percettroni_livello, numero_input);
             somma_parametri += (numero_percettroni_livello * numero_input);
         }
-        else {
+        else
+        {
             r.layers[livello] = inizializza_layer(numero_percettroni_livello, r.layers[livello - 1].size);
             somma_parametri += (numero_percettroni_livello * r.layers[livello - 1].size);
         }
@@ -309,12 +312,15 @@ double **elabora_gradienti(ReteNeurale *rete_neurale, byte output_corretto, doub
         gradienti[indice_layer] = (double *)malloc(sizeof(double) * rete_neurale->layers[indice_layer].size);
     }
 
-    for(int indice_percettrone = 0; indice_percettrone < rete_neurale->layers[rete_neurale->size - 1].size; indice_percettrone++) {
+    for (int indice_percettrone = 0; indice_percettrone < rete_neurale->layers[rete_neurale->size - 1].size; indice_percettrone++)
+    {
         double gradiente_errore = 0.0;
-        if(indice_percettrone == output_corretto) {
+        if (indice_percettrone == output_corretto)
+        {
             gradiente_errore = 1 - sigmoidi[rete_neurale->size - 1][indice_percettrone];
         }
-        else {
+        else
+        {
             gradiente_errore = 0 - sigmoidi[rete_neurale->size - 1][indice_percettrone];
         }
 
@@ -337,10 +343,10 @@ double sigmoide(Percettrone p, double *valori)
 
     sommatoria += p.bias;
 
-    //Sigmoide
+    // Sigmoide
     double risultato = 1.0 / (1.0 + exp(-sommatoria));
-    //ReLU
-    //double risultato = sommatoria > 0 ? sommatoria : 0.0f;
+    // ReLU
+    // double risultato = sommatoria > 0 ? sommatoria : 0.0f;
 
     // printf(" sommatoria %f -> %f\n",sommatoria, risultato);
 
@@ -353,7 +359,8 @@ double derivata_sigmoide(double valore)
     return derivata;
 }
 
-void softmax(double *input, int size) {
+void softmax(double *input, int size)
+{
     float max = input[0];
 
     for (int i = 1; i < size; i++)
@@ -361,7 +368,8 @@ void softmax(double *input, int size) {
             max = input[i];
 
     float sum = 0.0f;
-    for (int i = 0; i < size; i++) {
+    for (int i = 0; i < size; i++)
+    {
         input[i] = expf(input[i] - max);
         sum += input[i];
     }
@@ -378,13 +386,15 @@ int previsione(double valore)
         return 0;
 }
 
-int previsione_softmax(double *livello_percettroni, int size) {
+int previsione_softmax(double *livello_percettroni, int size)
+{
 
     softmax(livello_percettroni, size);
     int max = 0;
 
-    for(int i = 1; i < size; i++) {
-        if(livello_percettroni[i] > livello_percettroni[max])
+    for (int i = 1; i < size; i++)
+    {
+        if (livello_percettroni[i] > livello_percettroni[max])
             max = i;
     }
 
@@ -452,7 +462,8 @@ double **elabora_sigmoidi(ReteNeurale *rete, Istanza istanza)
 void aggiorna_pesi(ReteNeurale *rete_neurale, double **sigmoidi, double **gradienti, Istanza istanza)
 {
 
-    for(int indice_percettrone = 0; indice_percettrone < rete_neurale->layers[rete_neurale->size - 1].size; indice_percettrone++) {
+    for (int indice_percettrone = 0; indice_percettrone < rete_neurale->layers[rete_neurale->size - 1].size; indice_percettrone++)
+    {
 
         for (int indice_peso = 0; indice_peso < rete_neurale->layers[rete_neurale->size - 1].percettroni[indice_percettrone].size; indice_peso++)
         {
@@ -522,17 +533,18 @@ char addestra(ReteNeurale *rete_neurale, Dataset set)
 
         int previsto = previsione_softmax(sigmoidi_softmax, rete_neurale->layers[rete_neurale->size - 1].size);
 
-        if (previsto == output_corretto) {
+        if (previsto == output_corretto)
+        {
             corrette++;
         }
 
         aggiorna_pesi(rete_neurale, sigmoidi, gradienti, set.istanze[indice_set]);
 
-        for(int i = 0; i < rete_neurale->size; i++)
+        for (int i = 0; i < rete_neurale->size; i++)
             free(gradienti[i]);
         free(gradienti);
 
-        for(int i = 0; i < rete_neurale->size; i++)
+        for (int i = 0; i < rete_neurale->size; i++)
             free(sigmoidi[i]);
         free(sigmoidi);
         free(sigmoidi_softmax);
@@ -542,7 +554,7 @@ char addestra(ReteNeurale *rete_neurale, Dataset set)
 
     printf("Risposte corrette: %d%%\n", percentuale);
 
-    if(percentuale >= TOLLERANZA)
+    if (percentuale >= TOLLERANZA)
         return 1;
     else
         return 0;

visualizzatore.c

@@ -96,7 +96,7 @@ void init_allegro() {
 void carica_immagine(int indice_set)
 {
     // Stampa informazioni sull'immagine
-    printf("Immagine indice: %d, valore: %d. è un 7? %d\n", indice_set, set->istanze[indice_set].classificazione, prevedi(indice_set));
+    printf("Immagine indice: %d, valore: %d. valore previsto: %d\n", indice_set, set->istanze[indice_set].classificazione, prevedi(indice_set));
 
     // Itera su ogni pixel dell'immagine
     for (int y = 0; y < IMAGE_HEIGHT; y++)
@@ -165,16 +165,18 @@ void evento_click_bottone(int indice_set)
 
 int prevedi(int indice_set)
 {
-    double **sigmoidi = elabora_sigmoidi(*rete_neurale, set->istanze[indice_set]);
+    double *sigmoidi_softmax = elabora_sigmoidi(rete_neurale, set->istanze[indice_set])[rete_neurale->size-1];
 
-    byte output_corretto = get_out_corretto(set->istanze[indice_set].classificazione);
+    byte output_corretto = set->istanze[indice_set].classificazione;
 
-    return previsione(sigmoidi[rete_neurale->size - 1][0]);
+    int previsto = previsione_softmax(sigmoidi_softmax, rete_neurale->layers[rete_neurale->size - 1].size);
+
+    return previsto;
 }
 
-byte get_out_corretto(byte categoria) {
+/* byte get_out_corretto(byte categoria) {
     if(categoria == CATEGORIA)
         return 1;
     else
         return 0;
-}
+} */