aggiunta serializzazione rete su file, l'intero dataset 1 e inserita funzione che tiene conto del tempo

classificatore_singolo.c

@@ -1,4 +1,5 @@
 #include "visualizzatore.h"
+#include <time.h>
 
 #define NUM_LAYERS 4
 
@@ -21,6 +22,10 @@ byte get_out_corretto(byte);
 void stampa_layer_indirizzo(Layer*);
 
 void main() {
+    time_t tempo_epoche[MAX_EPOCHE];
+
+    double tempo_trascorso;
+
     srand(time(NULL));
 
     /* init_allegro();
@@ -44,27 +49,50 @@ void main() {
     Dataset set = *set_appoggio;
     free(set_appoggio);
 
-    ReteNeurale rete_neurale = inizializza_rete_neurale(NUM_LAYERS);
+    ReteNeurale rete_neurale;
-    //inizializzo layer 0
+    ReteNeurale *puntatore_rete = caricaReteNeurale("rete_cifar_pesi.bin");
-    rete_neurale.layers[0] = inizializza_layer(PERCETTRONI_LAYER_0, INPUT_LAYER_0);
+    if(puntatore_rete == NULL) {
-    //inizializzo layer 1
+        rete_neurale = inizializza_rete_neurale(NUM_LAYERS);
-    rete_neurale.layers[1] = inizializza_layer(PERCETTRONI_LAYER_1, INPUT_LAYER_1);
+        //inizializzo layer 0
-    //inizializzo layer 2
+        rete_neurale.layers[0] = inizializza_layer(PERCETTRONI_LAYER_0, INPUT_LAYER_0);
-    rete_neurale.layers[2] = inizializza_layer(PERCETTRONI_LAYER_2, INPUT_LAYER_2);
+        //inizializzo layer 1
-    //inizializzo layer 3
+        rete_neurale.layers[1] = inizializza_layer(PERCETTRONI_LAYER_1, INPUT_LAYER_1);
-    rete_neurale.layers[3] = inizializza_layer(PERCETTRONI_LAYER_3, INPUT_LAYER_3);
+        //inizializzo layer 2
-    //inizializzo layer ULTIMO
+        rete_neurale.layers[2] = inizializza_layer(PERCETTRONI_LAYER_2, INPUT_LAYER_2);
-    //rete_neurale.layers[4] = inizializza_layer(PERCETTRONI_LAYER_4, INPUT_LAYER_4);
+        //inizializzo layer 3
+        rete_neurale.layers[3] = inizializza_layer(PERCETTRONI_LAYER_3, INPUT_LAYER_3);
+        //inizializzo layer ULTIMO
+        //rete_neurale.layers[4] = inizializza_layer(PERCETTRONI_LAYER_4, INPUT_LAYER_4);
+    } else {
+        rete_neurale = *puntatore_rete;
+        free(puntatore_rete);
+        printf("Caricate impostazioni rete neurale da file\n");
+    }
 
-    printf("Numero immagini: %d\n", 1000);
+    printf("Numero immagini: %d\n", set.size);
 
     //ADDESTRAMENTO
     for(int i = 0; i < MAX_EPOCHE; i++) {
-        printf("Epoca %d\n", i);
+        time(&tempo_epoche[i]);
+        
+        if(i == 0)
+            printf("Epoca %d\n", i);
+        else {
+            time(&tempo_epoche[i]);
+            double tempo_trascorso_epoca = difftime(tempo_epoche[i], tempo_epoche[i-1]);
+            double tempo_trascorso_totale = difftime(tempo_epoche[i], tempo_epoche[0]);
+            int minuti_epoca = (int)tempo_trascorso_epoca / 60;
+            int secondi_epoca = (int)tempo_trascorso_epoca % 60;
+            int minuti_totali = (int)tempo_trascorso_totale / 60;
+            int secondi_totali = (int)tempo_trascorso_totale % 60;
+            printf("Epoca %d\n", i);
+            printf("Tempo dall'epoca precedente: %d:%d\n", minuti_epoca, secondi_epoca);
+            printf("Tempo dall'inizio: %d:%d\n", minuti_epoca, secondi_epoca);
+        }
 
         int corrette = 0;
 
-        for(int indice_set = 0; indice_set < 1000; indice_set++) {
+        for(int indice_set = 0; indice_set < set.size; indice_set++) {
 
             //printf("\timmagine: %d\n", indice_set);
 
@@ -102,6 +130,8 @@ void main() {
         }
         printf("\tRisposte corrette: %d\n", corrette);
     }
+
+    salvaReteNeurale("rete_cifar_pesi.bin", &rete_neurale);
 }
 
 //Questa funzione ritorna 1 se la categoria è quella che voglio individuare, altrimenti 0

percettroni.h

@@ -47,6 +47,9 @@ void correggi_layer_input(Layer*, double**, double**, byte*, int);
 
 int previsione(double);
 
+void salvaReteNeurale(const char*, ReteNeurale*);
+ReteNeurale *caricaReteNeurale(const char*);
+
 //Questa funzione genera un valore reale random compreso nell'intervallo [-1, 1]
 double randomico() {
     // Genero numeri nell'intervallo [-1,1]
@@ -193,30 +196,79 @@ void correggi_layer_input(Layer *layer, double **gradienti, double **sigmoidi, b
     }
 }
 
-
+void salvaReteNeurale(const char *filename, ReteNeurale *rete) {
-
+    FILE *file = fopen(filename, "wb");
-
+    if (!file) {
-
+        perror("Errore nell'apertura del file");
-
+        exit(EXIT_FAILURE);
-/* void correggi_pesi_layer(Percettrone[], int, int, double**, double[], double[]);
-void correggi_pesi_layer_uno(Percettrone[], int, int, double**, byte[], double[]);
-
-void correggi_pesi_layer(Percettrone percettroni_layer[], int size_percettroni, int size_inputs, double **gradienti, double inputs[], double gradienti_bias[]) {
-    for(int i = 0; i < size_percettroni; i++) {
-        // Non termina questo for
-        for(int j = 0; j < size_inputs; j++) {
-            percettroni_layer[i].pesi[j] -= LRE * gradienti[i][j] * inputs[j];
-        }
-        percettroni_layer[i].bias -= LRE * gradienti_bias[i];
     }
+
+    // Scrivi il numero di layer
+    fwrite(&rete->size, sizeof(int), 1, file);
+
+    // Scrivi ogni layer
+    for (int i = 0; i < rete->size; i++) {
+        Layer *layer = &rete->layers[i];
+        fwrite(&layer->size, sizeof(int), 1, file);
+
+        // Scrivi ogni percettrone nel layer
+        for (int j = 0; j < layer->size; j++) {
+            Percettrone *perc = &layer->percettroni[j];
+            fwrite(&perc->size, sizeof(int), 1, file);
+            fwrite(perc->pesi, sizeof(double), perc->size, file);
+            fwrite(&perc->bias, sizeof(double), 1, file);
+        }
+    }
+
+    fclose(file);
 }
 
-void correggi_pesi_layer_uno(Percettrone percettroni_layer[], int size_percettroni, int size_inputs, double **gradienti, byte inputs[], double gradienti_bias[]) {
+ReteNeurale *caricaReteNeurale(const char *filename) {
+    FILE *file = fopen(filename, "rb");
 
-    for(int i = 0; i < size_percettroni; i++) {
+    if (!file) {
-        for(int j = 0; j < size_inputs; j++) {
+        perror("Errore nell'apertura del file");
-            percettroni_layer[i].pesi[j] -= LRE * gradienti[i][j] * inputs[j];
+        return NULL;
-        }
-        percettroni_layer[i].bias -= LRE * gradienti_bias[i];
     }
-} */
+
+    ReteNeurale *rete = malloc(sizeof(ReteNeurale));
+    if (!rete) {
+        perror("Errore nell'allocazione della memoria");
+        return NULL;
+    }
+
+    // Leggi il numero di layer
+    fread(&rete->size, sizeof(int), 1, file);
+    rete->layers = malloc(rete->size * sizeof(Layer));
+    if (!rete->layers) {
+        perror("Errore nell'allocazione della memoria");
+        return NULL;
+    }
+
+    // Leggi ogni layer
+    for (int i = 0; i < rete->size; i++) {
+        Layer *layer = &rete->layers[i];
+        fread(&layer->size, sizeof(int), 1, file);
+        layer->percettroni = malloc(layer->size * sizeof(Percettrone));
+        if (!layer->percettroni) {
+            perror("Errore nell'allocazione della memoria");
+            return NULL;
+        }
+
+        // Leggi ogni percettrone nel layer
+        for (int j = 0; j < layer->size; j++) {
+            Percettrone *perc = &layer->percettroni[j];
+            fread(&perc->size, sizeof(int), 1, file);
+            perc->pesi = malloc(perc->size * sizeof(double));
+            if (!perc->pesi) {
+                perror("Errore nell'allocazione della memoria");
+                return NULL;
+            }
+            fread(perc->pesi, sizeof(double), perc->size, file);
+            fread(&perc->bias, sizeof(double), 1, file);
+        }
+    }
+
+    fclose(file);
+    return rete;
+}