correggere aggiornamento dei pesi

classificatore_singolo.c

@@ -5,25 +5,30 @@
 #define CATEGORIA 7
 #define NUM_LAYERS 4
 #define PERCETTRONI_LAYER_0 32
-#define MAX_EPOCHE 100
+#define MAX_EPOCHE 10
 
-//1 relu, 2 sigmoide
+// 1 relu, 2 sigmoide
 #define TIPO_FUNZIONE 2
 
 byte get_out_corretto(byte);
 void stampa_layer_indirizzo(Layer *);
 void stampa_tempo(time_t[], int);
+void debug(int);
 
 void main()
 {
+    srand(time(NULL));
     time_t tempo_epoche[MAX_EPOCHE];
 
-    srand(time(NULL));
+    /*
+        ################# Inizializzazione rete e caricamento Dataset ################################
+    */
 
     Dataset *set_appoggio = get_dataset(file_immagini, file_label);
 
     if (set_appoggio == NULL)
         return;
+
     Dataset set = *set_appoggio;
     free(set_appoggio);
 
@@ -31,7 +36,7 @@ void main()
     ReteNeurale *puntatore_rete = caricaReteNeurale(file_pesi);
     if (puntatore_rete == NULL)
     {
-        rete_neurale = inizializza_rete_neurale(NUM_LAYERS, PERCETTRONI_LAYER_0, N_INPUTS);
+        rete_neurale = inizializza_rete_neurale_feed_forward(NUM_LAYERS, PERCETTRONI_LAYER_0, N_INPUTS);
     }
     else
     {
@@ -40,31 +45,75 @@ void main()
         printf("Caricate impostazioni rete neurale da file\n");
     }
 
-    //rete_neurale = inizializza_rete_neurale(NUM_LAYERS, PERCETTRONI_LAYER_0, N_INPUTS);
+    // rete_neurale = inizializza_rete_neurale(NUM_LAYERS, PERCETTRONI_LAYER_0, N_INPUTS);
-    int corrette = 0;
 
     printf("Numero elementi nel dataset: %d\n", set.size);
 
-    // ADDESTRAMENTO
+    /*
+        ################# Addestramento ################################
+    */
+
+    int corrette = 0;
+
     for (int i = 0; i < MAX_EPOCHE; i++)
     {
+        /*
+            ################# inizializzazione variabili per l'epoca in corso ################################
+        */
+
         printf("Epoca %d\n", i);
         stampa_tempo(tempo_epoche, i);
+
         corrette = 0;
         double errore_totale = 0.0;
-        
+
-        for (int indice_set = 0; indice_set < set.size -1; indice_set++)
+        /* for (int xxx = 0; xxx < rete_neurale.size; xxx++)
+            {
+                for (int count = 0; count < rete_neurale.layers[xxx].size; count++)
+                {
+                    for (int count_2 = 0; count_2 < rete_neurale.layers[xxx].percettroni[count].size; count_2++)
+                    {
+                        printf("[%d][%d]: %f\t", count, count_2, rete_neurale.layers[xxx].percettroni[count].pesi[count_2]);
+                    }
+                    printf("\n");
+                }
+            } */
+
+        for (int indice_set = 0; indice_set < set.size; indice_set++)
         {
-            //printf("Qui ci arrivo %d\n", indice_set);
+            
-            double **funzioni_attivazione = elabora_funzioni_attivazione(rete_neurale, set.istanze[indice_set], TIPO_FUNZIONE);
+            /*
+                ################# Feed Forward ################################
+            */
+            // Elabora le funzioni di attivazione in base al tipo scelto. Ritorna un vettore bidimensionale dove la prima dimensione rappresenta l'indice del layer, la seconda quella del percettrone nel layer
 
-            /* for(int k = 0; k < rete_neurale.size; k++)
+            double **funzioni_attivazione = elabora_funzioni_attivazione(&rete_neurale, set.istanze[indice_set], TIPO_FUNZIONE);
-                for(int j = 0; j < rete_neurale.layers[k].size; j++)
-                    printf("sigmoide[%d][%d] = %f\n", k, j, funzioni_attivazione[k][j]); */
 
+            /*
+                ################# Previsione ################################
+            */
+            // Siccome il dataset da il numero della categoria a cui appartiene l'immagine, se la categoria è quella che cerco io output_corretto varrà 1 altrimenti 0
             byte output_corretto = get_out_corretto(set.istanze[indice_set].classificazione);
 
-            double **gradienti = (double **)malloc(sizeof(double *) * NUM_LAYERS);
+            if (previsione(funzioni_attivazione[rete_neurale.size - 1][0]) == output_corretto)
+                corrette++;
+
+            /*
+                ################# Funzione di perdita (errore) ################################
+            */
+
+            // printf("funzione_attivazione_out: %f", funzioni_attivazione[rete_neurale.size - 1][0]);
+
+            // Derivata funzione di perdita
+            double errore = (output_corretto - funzioni_attivazione[rete_neurale.size - 1][0]);
+
+            // Sommo la funzione di perdita a errore_totale per stampare alla fine dell'epoca l'errore medio
+            errore_totale += pow(errore, 2) * 0.5;
+
+            /*
+                ################# Retropropagazione ################################
+            */
+            /* double **gradienti = (double **)malloc(sizeof(double *) * NUM_LAYERS);
 
             // Alloco la dimensione per ogni layer
             for (int indice_layer = 0; indice_layer < NUM_LAYERS; indice_layer++)
@@ -72,40 +121,43 @@ void main()
                 gradienti[indice_layer] = (double *)malloc(sizeof(double) * rete_neurale.layers[indice_layer].size);
             }
 
-            
-
-            // Derivata funzione di perdita
-            // printf("output_corretto = %d, previsione: %f\n", output_corretto, funzioni_attivazione[NUM_LAYERS - 1][0]);
-            double gradiente_errore = (output_corretto - funzioni_attivazione[NUM_LAYERS - 1][0]);
-
-            errore_totale += pow(gradiente_errore, 2) * 0.5;
-
-            
-
             // Derivata funzione attivazione
             double derivata_funzione_out = derivata_sigmoide(funzioni_attivazione[NUM_LAYERS - 1][0]);
             // if (derivata_funzione_out == 0.0) derivata_funzione_out = 1;
 
             // Gradiente del percettrone output
-            gradienti[NUM_LAYERS - 1][0] = gradiente_errore * derivata_funzione_out;
+            gradienti[NUM_LAYERS - 1][0] = errore * derivata_funzione_out;
 
             //Crasha nella discesa del gradiente all'immagine indice 16 quando metto troppi percettroni
-            discesa_gradiente(rete_neurale, funzioni_attivazione, gradienti, TIPO_FUNZIONE);
+            discesa_gradiente(rete_neurale, funzioni_attivazione, gradienti, TIPO_FUNZIONE); */
-            
+
-            
+            double **gradienti = discesa_gradiente(rete_neurale, funzioni_attivazione, errore, TIPO_FUNZIONE);
+
+            /*
+                ################# Aggiornamento dei pesi ################################
+            */
+
+            /*
+
+                **** SISTEMARE LA CORREZIONE IN VISTA DELLE ULTIME MODIFICHE PERCHÈ NON CORREGGE E MI SETTA TUTTI I PESI A NAN *****
+
+            */
+
 
-            // A questo punto ho tutti i gradienti dei percettroni, non mi resta che trovare i gradienti dei pesi e correggerli
 
             // Correggo il livello output
-            for (int indice_peso = 0; indice_peso < rete_neurale.layers[NUM_LAYERS - 1].percettroni[0].size; indice_peso++)
+            for (int indice_peso = 0; indice_peso < rete_neurale.layers[rete_neurale.size - 1].percettroni[0].size; indice_peso++)
             {
                 // Determino gradiente del peso
-                double gradiente_peso = gradienti[NUM_LAYERS - 1][0] * funzioni_attivazione[NUM_LAYERS - 2][indice_peso];
+                double gradiente_peso = gradienti[rete_neurale.size - 1][0] * funzioni_attivazione[rete_neurale.size - 2][indice_peso];
-                rete_neurale.layers[NUM_LAYERS - 1].percettroni[0].pesi[indice_peso] += gradiente_peso * LRE;
+                rete_neurale.layers[rete_neurale.size - 1].percettroni[0].pesi[indice_peso] += gradiente_peso * LRE;
             }
-            rete_neurale.layers[NUM_LAYERS - 1].percettroni[0].bias += gradienti[NUM_LAYERS - 1][0] * LRE;
+            rete_neurale.layers[rete_neurale.size - 1].percettroni[0].bias += gradienti[rete_neurale.size - 1][0] * LRE;
 
-            // Applico la correzione dal penultimo layer andando indietro fino al secondo (il primo si fa diverso)
+
+
+
+            /* // Applico la correzione dal penultimo layer andando indietro fino al secondo (il primo si fa diverso)
             for (int indice_layer = NUM_LAYERS - 2; indice_layer >= 0; indice_layer--)
             {
                 // Applico la correzione a tutti i percettroni del layer dal primo a seguire
@@ -121,35 +173,25 @@ void main()
                         correggi_pesi_percettrone_byte(&rete_neurale.layers[0].percettroni[indice_percettrone], set.istanze[indice_set], gradienti[0][indice_percettrone], indice_percettrone);
                     }
                 }
-            }
+            } */
-
-            if (previsione(funzioni_attivazione[NUM_LAYERS - 1][0]) == output_corretto)
-            {
-                corrette++;
-            }
         }
 
-        errore_totale /= 10000;
+        errore_totale /= set.size;
         double percentuale = (corrette * 100) / set.size;
-        printf("Errore: %f, accuratezza: %.2f%\n", errore_totale, percentuale);
+        printf("Errore: %f, accuratezza: %.2f%, corrette: %d\n", errore_totale, percentuale, corrette);
-        // printf("\tRisposte corrette: %d\n", corrette);
 
-        /* if (i == MAX_EPOCHE - 1)
+        // For di debug
+        /* for (int count = 0; count < rete_neurale.size; count++)
         {
-            printf("\nUltima epoca (%d), stato della rete:\n", i);
+            for (int count_2 = 0; count_2 < rete_neurale.layers[count].size; count_2++)
-            double **risultato;
-            for (int j = 0; j < 4; j++)
             {
-                risultato = elabora_funzioni_attivazione(rete_neurale, set.istanze[j]);
+                printf("[%d][%d]: %f\t", count, count_2, gradienti[count][count_2]);
-                printf("Input: [%d,%d] -> probabilità: %f -> previsione: %d -> risultato attesto: %d\n", set.istanze[j].dati[0], set.istanze[j].dati[1], risultato[NUM_LAYERS - 1][0], previsione(risultato[NUM_LAYERS - 1][0]), set.istanze[j].classificazione);
-                for (int k = 0; k < rete_neurale.size; k++)
-                    for (int j = 0; j < rete_neurale.layers[k].size; j++)
-                        printf("sigmoide[%d][%d] = %f\n", k, j, risultato[k][j]);
             }
+            printf("\n");
         } */
     }
 
-    salvaReteNeurale(file_pesi, &rete_neurale);
+    // salvaReteNeurale(file_pesi, &rete_neurale);
 }
 
 // Questa funzione ritorna 1 se la categoria è quella che voglio individuare, altrimenti 0
@@ -181,6 +223,7 @@ void stampa_layer_indirizzo(Layer *layer)
 }
 
 void stampa_tempo(time_t tempo_epoche[], int i)
+
 {
 
     time(&tempo_epoche[i]);
@@ -195,4 +238,23 @@ void stampa_tempo(time_t tempo_epoche[], int i)
         printf("Tempo dall'epoca precedente: %d:%d\n", minuti_epoca, secondi_epoca);
         printf("Tempo dall'inizio: %d:%d\n", minuti_totali, secondi_totali);
     }
-}
+}
+
+void debug(int indice)
+{
+    printf("qui ci arrivo %d", indice);
+}
+
+/* if (i == MAX_EPOCHE - 1)
+        {
+            printf("\nUltima epoca (%d), stato della rete:\n", i);
+            double **risultato;
+            for (int j = 0; j < 4; j++)
+            {
+                risultato = elabora_funzioni_attivazione(rete_neurale, set.istanze[j]);
+                printf("Input: [%d,%d] -> probabilità: %f -> previsione: %d -> risultato attesto: %d\n", set.istanze[j].dati[0], set.istanze[j].dati[1], risultato[NUM_LAYERS - 1][0], previsione(risultato[NUM_LAYERS - 1][0]), set.istanze[j].classificazione);
+                for (int k = 0; k < rete_neurale.size; k++)
+                    for (int j = 0; j < rete_neurale.layers[k].size; j++)
+                        printf("sigmoide[%d][%d] = %f\n", k, j, risultato[k][j]);
+            }
+        } */

mnist/mnist_manager.h

@@ -27,6 +27,7 @@ typedef unsigned char byte;
 // Singola istanza del dataset.
 typedef struct
 {
+    int size;
     byte classificazione;
     byte dati[N_INPUTS];
 } Istanza;
@@ -39,6 +40,8 @@ typedef struct
 } Dataset;
 
 Dataset *get_dataset(char *, char *);
+void salva_dataset(const char*, Dataset*);
+Dataset *carica_dataset(const char*);
 
 // Questo metodo legge il file in questione e restituisce un puntatore a Dataset se il file esiste, altrimenti NULL
 // Ritorna un puntatore perchè in questo caso posso gestire il ritorno NULL.
@@ -64,14 +67,16 @@ Dataset *get_dataset(char *path_mnist, char *path_categoria)
     int numero_righe = 0;
 
     //Leggo male il file, cambiare in base alle dichiarazioni sopra
-    if(fread(istanze[numero_righe].dati, sizeof(byte), 16, file) == 16 && fread(&istanze[numero_righe].classificazione, sizeof(byte), 8, categorie) == 8)
+    if(fread(istanze[numero_righe].dati, sizeof(byte), 16, file) == 16 && fread(&istanze[numero_righe].classificazione, sizeof(byte), 8, categorie) == 8) {
         while (fread(istanze[numero_righe].dati, sizeof(byte), N_INPUTS, file) == N_INPUTS)
         {
             if(fread(&istanze[numero_righe].classificazione, sizeof(byte), 1, categorie) == 1) {
                 numero_righe++;
                 istanze = (Istanza *)realloc(istanze, sizeof(Istanza) * (numero_righe + 1));
+                istanze[numero_righe].size = N_INPUTS;
             }
         }
+    }
 
     // Dataset set;
     (*set).size = numero_righe;
@@ -81,19 +86,19 @@ Dataset *get_dataset(char *path_mnist, char *path_categoria)
 
     //Trasformo tutto in 0 e 1
 
-    /* for(int indice_immagine = 0; indice_immagine < set->size; indice_immagine++) {
+    for(int indice_immagine = 0; indice_immagine < set->size; indice_immagine++) {
         for(int indice_byte = 0; indice_byte < N_INPUTS; indice_byte++) {
             if(set->istanze[indice_immagine].dati[indice_byte] >= 128)
                 set->istanze[indice_immagine].dati[indice_byte] = 1;
             else
                 set->istanze[indice_immagine].dati[indice_byte] = 0;
         }
-    } */
+    }
 
     return set;
 }
 
-/* void salva_dataset(const char *filename, Dataset *set)
+void salva_dataset(const char *filename, Dataset *set)
 {
     FILE *file = fopen(filename, "wb");
     if (!file)
@@ -104,21 +109,76 @@ Dataset *get_dataset(char *path_mnist, char *path_categoria)
 
     for (int indice_istanze = 0; indice_istanze < set->size; indice_istanze++)
     {
-        fwrite(&set->istanze[indice_istanze].classificazione, sizeof(byte), 1, file);
+        if(set->istanze[indice_istanze].classificazione == 7) {
-        fwrite(&set->istanze[indice_istanze].dati, sizeof(byte), N_INPUTS, file);
+            fwrite(&set->istanze[indice_istanze].classificazione, sizeof(byte), 1, file);
+            fwrite(&set->istanze[indice_istanze].dati, sizeof(byte), N_INPUTS, file);
+        }
     }
 
     fclose(file);
-} */
+}
+
+Dataset *carica_dataset(const char *filename) {
+    FILE *file = fopen(filename, "rb");
+    if (!file) {
+        perror("Errore nell'apertura del file");
+        exit(EXIT_FAILURE);
+    }
+
+    // Creazione di un dataset vuoto
+    Dataset *set = (Dataset *)malloc(sizeof(Dataset));
+    if (!set) {
+        perror("Errore nell'allocazione del dataset");
+        fclose(file);
+        exit(EXIT_FAILURE);
+    }
+    set->size = 0;
+    set->istanze = NULL;
+
+    // Variabile temporanea per leggere ogni istanza
+    Istanza temp;
+
+    // Leggi il file fino alla fine
+    while (1) {
+        // Prova a leggere la classificazione
+        size_t letti_classificazione = fread(&temp.classificazione, sizeof(byte), 1, file);
+        // Prova a leggere i dati
+        size_t letti_dati = fread(&temp.dati, sizeof(byte), N_INPUTS, file);
+
+        // Se non riesci a leggere un'intera istanza, esci dal ciclo
+        if (letti_classificazione != 1 || letti_dati != N_INPUTS) {
+            break;
+        }
+
+        // Aumenta la dimensione del dataset
+        set->size++;
+        // Rialloca la memoria per le istanze
+        set->istanze = (Istanza *)realloc(set->istanze, set->size * sizeof(Istanza));
+        if (!set->istanze) {
+            perror("Errore nella riallocazione della memoria");
+            fclose(file);
+            free(set);
+            exit(EXIT_FAILURE);
+        }
+
+        // Aggiungi l'istanza letta al dataset
+        set->istanze[set->size - 1] = temp;
+    }
+
+    fclose(file);
+    return set;
+}
 
 /* void main() {
-    Dataset *set = get_dataset("t10k-images.idx3-ubyte", "t10k-labels.idx1-ubyte");
+    Dataset *set = get_dataset(file_immagini, file_label);
 
     if(set == NULL) {
         printf("Nullo esco\n");
         return;
     }
 
+    salva_dataset("dataset_sette.bin", set);
+
     for(int i = 0; i < set->size; i++) {
         printf("immagine %d - valore rappresentato: %d\n", i, set->istanze[i].classificazione);
     }

percettroni.h

@@ -40,15 +40,20 @@ typedef struct
 } ReteNeurale;
 
 double randomico();
+double *get_double_from_bytes(Istanza);
 
 Percettrone inzializza_percettrone(int);
-ReteNeurale inizializza_rete_neurale(int, int, int);
 Layer inizializza_layer(int, int);
+ReteNeurale inizializza_rete_neurale_deep_feed_forward(int, int, int);
+ReteNeurale inizializza_rete_neurale_feed_forward(int, int, int);
 
-double funzione_attivazione(Percettrone p, double*, int);
+
-double **elabora_funzioni_attivazione(ReteNeurale, Istanza, int);
+double funzione_attivazione_percettrone(Percettrone p, double*, int);
-void discesa_gradiente(ReteNeurale, double **, double **, int);
+double **elabora_funzioni_attivazione(ReteNeurale*, Istanza, int);
-double calcola_gradiente_disceso(ReteNeurale, int, int, double **);
+double *elabora_funzioni_attivazione_layer(Layer, double*, int);
+double **discesa_gradiente(ReteNeurale, double **, double, int);
+double *calcola_gradiente_output(Layer layer, double*, double, int);
+double calcola_gradiente_disceso(ReteNeurale, int, int, double **, double);
 void correggi_pesi_percettrone_double(Percettrone *, int, double **, double);
 void correggi_pesi_percettrone_byte(Percettrone *, Istanza, double, int);
 
@@ -62,7 +67,7 @@ void salvaReteNeurale(const char *, ReteNeurale *);
 ReteNeurale *caricaReteNeurale(const char *);
 
 /*
-    ################# INIZIALIZZAZIONI ################################
+    ################# INIZIALIZZAZIONI E METODI UTILI ################################
 */
 // Questa funzione genera un valore reale random compreso nell'intervallo [-1, 1]
 double randomico()
@@ -101,14 +106,13 @@ Layer inizializza_layer(int n_percettroni, int n_pesi)
     return layer;
 }
 
-ReteNeurale inizializza_rete_neurale(int numero_layers, int numero_percettroni_iniziali, int numero_input)
+ReteNeurale inizializza_rete_neurale_feed_forward(int numero_layers, int numero_percettroni_iniziali, int numero_input) {
-{
     ReteNeurale r;
     r.layers = (Layer *)malloc(sizeof(Layer) * numero_layers);
     r.size = numero_layers;
 
     // Funzione esponenziale inversa layer 5
-    /* for (int livello = 0; livello < numero_layers; livello++)
+    for (int livello = 0; livello < numero_layers; livello++)
     {
         double esponente = (double)livello / (double)numero_layers;
         double frazione = (double)1 / (double)numero_percettroni_iniziali;
@@ -124,7 +128,16 @@ ReteNeurale inizializza_rete_neurale(int numero_layers, int numero_percettroni_i
             r.layers[livello] = inizializza_layer(numero_percettroni_livello, numero_input);
         else
             r.layers[livello] = inizializza_layer(numero_percettroni_livello, r.layers[livello - 1].size);
-    } */
+    }
+
+    return r;
+}
+
+ReteNeurale inizializza_rete_neurale_deep_feed_forward(int numero_layers, int numero_percettroni_iniziali, int numero_input)
+{
+    ReteNeurale r;
+    r.layers = (Layer *)malloc(sizeof(Layer) * numero_layers);
+    r.size = numero_layers;
 
     for (int livello = 0; livello < numero_layers; livello++)
     {
@@ -132,28 +145,35 @@ ReteNeurale inizializza_rete_neurale(int numero_layers, int numero_percettroni_i
             printf("Layer %d -> percettroni: %d\n", livello, numero_percettroni_iniziali);
             r.layers[livello] = inizializza_layer(numero_percettroni_iniziali, numero_input);
         }
-            
         else if(livello < numero_layers -1) {
             printf("Layer %d -> percettroni: %d\n", livello, numero_percettroni_iniziali*2);
             r.layers[livello] = inizializza_layer(numero_percettroni_iniziali * 2, r.layers[livello - 1].size);
         }
-            
         else {
             printf("Layer %d -> percettroni: %d\n", livello, 1);
             r.layers[livello] = inizializza_layer(1, r.layers[livello - 1].size);
         }
-    }
+    }    
 
     return r;
 }
 
+double *get_double_from_bytes(Istanza istanza) {
+    double *inputs = (double *)malloc(sizeof(double *) * istanza.size);
+    for(int i = 0; i < istanza.size; i++) {
+        inputs[i] = (double)istanza.dati[i];
+    }
 
+    return inputs;
+}
 /*
-    ################# PREVISIONI ################################
+    ################# FUNZIONI ATTIVAZIONE ################################
 */
 
+//******************* I PESI SONO TUTTI NAN ********************************
+
 //Tipo 1 = relu, tipo 2 = sigmoide
-double funzione_attivazione(Percettrone p, double *valori, int tipo)
+double funzione_attivazione_percettrone(Percettrone p, double *valori, int tipo)
 {
     double sommatoria = 0.0;
     for (int i = 0; i < p.size; i++) {
@@ -162,7 +182,7 @@ double funzione_attivazione(Percettrone p, double *valori, int tipo)
     }
 
     sommatoria += p.bias;
-    //printf(" sommatoria %f -> %f\n",sommatoria, risultato);
+    //printf(" sommatoria %f\n",sommatoria);
 
     if(tipo == 1)
         return relu(sommatoria);
@@ -178,14 +198,6 @@ double derivata_sigmoide(double valore) {
     return valore * (1.0 - valore);
 }
 
-int previsione(double valore)
-{
-    if (valore >= soglia_sigmoide)
-        return 1;
-    else
-        return 0;
-}
-
 double relu(double valore) {
     if(valore > 0)
         return valore;
@@ -200,14 +212,67 @@ double derivata_relu(double valore) {
     return 0;
 }
 
-void discesa_gradiente(ReteNeurale rete, double **funzioni, double **gradienti, int tipo_derivata)
+
+//tipo_funzione 1: relu, 2:sigmoide
+double **elabora_funzioni_attivazione(ReteNeurale *rete, Istanza istanza, int tipo_funzione)
 {
+    /* for(int xxx = 0; xxx < rete->size; xxx++) {
+        for (int count = 0; count < rete->layers[xxx].size; count++)
+            {
+                for (int count_2 = 0; count_2 < rete->layers[xxx].percettroni[count].size; count_2++)
+                {
+                    printf("[%d][%d]: %f\t", count, count_2, rete->layers[xxx].percettroni[count].pesi[count_2]);
+                }
+                printf("\n");
+            }
+    } */
+
+    //Inizializzo il vettore bidimensionale che dovrò ritornare
+    double **funzioni = (double **)malloc(sizeof(double *) * rete->size);
+
+    //Il primo layer devo farlo a parte perchè prende gli input dal dataset e non dal layer precedente
+    funzioni[0] = elabora_funzioni_attivazione_layer(rete->layers[0], get_double_from_bytes(istanza), tipo_funzione);
+    
+    for(int indice_layer = 1; indice_layer < rete->size - 1; indice_layer ++) {
+        funzioni[indice_layer] = elabora_funzioni_attivazione_layer(rete->layers[indice_layer], funzioni[indice_layer-1], tipo_funzione);   
+    }
+
+    funzioni[rete->size-1] = elabora_funzioni_attivazione_layer(rete->layers[rete->size-1], funzioni[rete->size-2], 2);
+
+    return funzioni;
+}
+
+//DA NAN
+double *elabora_funzioni_attivazione_layer(Layer layer, double *inputs, int tipo_funzione) {
+
+    double *funzioni = (double *)malloc(sizeof(double) * layer.size);
+
+    for(int indice_percettrone = 0; indice_percettrone < layer.size; indice_percettrone ++) {
+        funzioni[indice_percettrone] = funzione_attivazione_percettrone(layer.percettroni[indice_percettrone], inputs, tipo_funzione);
+    }
+
+    return funzioni;
+}
+
+/*
+    ################# RETROPROPAGAZIONE ################################
+*/
+
+double **discesa_gradiente(ReteNeurale rete, double **funzioni, double errore, int tipo_derivata) {
+
+    double **gradienti = (double**)malloc(sizeof(double*) * rete.size);
+
+    //Determino il gradiente di output a parte perchè non prende gradienti discesi dal livello superiore
+    gradienti[rete.size-1] = calcola_gradiente_output(rete.layers[rete.size-1], funzioni[rete.size-1], errore, tipo_derivata);
+
+    //Determino gli altri livelli
     for (int indice_layer = rete.size - 2; indice_layer >= 0; indice_layer--)
     {
+        gradienti[indice_layer] = (double*)malloc(sizeof(double) * rete.layers[indice_layer].size);
+        
         for (int indice_percettrone = 0; indice_percettrone < rete.layers[indice_layer].size; indice_percettrone++)
         {
             //In base al tipo di funzione scelto, avvio relu o sigmoidi
-
             double derivata_attivazione;
 
             if(tipo_derivata == 1)
@@ -215,15 +280,32 @@ void discesa_gradiente(ReteNeurale rete, double **funzioni, double **gradienti,
             else
                 derivata_attivazione = derivata_sigmoide(funzioni[indice_layer][indice_percettrone]);
 
-            // Passo anche l'indice del percettrone perchè corrisponde all'indice del peso del livello sopra
+            gradienti[indice_layer][indice_percettrone] = calcola_gradiente_disceso(rete, indice_layer + 1, indice_percettrone, gradienti, derivata_attivazione);
-            double gradiente_disceso = calcola_gradiente_disceso(rete, indice_layer + 1, indice_percettrone, gradienti);
-
-            gradienti[indice_layer][indice_percettrone] = gradiente_disceso * derivata_attivazione;
         }
     }
+
+    return gradienti;
 }
 
-double calcola_gradiente_disceso(ReteNeurale rete, int livello, int indice_peso, double **gradienti)
+ double *calcola_gradiente_output(Layer layer, double *funzioni, double errore, int tipo_derivata) {
+    
+    double *gradienti = (double*)malloc(sizeof(double) * layer.size);
+
+    //Qui darò per scontato che ci sia un singolo percettrone in uscita, da aggiornare in caso di multipercettrone
+
+    double derivata_funzione;
+
+    if(tipo_derivata == 1)
+        derivata_funzione = derivata_relu(funzioni[0]);
+    else
+        derivata_funzione = derivata_sigmoide(funzioni[0]);
+
+    gradienti[0] = errore * derivata_funzione;
+
+    return gradienti;
+}
+
+double calcola_gradiente_disceso(ReteNeurale rete, int livello, int indice_peso, double **gradienti, double derivata_attivazione)
 {
     // printf("Qui ci arrivo\n");
     double sommatoria = 0.0;
@@ -234,44 +316,42 @@ double calcola_gradiente_disceso(ReteNeurale rete, int livello, int indice_peso,
         sommatoria += (gradienti[livello][indice_peso] * rete.layers[livello].percettroni[indice_percettrone].pesi[indice_peso]);
     }
 
-    return sommatoria;
+    return sommatoria * derivata_attivazione;
-}
-
-//tipo_funzione 1: relu, 2:sigmoide
-double **elabora_funzioni_attivazione(ReteNeurale rete, Istanza istanza, int tipo_funzione)
-{
-
-    double **funzioni = (double **)malloc(sizeof(double *) * rete.size);
-    double *inputs = (double *)malloc(sizeof(double *) * N_INPUTS);
-    for(int i = 0; i < N_INPUTS; i++) {
-        inputs[i] = (double)istanza.dati[i];
-    }
-
-    funzioni[0] = (double *)malloc(sizeof(double) * rete.layers[0].size);
-    for(int indice_percettrone = 0; indice_percettrone < rete.layers[0].size; indice_percettrone ++) {
-        funzioni[0][indice_percettrone] = funzione_attivazione(rete.layers[0].percettroni[indice_percettrone], inputs, tipo_funzione);
-    }
-
-    //Taglio fuori l'ultimo layer perchè in ogni caso sarà sigmoide
-    for(int indice_layer = 1; indice_layer < rete.size; indice_layer ++) {
-        funzioni[indice_layer] = (double *)malloc(sizeof(double) * rete.layers[indice_layer].size);
-        for(int indice_percettrone = 0; indice_percettrone < rete.layers[indice_layer].size; indice_percettrone ++) {
-            //Se è il livello output in ogni caso deve fare sigmoide
-            if(indice_layer == rete.size-1)
-                funzioni[indice_layer][indice_percettrone] = funzione_attivazione(rete.layers[indice_layer].percettroni[indice_percettrone], funzioni[indice_layer-1], 2);
-            else
-                funzioni[indice_layer][indice_percettrone] = funzione_attivazione(rete.layers[indice_layer].percettroni[indice_percettrone], funzioni[indice_layer-1], tipo_funzione);
-        }
-    }
-
-    return funzioni;
 }
 
 
 /*
-    ################# CORREZIONI ################################
+    ################# PREVISIONE E CORREZIONI ################################
 */
 
+void aggiorna_pesi(ReteNeurale *rete_neurale, double **gradienti, double **funzioni_attivazione, Istanza istanza) {
+
+    // Applico la correzione dal penultimo layer andando indietro fino al secondo (il primo si fa diverso)
+    for (int indice_layer = rete_neurale->size - 2; indice_layer >= 0; indice_layer--)
+    {
+        // Applico la correzione a tutti i percettroni del layer dal primo a seguire
+        for (int indice_percettrone = 0; indice_percettrone < rete_neurale.layers[indice_layer].size; indice_percettrone++)
+        {
+            // Devo prendere il gradiente del percettrone e moltiplicarlo con gli input associati ai pesi
+            if (indice_layer != 0)
+            {
+                correggi_pesi_percettrone_double(&rete_neurale.layers[indice_layer].percettroni[indice_percettrone], indice_layer, funzioni_attivazione, gradienti[indice_layer][indice_percettrone]);
+            }
+            else
+            {
+                correggi_pesi_percettrone_byte(&rete_neurale.layers[0].percettroni[indice_percettrone], set.istanze[indice_set], gradienti[0][indice_percettrone], indice_percettrone);
+            }
+        }
+    }
+}
+
+int previsione(double valore)
+{
+    if (valore >= soglia_sigmoide)
+        return 1;
+    else
+        return 0;
+}
 
 void correggi_pesi_percettrone_double(Percettrone *p, int layer, double **input, double gradiente_percettrone)
 {
@@ -304,9 +384,12 @@ void correggi_pesi_percettrone_byte(Percettrone *p, Istanza input, double gradie
 
 
 
+
 /*
     ################# IMPORT EXPORT ################################
 */
+
+
 void salvaReteNeurale(const char *filename, ReteNeurale *rete)
 {
     FILE *file = fopen(filename, "wb");
@@ -402,7 +485,14 @@ ReteNeurale *caricaReteNeurale(const char *filename)
 
 
 
-
+/* funzioni[indice_layer] = (double *)malloc(sizeof(double) * rete.layers[indice_layer].size);
+        for(int indice_percettrone = 0; indice_percettrone < rete.layers[indice_layer].size; indice_percettrone ++) {
+            //Se è il livello output in ogni caso deve fare sigmoide
+            if(indice_layer == rete.size-1)
+                funzioni[indice_layer][indice_percettrone] = funzione_attivazione(rete.layers[indice_layer].percettroni[indice_percettrone], funzioni[indice_layer-1], 2);
+            else
+                funzioni[indice_layer][indice_percettrone] = funzione_attivazione(rete.layers[indice_layer].percettroni[indice_percettrone], funzioni[indice_layer-1], tipo_funzione);
+        } */
 
 /* double sigmoide_byte(Percettrone, byte *, int);
 double sigmoide_double(Percettrone, double *, int);
@@ -520,4 +610,27 @@ double sigmoide_double(Percettrone p, double *valori, int n_input)
 
     return risultato;
 }
- */
+ */
+
+
+//void discesa_gradiente(ReteNeurale, double **, double **, int);
+/* void discesa_gradiente(ReteNeurale rete, double **funzioni, double **gradienti, int tipo_derivata)
+{
+    for (int indice_layer = rete.size - 2; indice_layer >= 0; indice_layer--)
+    {
+        for (int indice_percettrone = 0; indice_percettrone < rete.layers[indice_layer].size; indice_percettrone++)
+        {
+            //In base al tipo di funzione scelto, avvio relu o sigmoidi
+
+            double derivata_attivazione;
+
+            if(tipo_derivata == 1)
+                derivata_attivazione = derivata_relu(funzioni[indice_layer][indice_percettrone]);
+            else
+                derivata_attivazione = derivata_sigmoide(funzioni[indice_layer][indice_percettrone]);
+
+            // Passo anche l'indice del percettrone perchè corrisponde all'indice del peso del livello sopra
+            gradienti[indice_layer][indice_percettrone] = calcola_gradiente_disceso(rete, indice_layer + 1, indice_percettrone, gradienti, derivata_attivazione);
+        }
+    }
+} */

visualizzatore.c

@@ -49,16 +49,16 @@ void main()
     free(set_appoggio);
     free(rete_appoggio);
 
-    //Trasformo tutto in 0 e 1
+    //Trasformo tutto in 0 e 255
 
-    /* for(int indice_immagine = 0; indice_immagine < set.size; indice_immagine++) {
+    for(int indice_immagine = 0; indice_immagine < set.size; indice_immagine++) {
         for(int indice_byte = 0; indice_byte < N_INPUTS; indice_byte++) {
             if(set.istanze[indice_immagine].dati[indice_byte] == 0)
                 set.istanze[indice_immagine].dati[indice_byte] = 0;
             else
                 set.istanze[indice_immagine].dati[indice_byte] = 255;
         }
-    } */
+    }
 
     int indice_set = rand() % set.size;