diff --git a/classificatore_singolo b/classificatore_singolo
index fc5b2c1..0719ddb 100755
Binary files a/classificatore_singolo and b/classificatore_singolo differ
diff --git a/classificatore_singolo.c b/classificatore_singolo.c
index 69ff035..15edcbf 100644
--- a/classificatore_singolo.c
+++ b/classificatore_singolo.c
@@ -6,8 +6,8 @@
 
 //Scelgo quale categoria voglio identificare. nel caso dello xor -1
 #define CATEGORIA -1
-#define NUM_LAYERS 5
-#define PERCETTRONI_LAYER_0 256
+#define NUM_LAYERS 2
+#define PERCETTRONI_LAYER_0 2
 #define MAX_EPOCHE 10000
 
 byte get_out_corretto(byte);
@@ -40,39 +40,56 @@ void main() {
 
     //ADDESTRAMENTO
     for(int i = 0; i < MAX_EPOCHE; i++) {
-        
-        printf("Epoca %d\n", i);
-        stampa_tempo(tempo_epoche, i);
+    
+        //printf("Epoca %d\n", i);
+        //stampa_tempo(tempo_epoche, i);
         int corrette = 0;
+        double errore_totale = 0.0;
 
         for(int indice_set = 0; indice_set < set.size; indice_set++) {
 
+            //sigmoidi è un array bidimensionale, la prima dimensione identifica il layer, la seconda il percettrone nel layer
+            // sigmoidi[indice_layer][indice_percettrone]
             double **sigmoidi = (double **)malloc(sizeof(double*) * NUM_LAYERS);
 
+            //Il layer di ingresso ha bisogno di una funzione a parte perchè prende byte come input
             sigmoidi[0] = (double*)malloc(sizeof(double) * PERCETTRONI_LAYER_0);
             sigmoidi[0] = funzioni_attivazione_layer_byte(rete_neurale.layers[0], set.istanze[indice_set].dati);
             
+            //Calcolo le sigmoidi in tutti gli altri layer
             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]);
             }
 
+            
             byte output_corretto = get_out_corretto(set.istanze[indice_set].classificazione);
 
-            printf("Inputs: %d %d\t", set.istanze[indice_set].dati[0], set.istanze[indice_set].dati[1]);
-            printf("Previsione: %d, out corretto: %d\n", previsione(sigmoidi[NUM_LAYERS-1][0]), output_corretto);
 
             //Se prevede male
             if(previsione(sigmoidi[NUM_LAYERS-1][0]) != output_corretto) {
 
+                //gradienti è un array bidimensionale, la prima dimensione identifica il layer, la seconda il percettrone nel layer
+                //gradienti[indice_layer][indice_percettrone]
                 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++) {
                     gradienti[indice_layer] = (double*)malloc(sizeof(double) * rete_neurale.layers[indice_layer].size);
                 }
 
-                //Errore
+                /*  Gestione dell'errore
+                    Funzione di perdita -> errore quadratico medio: (risultato_esatto - previsione)^2
+                    Gradiente dell'errore rispetto all'attivazione = derivata(funzione_perdita) * derivata(sigmoide_out)
+                                                                   = -(risultato_esatto - previsione) * (sigmoide_out * (1 - sigmoide_out))
+                    
+                    //Per ogni percettrone sugli altri layer:
+                    - calcolare derivata della propria sigmoide
+                    - gradiente dell'errore retropropagato = peso del ne
+                    
+                */
                 gradienti[NUM_LAYERS-1][0] = (output_corretto - sigmoidi[NUM_LAYERS-1][0]);
+                errore_totale += gradienti[NUM_LAYERS-1][0];
 
                 correggi_layer_interni(&rete_neurale, gradienti, sigmoidi);
                 correggi_layer_input(&rete_neurale.layers[0], gradienti, sigmoidi, set.istanze[indice_set].dati, NUM_LAYERS);
@@ -81,9 +98,16 @@ void main() {
             {
                 corrette++;
             }
+
+            if(corrette == 4) {
+                printf("\tConvergo all'epoca %d\n", i);
+                break;
+            }
         }
+
+        printf("Errore: %f\n", errore_totale);
         
-        printf("\tRisposte corrette: %d\n", corrette);
+        //printf("\tRisposte corrette: %d\n", corrette);
 
         if(corrette == set.size) {
             break;
diff --git a/percettroni.h b/percettroni.h
index 9943596..4012f68 100644
--- a/percettroni.h
+++ b/percettroni.h
@@ -52,15 +52,17 @@ ReteNeurale *caricaReteNeurale(const char*);
 //Questa funzione genera un valore reale random compreso nell'intervallo [-1, 1]
 double randomico() {
     // Genero numeri nell'intervallo [-1,1]
-    return (double)((rand() / RAND_MAX) * -1);//((double)(rand() % 101 * 0.01 * 2 ) -1);
+    return ((double)(rand() % 101 * 0.01 * 2 ) -1);
 }
 
 //Questa funzione inizializza il percettrone allocando la memoria in base al numero dei pesi che voglio ed inizializza il loro valore usando randomico()
 Percettrone inizializza_percettrone(int n_pesi) {
     Percettrone p;
     p.pesi = (double*) malloc(sizeof(double) * n_pesi);
-    for(int i = 0; i < n_pesi; i++)
+    for(int i = 0; i < n_pesi; i++) {
         p.pesi[i] = randomico();
+        //printf("peso[%d]: %f\n",i, p.pesi[i]);
+    }
 
     p.bias = randomico();
 
@@ -113,6 +115,7 @@ Layer inizializza_layer(int n_percettroni, int n_pesi) {
 
     for(int i = 0; i < n_percettroni; i++) {
         layer.percettroni[i] = inizializza_percettrone(n_pesi);
+
     }
 
     layer.size = n_percettroni;
@@ -124,8 +127,11 @@ Layer inizializza_layer(int n_percettroni, int n_pesi) {
 double sigmoide_byte(Percettrone p, byte *valori, int n_input) {
     
     double sommatoria = 0.0;
+    //printf("valori: [%d][%d]", valori[0], valori[1]);
+    //printf("pesi: [%f][%f]", p.pesi[0], p.pesi[1]);
+
     for(int i = 0; i < n_input; i++) {
-        sommatoria += ((double)valori[i] * p.pesi[i]);
+        sommatoria += (valori[i] * p.pesi[i]);
     }
     //printf("sommatoria= %f\n", sommatoria);
     double funzione = sommatoria + p.bias;
@@ -196,9 +202,9 @@ void correggi_layer_interni(ReteNeurale *rete, double **gradienti, double **sigm
         for(int indice_percettrone = 0; indice_percettrone < rete->layers[indice_layer].size; indice_percettrone++) {//Numero percettroni
 
             for(int indice_peso = 0; indice_peso < rete->layers[indice_layer].percettroni[indice_percettrone].size; indice_peso++) {//Numero pesi
-                //gradienti[indice_layer][indice_percettrone] = gradienti[rete->size-1][0] * (sigmoidi[indice_layer][indice_percettrone] * (1 - sigmoidi[indice_layer][indice_percettrone]));
-                //rete->layers[indice_layer].percettroni[indice_percettrone].pesi[indice_peso] += (gradienti[indice_layer][indice_percettrone] * LRE * sigmoidi[indice_layer-1][indice_percettrone]);           
-                rete->layers[indice_layer].percettroni[indice_percettrone].pesi[indice_peso] += (gradienti[rete->size-1][0] * LRE * sigmoidi[indice_layer-1][indice_percettrone]);
+                gradienti[indice_layer][indice_percettrone] = gradienti[rete->size-1][0] * (sigmoidi[indice_layer][indice_percettrone] * (1 - sigmoidi[indice_layer][indice_percettrone]));
+                rete->layers[indice_layer].percettroni[indice_percettrone].pesi[indice_peso] += (gradienti[indice_layer][indice_percettrone] * LRE * sigmoidi[indice_layer-1][indice_percettrone]);           
+                //rete->layers[indice_layer].percettroni[indice_percettrone].pesi[indice_peso] += (gradienti[rete->size-1][0] * LRE * sigmoidi[indice_layer-1][indice_percettrone]);
             }
             rete->layers[indice_layer].percettroni[indice_percettrone].bias += (gradienti[indice_layer][indice_percettrone] * LRE);
             //printf("bias: %f\n", rete->layers[indice_layer].percettroni[indice_percettrone].bias);
@@ -213,9 +219,9 @@ void correggi_layer_input(Layer *layer, double **gradienti, double **sigmoidi, b
     for(int indice_percettrone = 0; indice_percettrone < layer->size; indice_percettrone++) {//Numero percettroni
         for(int indice_peso = 0; indice_peso < layer->percettroni->size; indice_peso++) { //Numero pesi
 
-            //gradienti[indice_layer][indice_percettrone] = gradienti[n_layers-1][0] * (sigmoidi[indice_layer][indice_percettrone] * (1 - sigmoidi[indice_layer][indice_percettrone]));
-            //layer->percettroni[indice_percettrone].pesi[indice_peso] += (gradienti[indice_layer][indice_percettrone] * LRE * inputs[indice_peso]);
-            layer->percettroni[indice_percettrone].pesi[indice_peso] += (gradienti[n_layers-1][0] * LRE * inputs[indice_peso]);
+            gradienti[indice_layer][indice_percettrone] = gradienti[n_layers-1][0] * (sigmoidi[indice_layer][indice_percettrone] * (1 - sigmoidi[indice_layer][indice_percettrone]));
+            layer->percettroni[indice_percettrone].pesi[indice_peso] += (gradienti[indice_layer][indice_percettrone] * LRE * inputs[indice_peso]);
+            //layer->percettroni[indice_percettrone].pesi[indice_peso] += (gradienti[n_layers-1][0] * LRE * inputs[indice_peso]);
         }
         layer->percettroni[indice_percettrone].bias += (gradienti[n_layers-1][0] * LRE);
     }
diff --git a/tempCodeRunnerFile.c b/tempCodeRunnerFile.c
new file mode 100644
index 0000000..da3cc5d
--- /dev/null
+++ b/tempCodeRunnerFile.c
@@ -0,0 +1,3 @@
+for(int indice_percettrone = 0; indice_percettrone < PERCETTRONI_LAYER_0; indice_percettrone++) {
+                printf("percettrone %d -> sigmoide: %f\n", indice_percettrone, sigmoidi[0][indice_percettrone]);
+            }
\ No newline at end of file