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

@@ -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 {
+        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];
         }
 
@@ -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,12 +386,14 @@ 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++) {
+    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,7 +533,8 @@ 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++;
         }
 

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;
-}
+} */