Sistemato visualizzatore e addestrata per cifar10, ma tanto per cambiare non va

classificatore_singolo.c

@@ -4,7 +4,7 @@
 // Scelgo quale categoria voglio identificare. nel caso dello xor -1
 #define CATEGORIA 7
 #define NUM_LAYERS 4
-#define PERCETTRONI_LAYER_0 16
+#define PERCETTRONI_LAYER_0 32
 #define MAX_EPOCHE 10
 
 byte get_out_corretto(byte);
@@ -17,7 +17,7 @@ void main()
 
     srand(time(NULL));
 
-    Dataset *set_appoggio = get_dataset(file_immagini, file_label);
+    Dataset *set_appoggio = get_dataset(file_immagini);//get_dataset(file_immagini, file_label);
 
     if (set_appoggio == NULL)
         return;

percettroni.h

@@ -5,17 +5,24 @@
 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_immagini = "mnist/train-images.idx3-ubyte";
-char *file_label = "mnist/train-labels.idx1-ubyte";
+char *file_label = "mnist/train-labels.idx1-ubyte"; */
+
+//#include "mnist/mnist_manager.h"
+#include "cifar-10/cifar10_manager.h";
+//char *file_immagini = "cifar-10/data_batch_1.bin";
+//char *file_immagini = "cifar-10/data_batch_2.bin";
+//char *file_immagini = "cifar-10/data_batch_3.bin";
+//char *file_immagini = "cifar-10/data_batch_4.bin";
+//char *file_immagini = "cifar-10/data_batch_5.bin";
+char *file_immagini = "cifar-10/test_batch.bin";
 
-#include "mnist/mnist_manager.h"
-// #include "cifar_10/cifar10_manager.h"
 //#include "xor_manager.h"
 
 // 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

visualizzatore.c

@@ -1,14 +1,15 @@
 #include <allegro.h>
 #include <time.h>
 #include "percettroni.h"
-#include "mnist/mnist_manager.h"
+//#include "mnist/mnist_manager.h"
 
 //CIFAR_10
-/* #define IMAGE_WIDTH 32
+#define IMAGE_WIDTH 32
-#define IMAGE_HEIGHT 32 */
+#define IMAGE_HEIGHT 32
 //MNIST
-#define IMAGE_WIDTH 28
+/* #define IMAGE_WIDTH 28
-#define IMAGE_HEIGHT 28
+#define IMAGE_HEIGHT 28*/
+
 #define SCALE_FACTOR 2
 
 //Cavalli
@@ -33,7 +34,7 @@ void main()
     init_allegro();
 
     //get_dataset("cifar-10-batches/test_batch.bin");
-    set = get_dataset(file_immagini, file_label);
+    set = get_dataset(file_immagini);//get_dataset(file_immagini, file_label);
     if (set == NULL) {
         printf("Errore nel caricare il dataset\n");
         return;
@@ -74,27 +75,27 @@ void init_allegro() {
 }
 
 //cifar_10
-/* void carica_immagine(int indice_set)
+void carica_immagine(int indice_set)
 {
-    printf("Immagine indice: %d, categoria: %d, previsione: %d\n", indice_set, set->istanze[indice_set].categoria, prevedi(indice_set));
+    printf("Immagine indice: %d, categoria: %d, previsione: %d\n", indice_set, set->istanze[indice_set].classificazione, prevedi(indice_set));
 
     for (int y = 0; y < IMAGE_HEIGHT; y++)
     {
         for (int x = 0; x < IMAGE_WIDTH; x++)
         {
-            int r = set->istanze[indice_set].immagine[y * IMAGE_WIDTH + x];
+            int r = set->istanze[indice_set].dati[y * IMAGE_WIDTH + x];
-            int g = set->istanze[indice_set].immagine[1024 + y * IMAGE_WIDTH + x];
+            int g = set->istanze[indice_set].dati[1024 + y * IMAGE_WIDTH + x];
-            int b = set->istanze[indice_set].immagine[2048 + y * IMAGE_WIDTH + x];
+            int b = set->istanze[indice_set].dati[2048 + y * IMAGE_WIDTH + x];
             putpixel(image, x, y, makecol(r, g, b));
         }
     }
-} */
+}
 
 //MNIST
-void carica_immagine(int indice_set)
+/* 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].categoria, prevedi(indice_set));
+    printf("Immagine indice: %d, valore: %d. è un 7? %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++)
@@ -102,7 +103,7 @@ void carica_immagine(int indice_set)
         for (int x = 0; x < IMAGE_WIDTH; x++)
         {
             // Ottieni il valore del pixel (scala di grigi, quindi un solo canale)
-            int gray_value = set->istanze[indice_set].immagine[y * IMAGE_WIDTH + x];
+            int gray_value = set->istanze[indice_set].dati[y * IMAGE_WIDTH + x];
 
             // Converti il valore in scala di grigi in un colore RGB (r = g = b = gray_value)
             int color = makecol(gray_value, gray_value, gray_value);
@@ -111,11 +112,10 @@ void carica_immagine(int indice_set)
             putpixel(image, x, y, color);
         }
     }
-}
+} */
 
 void disegna_interfaccia()
 {
-    //printf("\tPrevisione: %d\n", previsione);
     clear_to_color(buffer, makecol(255, 255, 255));
 
     // Calcola la posizione per centrare l'immagine ingrandita
@@ -135,11 +135,6 @@ void disegna_interfaccia()
 
     rectfill(buffer, button_x, button_y, button_x + button_width, button_y + button_height, makecol(200, 200, 200));
     textout_centre_ex(buffer, font, "prossima", button_x + button_width / 2, button_y + 10, makecol(0, 0, 0), -1);
-
-    /* if(previsto == 1)
-        textout_centre_ex(buffer, font, "cavallo", button_x + button_width / 2, 70, makecol(0, 255, 0), -1);
-    else
-        textout_centre_ex(buffer, font, "non cavallo", button_x + button_width / 2, 70, makecol(255, 0, 0), -1); */
     
     // Copia il buffer sullo schermo
     blit(buffer, screen, 0, 0, 0, 0, 800, 600);
@@ -169,18 +164,9 @@ void evento_click_bottone(int indice_set)
 
 int prevedi(int indice_set)
 {
-    double **sigmoidi = (double **)malloc(sizeof(double *) * rete_neurale->size);
+    double **sigmoidi = elabora_sigmoidi(*rete_neurale, set->istanze[indice_set]);
 
-    sigmoidi[0] = (double *)malloc(sizeof(double) * rete_neurale->layers[0].size);
+    byte output_corretto = get_out_corretto(set->istanze[indice_set].classificazione);
-    sigmoidi[0] = funzioni_attivazione_layer_byte(rete_neurale->layers[0], set->istanze[indice_set].immagine);
-
-    for (int j = 1; j < rete_neurale->size; j++)
-    {
-        sigmoidi[j] = (double *)malloc(sizeof(double) * rete_neurale->layers[j].size);
-        sigmoidi[j] = funzioni_attivazione_layer_double(rete_neurale->layers[j], sigmoidi[j - 1]);
-    }
-
-    byte output_corretto = get_out_corretto(set->istanze[indice_set].categoria);
 
     return previsione(sigmoidi[rete_neurale->size - 1][0]);
 }