From b8c5b82f7291bc1ef4fea6e81fc12e72cd016203 Mon Sep 17 00:00:00 2001
From: mirimatcode <mirimatcode@gmail.com>
Date: Mon, 24 Feb 2025 09:39:47 +0100
Subject: [PATCH] la discesa del gradiente porta i gradienti a nan e in seguito
 tutti i pesi

---
 classificatore_singolo   | Bin 25952 -> 25928 bytes
 classificatore_singolo.c |   6 ++--
 percettroni.h            |  71 ++++++++++++++++++++++++++++++---------
 3 files changed, 58 insertions(+), 19 deletions(-)

diff --git a/classificatore_singolo b/classificatore_singolo
index 2cb26d7d11e503af47e744246b3aef4404d66619..f80924325f7a08c254efbfd1ca72bc50812fd473 100755
GIT binary patch
delta 3838
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
VX<>Vbl@ASkZ@NMDq55Yc{souc2{Qly

delta 3688
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
S3WrS2L0{!e(gyKWN&f?{y4vCZ

diff --git a/classificatore_singolo.c b/classificatore_singolo.c
index 46f2d36..c85c9c2 100644
--- a/classificatore_singolo.c
+++ b/classificatore_singolo.c
@@ -144,16 +144,16 @@ void main()
             */
 
 
+            aggiorna_pesi(rete_neurale, gradienti, funzioni_attivazione, set.istanze[indice_set]);
 
             // Correggo il livello output
-            for (int indice_peso = 0; indice_peso < rete_neurale.layers[rete_neurale.size - 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[rete_neurale.size - 1][0] * funzioni_attivazione[rete_neurale.size - 2][indice_peso];
                 rete_neurale.layers[rete_neurale.size - 1].percettroni[0].pesi[indice_peso] += gradiente_peso * LRE;
             }
-            rete_neurale.layers[rete_neurale.size - 1].percettroni[0].bias += gradienti[rete_neurale.size - 1][0] * LRE;
-
+            rete_neurale.layers[rete_neurale.size - 1].percettroni[0].bias += gradienti[rete_neurale.size - 1][0] * LRE; */
 
 
 
diff --git a/percettroni.h b/percettroni.h
index 36dec8e..219fd53 100644
--- a/percettroni.h
+++ b/percettroni.h
@@ -53,9 +53,10 @@ double **elabora_funzioni_attivazione(ReteNeurale*, Istanza, int);
 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);
+double calcola_gradiente_disceso(ReteNeurale, int, int, double**, double);
+void aggiorna_pesi(ReteNeurale, double**, double**, Istanza);
+void correggi_pesi_percettrone(Percettrone, double*, double);
+//void correggi_pesi_percettrone_byte(Percettrone*, Istanza, double, int);
 
 int previsione(double);
 double sigmoide(double);
@@ -258,6 +259,8 @@ double *elabora_funzioni_attivazione_layer(Layer layer, double *inputs, int tipo
     ################# RETROPROPAGAZIONE ################################
 */
 
+NON CALCOLA I GRADIENTI, PARTE DIRETTAMENTE NAN, VERIFICARE LA PRESENZA DI DATI IN FUNZIONI E LE FUNZIONI DI CALCOLO
+
 double **discesa_gradiente(ReteNeurale rete, double **funzioni, double errore, int tipo_derivata) {
 
     double **gradienti = (double**)malloc(sizeof(double*) * rete.size);
@@ -265,6 +268,8 @@ double **discesa_gradiente(ReteNeurale rete, double **funzioni, double errore, i
     //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);
 
+    //printf("grad di testa %f, size %d\n", gradienti[rete.size-1][0], rete.size);
+
     //Determino gli altri livelli
     for (int indice_layer = rete.size - 2; indice_layer >= 0; indice_layer--)
     {
@@ -280,10 +285,21 @@ double **discesa_gradiente(ReteNeurale rete, double **funzioni, double errore, i
             else
                 derivata_attivazione = derivata_sigmoide(funzioni[indice_layer][indice_percettrone]);
 
+           // printf("derivata: %f, gradiente_disceso %f\n", derivata_attivazione, calcola_gradiente_disceso(rete, indice_layer + 1, indice_percettrone, gradienti, derivata_attivazione));
+
             gradienti[indice_layer][indice_percettrone] = calcola_gradiente_disceso(rete, indice_layer + 1, indice_percettrone, gradienti, derivata_attivazione);
         }
     }
 
+    /* for (int count = 0; count < rete.size; count++)
+        {
+            for (int count_2 = 0; count_2 < rete.layers[count].size; count_2++)
+            {
+                printf("[%d][%d]: %f\t", count, count_2, gradienti[count][count_2]);
+            }
+            printf("\n");
+        } */
+
     return gradienti;
 }
 
@@ -324,24 +340,38 @@ double calcola_gradiente_disceso(ReteNeurale rete, int livello, int indice_peso,
     ################# PREVISIONE E CORREZIONI ################################
 */
 
-void aggiorna_pesi(ReteNeurale *rete_neurale, double **gradienti, double **funzioni_attivazione, Istanza istanza) {
+void aggiorna_pesi(ReteNeurale rete_neurale, double **gradienti, double **funzioni_attivazione, Istanza istanza) {
+
+    /* 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");
+                }
+            } */
 
     // 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--)
+    for (int indice_layer = rete_neurale.size - 1; 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)
+            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]);
+                //printf(" [%d][%d]: %f ", indice_layer, indice_percettrone, gradienti[indice_layer][indice_percettrone]);
+                correggi_pesi_percettrone(rete_neurale.layers[indice_layer].percettroni[indice_percettrone], funzioni_attivazione[indice_layer-1], 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);
+                correggi_pesi_percettrone(rete_neurale.layers[indice_layer].percettroni[indice_percettrone], get_double_from_bytes(istanza), gradienti[indice_layer][indice_percettrone]);
             }
         }
+        //printf("\n");
     }
 }
 
@@ -353,22 +383,31 @@ int previsione(double valore)
         return 0;
 }
 
-void correggi_pesi_percettrone_double(Percettrone *p, int layer, double **input, double gradiente_percettrone)
-{
+/*
+    Al secondo giro diventa NAN
+*/
 
-    for (int indice_peso = 0; indice_peso < p->size; indice_peso++)
+void correggi_pesi_percettrone(Percettrone p, double *input, double gradiente_percettrone)
+{
+    //printf("grad_perc: %f", gradiente_percettrone);
+    for (int indice_peso = 0; indice_peso < p.size; indice_peso++)
     {
+        
         // Determino il gradiente del peso
-        double gradiente_peso = gradiente_percettrone * input[layer - 1][indice_peso];
+        double gradiente_peso = gradiente_percettrone * input[indice_peso];
+
+        //printf("indice[%d], gradiente percettrone %f, gradiente peso %f ", indice_peso, gradiente_percettrone, gradiente_peso);
 
         // Modifico il peso
-        p->pesi[indice_peso] += (gradiente_peso * LRE);
+        p.pesi[indice_peso] += (gradiente_peso * LRE);
+        
     }
 
-    p->bias += (gradiente_percettrone * LRE);
+    p.bias += (gradiente_percettrone * LRE);
+    //printf("\n");
 }
 
-void correggi_pesi_percettrone_byte(Percettrone *p, Istanza input, double gradiente_percettrone, int indice_percettrone)
+/* void correggi_pesi_percettrone_byte(Percettrone *p, Istanza input, double gradiente_percettrone, int indice_percettrone)
 {
     for (int indice_peso = 0; indice_peso < p->size; indice_peso++)
     {
@@ -380,7 +419,7 @@ void correggi_pesi_percettrone_byte(Percettrone *p, Istanza input, double gradie
     }
 
     p->bias += (gradiente_percettrone * LRE);
-}
+} */