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;
 
@@ -44,7 +44,7 @@ typedef struct
 
 /*
  * Genera un valore casuale nell'intervallo [-1, 1] per inizializzare pesi e bias.
- * Usa rand() modulo 101 (0-100) convertito in decimale (0.00-1.00), 
+ * Usa rand() modulo 101 (0-100) convertito in decimale (0.00-1.00),
  * poi scalato a [-1, 1] moltiplicando per 2 e sottraendo 1.
  */
 double randomico();
@@ -62,7 +62,7 @@ Percettrone inzializza_percettrone(int);
  * - numero_layers: quanti strati nascosti + strato di output
  * - numero_percettroni_iniziali: percettroni nel primo layer
  * - numero_percettroni_finali: percettroni nell'output (10 per MNIST, 1 per XOR)
- * 
+ *
  * I layer intermedi hanno numero decrescente di percettroni calcolato come:
  * numero_percettroni = numero_percettroni_iniziali * (layer_rimanenti / layer_totali)
  * Questo crea una piramide: molti neuroni in ingresso, pochi in uscita.
@@ -102,12 +102,12 @@ void softmax(double *, int);
 
 /*
  * Forward propagation: calcola gli output di tutti i layer partendo dall'input.
- * 
+ *
  * Algoritmo:
  * 1. Converte i byte input (0-255) in double normalizzati (0.0-1.0) dividendo per 255
  * 2. Per il primo layer: applica sigmoide a ogni percettrone usando gli input
  * 3. Per i layer successivi: usa gli output del layer precedente come input
- * 
+ *
  * Restituisce una matrice sigmoidi[layer][percettrone] con tutti i valori intermedi.
  * Questi valori servono poi per il calcolo dei gradienti (backpropagation).
  */
@@ -115,31 +115,31 @@ double **elabora_sigmoidi(ReteNeurale *, Istanza);
 
 /*
  * Calcola i gradienti dell'errore per ogni percettrone usando backpropagation.
- * 
+ *
  * Passaggi:
  * 1. GRADIENTI OUTPUT (ultimo layer):
  *    - Se il percettrone corrisponde alla classe corretta: errore = 1 - output
  *    - Altrimenti: errore = 0 - output
  *    - Moltiplica errore per derivata_sigmoide(output) per ottenere il gradiente
- * 
+ *
  * 2. GRADIENTI NASCOSTI (layer precedenti):
  *    - Usa discesa_gradiente() per propagare l'errore all'indietro
  *    - Ogni neurone riceve la somma pesata dei gradienti dei neuroni successivi
- * 
+ *
  * Il gradiente indica quanto e in che direzione modificare i pesi per ridurre l'errore.
  */
 double **elabora_gradienti(ReteNeurale *, byte, double **);
 
 /*
  * Propaga i gradienti dagli output verso i layer precedenti (backpropagation).
- * 
+ *
  * Per ogni layer (dall'ultimo al primo):
  * - Per ogni percettrone del layer corrente:
  *   1. Calcola derivata_sigmoide dell'output del percettrone
  *   2. Calcola gradiente_disceso: somma pesata dei gradienti del layer successivo
  *      moltiplicati per i pesi delle connessioni
  *   3. Il gradiente finale = gradiente_disceso * derivata_sigmoide
- * 
+ *
  * Questo è l'algoritmo della "catena" di derivate (chain rule) del calcolo differenziale.
  */
 void discesa_gradiente(ReteNeurale *, double **, double **);
@@ -150,21 +150,21 @@ 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).
- * 
+ *
  * Formula di aggiornamento: peso_nuovo = peso_vecchio + (gradiente * learning_rate)
- * 
+ *
  * Per l'ultimo layer:
  * - gradiente_peso = gradiente_percettrone * output_layer_precedente
  * - Aggiorna pesi e bias
- * 
+ *
  * Per i layer nascosti:
  * - Usa correggi_pesi_percettrone_double() per layer interni (input da double)
  * - Usa correggi_pesi_percettrone_byte() per primo layer (input da byte originale)
- * 
+ *
  * Il learning rate (LRE) controlla la "velocità" di apprendimento.
  */
 void aggiorna_pesi(ReteNeurale *, double **, double **, Istanza);
@@ -201,7 +201,7 @@ int previsione_softmax(double *, int);
  * - Numero di layer
  * - Per ogni layer: numero di percettroni
  * - Per ogni percettrone: numero di pesi, array pesi, bias
- * 
+ *
  * Il formato binario permette di ricaricare il modello addestrato
  * senza dover ripetere l'allenamento.
  */
@@ -210,7 +210,7 @@ void salvaReteNeurale(const char *, ReteNeurale *);
 /*
  * Carica una rete neurale da file binario.
  * Legge la struttura e alloca dinamicamente tutta la memoria necessaria.
- * 
+ *
  * Restituisce NULL se il file non esiste o c'è un errore di allocazione.
  */
 ReteNeurale *caricaReteNeurale(const char *);
@@ -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;
+        {
+            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
+    // ReLU
-    //double risultato = sommatoria > 0 ? sommatoria : 0.0f;
+    // double risultato = sommatoria > 0 ? sommatoria : 0.0f;
 
     // printf(" sommatoria %f -> %f\n",sommatoria, risultato);
 
@@ -349,19 +355,21 @@ double sigmoide(Percettrone p, double *valori)
 
 double derivata_sigmoide(double valore)
 {
-    double derivata = valore * (1.0 - valore);   
+    double derivata = valore * (1.0 - 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++)
         if (input[i] > max)
             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++) {
+    for (int i = 1; i < size; i++)
-        if(livello_percettroni[i] > livello_percettroni[max])
+    {
+        if (livello_percettroni[i] > livello_percettroni[max])
             max = i;
     }
 
@@ -397,7 +407,7 @@ 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 =  derivata_sigmoide(sigmoidi[indice_layer][indice_percettrone]);
+            double derivata_attivazione = derivata_sigmoide(sigmoidi[indice_layer][indice_percettrone]);
             double gradiente_disceso = calcola_gradiente_disceso(rete, indice_layer + 1, indice_percettrone, gradienti);
 
             gradienti[indice_layer][indice_percettrone] = gradiente_disceso * derivata_attivazione;
@@ -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++)
         {
@@ -514,25 +525,26 @@ char addestra(ReteNeurale *rete_neurale, Dataset set)
         byte output_corretto = set.istanze[indice_set].classificazione;
 
         double **sigmoidi = elabora_sigmoidi(rete_neurale, set.istanze[indice_set]);
-        
+
         double *sigmoidi_softmax = (double *)malloc(sizeof(double) * rete_neurale->layers[rete_neurale->size - 1].size);
         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) {
+        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;
-}
+} */