aggiornato classificatore singolo per mnist

classificatore_singolo.c

@@ -77,20 +77,20 @@ void main() {
 
         int corrette = 0;
 
-        for(int indice_set = 0; indice_set < set.size; indice_set++) {
-
-            printf("\timmagine: %d\n", indice_set);
+        for(int indice_set = 0; indice_set < set.size -1; indice_set++) {
 
             double **sigmoidi = (double **)malloc(sizeof(double*) * NUM_LAYERS);
 
             sigmoidi[0] = (double*)malloc(sizeof(double) * PERCETTRONI_LAYER_0);
             sigmoidi[0] = funzioni_attivazione_layer_byte(rete_neurale.layers[0], set.istanze[indice_set].immagine);
-
+            
             for(int j = 1; j < NUM_LAYERS; 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]);
             }
 
+            //printf("\timmagine: %d post sigmoidi\n", indice_set);
+
             byte output_corretto = get_out_corretto(set.istanze[indice_set].categoria);
 
             
@@ -103,7 +103,7 @@ void main() {
                     gradienti[indice_layer] = (double*)malloc(sizeof(double) * rete_neurale.layers[indice_layer].size);
                 }
 
-                gradienti[NUM_LAYERS-1][0] = output_corretto - sigmoidi[NUM_LAYERS-1][0];
+                gradienti[NUM_LAYERS-1][0] = - (output_corretto - sigmoidi[NUM_LAYERS-1][0]);
 
                 correggi_layer_interni(&rete_neurale, gradienti, sigmoidi);
                 correggi_layer_input(&rete_neurale.layers[0], gradienti, sigmoidi, set.istanze[indice_set].immagine, NUM_LAYERS);
@@ -113,7 +113,7 @@ void main() {
                 corrette++;
             }
 
-            printf("\timmagine: %d post calcoli, indovinate: %d\n", indice_set, corrette);
+            //printf("\timmagine: %d post correzioni\n", indice_set);
         }
         
         printf("\tRisposte corrette: %d\n", corrette);

mnist/mnist_manager.h

@@ -1,3 +1,16 @@
+/*
+Il file MNIST in formato IDX ha questa struttura:
+Byte 0-3: Numero magico (4 byte).
+Byte 4-7: Numero di immagini (4 byte).
+Byte 8-11: Numero di righe per immagine (4 byte).
+Byte 12-15: Numero di colonne per immagine (4 byte).
+Byte 16 in poi: Dati delle immagini (ogni immagine è composta da 28x28 = 784 byte).
+
+Le immagini sono 28x28 pixel.
+I dati sono byte non firmati (valori da 0 a 255).
+Il file contiene 60.000 immagini (per il training set),
+*/
+
 #include <stdlib.h>
 #include <stdio.h>
 
@@ -29,7 +42,6 @@ Dataset *get_dataset(char *path_mnist, char *path_categoria)
     Dataset *set = (Dataset *)malloc(sizeof(Dataset));
     FILE *file;
     FILE *categorie;
-    Istanza istanza;
     Istanza *istanze = (Istanza *)malloc(sizeof(Istanza));
 
     file = fopen(path_mnist, "rb");
@@ -46,16 +58,15 @@ Dataset *get_dataset(char *path_mnist, char *path_categoria)
 
     int numero_righe = 0;
 
-    //printf("Scorro il while %d\n", fread(istanze[numero_righe].categoria, sizeof(byte), 2, categorie));
-
-    // Fino a quando questo fread restituisce 1 significa che il file contiene ancora roba
-    while (fread(istanze[numero_righe].immagine, sizeof(byte), N_PIXEL, file) == N_PIXEL)
-    {
-        if(fread(&istanze[numero_righe].categoria, sizeof(byte), 1, categorie) == 1) {
-            numero_righe++;
-            istanze = (Istanza *)realloc(istanze, sizeof(Istanza) * (numero_righe + 1));
+    //Leggo male il file, cambiare in base alle dichiarazioni sopra
+    if(fread(istanze[numero_righe].immagine, sizeof(byte), 16, file) == 16)
+        while (fread(istanze[numero_righe].immagine, sizeof(byte), N_PIXEL, file) == N_PIXEL)
+        {
+            if(fread(&istanze[numero_righe].categoria, sizeof(byte), 1, categorie) == 1) {
+                numero_righe++;
+                istanze = (Istanza *)realloc(istanze, sizeof(Istanza) * (numero_righe + 1));
+            }
         }
-    }
 
     // Dataset set;
     (*set).size = numero_righe;

percettroni.h

@@ -107,7 +107,6 @@ double sigmoide_byte(Percettrone p, byte *valori, int n_input) {
 
 //Questa funzione viene usata per gli altri livelli dove gli input sono double, ossia i valori della sigmoide dei livelli precedenti
 double sigmoide_double(Percettrone p, double *valori, int n_input) {
-    
     double sommatoria = 0.0;
     for(int i = 0; i < n_input; i++) {
         sommatoria += (valori[i] * p.pesi[i]);
@@ -126,7 +125,7 @@ double sigmoide_double(Percettrone p, double *valori, int n_input) {
 
 //Questa funzione calcola tutte le funzioni di attivazione dei percettroni del layer che prende dei byte come inputs
 double *funzioni_attivazione_layer_byte(Layer layer, byte *inputs) {
-
+    
     double *funzioni = (double*)malloc(sizeof(double) * layer.size);
     
     for(int i = 0; i < layer.size; i++) {