messo due codici da deepseek, per classificare il singolo e il multi classe

classificatore_singolo.c

@@ -3,8 +3,8 @@
 
 // Scelgo quale categoria voglio identificare. nel caso dello xor -1
 #define CATEGORIA 7
-#define NUM_LAYERS 4
+#define NUM_LAYERS 7
-#define PERCETTRONI_LAYER_0 32
+#define PERCETTRONI_LAYER_0 128
 #define MAX_EPOCHE 10
 
 byte get_out_corretto(byte);
@@ -37,7 +37,6 @@ void main()
         printf("Caricate impostazioni rete neurale da file\n");
     }
 
-    //rete_neurale = inizializza_rete_neurale(NUM_LAYERS, PERCETTRONI_LAYER_0, N_INPUTS);
     int corrette = 0;
 
     printf("Numero elementi nel dataset: %d\n", set.size);
@@ -45,7 +44,6 @@ void main()
     // ADDESTRAMENTO
     for (int i = 0; i < MAX_EPOCHE; i++)
     {
-
         printf("Epoca %d\n", i);
         stampa_tempo(tempo_epoche, i);
         corrette = 0;
@@ -53,61 +51,20 @@ void main()
         
         for (int indice_set = 0; indice_set < set.size; indice_set++)
         {
-            //printf("Qui ci arrivo %d\n", indice_set);
             double **sigmoidi = elabora_sigmoidi(rete_neurale, set.istanze[indice_set]);
 
             byte output_corretto = get_out_corretto(set.istanze[indice_set].classificazione);
-            if (previsione(sigmoidi[NUM_LAYERS - 1][0]) == output_corretto)
+            if (previsione(sigmoidi[rete_neurale.size - 1][0]) == output_corretto)
                 corrette++;
 
-            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);
-            }
-
             // Derivata funzione di perdita
-            double gradiente_errore = (output_corretto - sigmoidi[NUM_LAYERS - 1][0]);
+            double gradiente_errore = (output_corretto - sigmoidi[rete_neurale.size - 1][0]);
             errore_totale += pow(gradiente_errore, 2);
 
-            // Derivata funzione attivazione
+            double **gradienti = elabora_gradienti(rete_neurale, gradiente_errore, sigmoidi);
-            double derivata_sigmoide_out = sigmoidi[NUM_LAYERS - 1][0] * (1.0 - sigmoidi[NUM_LAYERS - 1][0]);
 
-            // Gradiente del percettrone output
+            aggiorna_pesi(&rete_neurale, sigmoidi, gradienti, set.istanze[indice_set]);
-            gradienti[NUM_LAYERS - 1][0] = gradiente_errore * derivata_sigmoide_out;
 
-            discesa_gradiente(rete_neurale, sigmoidi, gradienti);
-
-            // 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++)
-            {
-                // Determino gradiente del peso
-                double gradiente_peso = gradienti[NUM_LAYERS - 1][0] * sigmoidi[NUM_LAYERS - 2][indice_peso];
-                rete_neurale.layers[NUM_LAYERS - 1].percettroni[0].pesi[indice_peso] += gradiente_peso * LRE;
-            }
-            rete_neurale.layers[NUM_LAYERS - 1].percettroni[0].bias += gradienti[NUM_LAYERS - 1][0] * LRE;
-
-            // 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
-                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, sigmoidi, 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);
-                    }
-                }
-            }
         }
 
         printf("Errore: %f, risposte corrette: %d%\n", errore_totale / set.size, (corrette * 100) / set.size);

deep_seek.c

@@ -0,0 +1,304 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <math.h>
+#include "cifar-10/cifar10_manager.h"
+
+// Costanti configurabili
+#define N_LAYERS 3                // Numero di layer (input, hidden, output)
+#define N_NEURONI_HIDDEN 128      // Numero di neuroni nei layer nascosti
+#define N_NEURONI_OUTPUT 10       // Numero di neuroni nel layer di output (10 classi)
+#define N_EPOCHE 10               // Numero di epoche di addestramento
+#define LEARNING_RATE 0.01        // Tasso di apprendimento
+#define N_INPUTS 3072             // Dimensioni di un'immagine CIFAR-10 (32x32x3)
+
+// Strutture dati
+/* typedef unsigned char byte;
+
+typedef struct {
+    byte classificazione;
+    byte dati[N_INPUTS];
+} Istanza;
+
+typedef struct {
+    int size;
+    Istanza *istanze;
+} Dataset; */
+
+typedef struct {
+    double *pesi;
+    double bias;
+    int size;
+} Percettrone;
+
+typedef struct {
+    Percettrone *percettroni;
+    int size;
+} Layer;
+
+typedef struct {
+    Layer *layers;
+    int size;
+} ReteNeurale;
+
+double sigmoide(double);
+double relu(double);
+double relu_derivata(double);
+double softmax(double*, int, int);
+ReteNeurale crea_rete();
+double *prevedi(ReteNeurale*, byte*);
+void allena(ReteNeurale*, Dataset*);
+void salva_rete(ReteNeurale*, const char*);
+ReteNeurale carica_rete(const char*);
+void carica_immagini_casuali(Dataset*, byte[][N_INPUTS], byte*);
+void fai_previsioni(ReteNeurale*, byte[][N_INPUTS], byte*);
+void backpropagation(ReteNeurale*, byte*, byte, double*);
+double *forward_pass(ReteNeurale*, byte*);
+
+// Funzioni di utilità
+double sigmoide(double x) {
+    return 1.0 / (1.0 + exp(-x));
+}
+
+double relu(double x) {
+    return x > 0 ? x : 0;
+}
+
+double relu_derivata(double x) {
+    return x > 0 ? 1 : 0;
+}
+
+double softmax(double *x, int index, int size) {
+    double max = x[0];
+    for (int i = 1; i < size; i++) {
+        if (x[i] > max) max = x[i];
+    }
+    double sum = 0.0;
+    for (int i = 0; i < size; i++) {
+        sum += exp(x[i] - max);
+    }
+    return exp(x[index] - max) / sum;
+}
+
+// Inizializzazione della rete
+ReteNeurale crea_rete() {
+    ReteNeurale rete;
+    rete.size = N_LAYERS;
+    rete.layers = (Layer *)malloc(N_LAYERS * sizeof(Layer));
+
+    // Layer di input (non ha pesi, solo pass-through)
+    rete.layers[0].size = N_INPUTS;
+    rete.layers[0].percettroni = NULL;
+
+    // Layer nascosto
+    rete.layers[1].size = N_NEURONI_HIDDEN;
+    rete.layers[1].percettroni = (Percettrone *)malloc(N_NEURONI_HIDDEN * sizeof(Percettrone));
+    for (int i = 0; i < N_NEURONI_HIDDEN; i++) {
+        rete.layers[1].percettroni[i].size = N_INPUTS;
+        rete.layers[1].percettroni[i].pesi = (double *)malloc(N_INPUTS * sizeof(double));
+        for (int j = 0; j < N_INPUTS; j++) {
+            rete.layers[1].percettroni[i].pesi[j] = ((double)rand() / RAND_MAX) * 2 - 1; // Pesi casuali tra -1 e 1
+        }
+        rete.layers[1].percettroni[i].bias = ((double)rand() / RAND_MAX) * 2 - 1; // Bias casuale tra -1 e 1
+    }
+
+    // Layer di output
+    rete.layers[2].size = N_NEURONI_OUTPUT;
+    rete.layers[2].percettroni = (Percettrone *)malloc(N_NEURONI_OUTPUT * sizeof(Percettrone));
+    for (int i = 0; i < N_NEURONI_OUTPUT; i++) {
+        rete.layers[2].percettroni[i].size = N_NEURONI_HIDDEN;
+        rete.layers[2].percettroni[i].pesi = (double *)malloc(N_NEURONI_HIDDEN * sizeof(double));
+        for (int j = 0; j < N_NEURONI_HIDDEN; j++) {
+            rete.layers[2].percettroni[i].pesi[j] = ((double)rand() / RAND_MAX) * 2 - 1; // Pesi casuali tra -1 e 1
+        }
+        rete.layers[2].percettroni[i].bias = ((double)rand() / RAND_MAX) * 2 - 1; // Bias casuale tra -1 e 1
+    }
+
+    return rete;
+}
+
+// Funzione per la previsione
+double *prevedi(ReteNeurale *rete, byte *input) {
+    double *output = (double *)malloc(N_NEURONI_OUTPUT * sizeof(double));
+    // Implementazione del forward pass
+    // (Da completare)
+    return output;
+}
+
+// Funzione per l'addestramento
+void allena(ReteNeurale *rete, Dataset *dataset) {
+    printf("Sono dentro l'allenamento\n");
+    for (int epoca = 0; epoca < N_EPOCHE; epoca++) {
+        printf("Epoca %d\n", epoca);
+        for (int i = 0; i < dataset->size; i++) {
+            byte *input = dataset->istanze[i].dati;
+            byte target = dataset->istanze[i].classificazione;
+
+            // Forward pass
+            double *output_final = forward_pass(rete, input);
+
+            // Backpropagation
+            backpropagation(rete, input, target, output_final);
+
+            free(output_final);
+        }
+    }
+}
+
+// Forward pass
+double *forward_pass(ReteNeurale *rete, byte *input) {
+    double *output_hidden = (double *)malloc(N_NEURONI_HIDDEN * sizeof(double));
+    double *output_final = (double *)malloc(N_NEURONI_OUTPUT * sizeof(double));
+
+    // Layer nascosto
+    for (int i = 0; i < N_NEURONI_HIDDEN; i++) {
+        double somma = 0.0;
+        for (int j = 0; j < N_INPUTS; j++) {
+            somma += input[j] * rete->layers[1].percettroni[i].pesi[j];
+        }
+        somma += rete->layers[1].percettroni[i].bias;
+        output_hidden[i] = relu(somma); // Applica ReLU
+    }
+
+    // Layer di output
+    for (int i = 0; i < N_NEURONI_OUTPUT; i++) {
+        double somma = 0.0;
+        for (int j = 0; j < N_NEURONI_HIDDEN; j++) {
+            somma += output_hidden[j] * rete->layers[2].percettroni[i].pesi[j];
+        }
+        somma += rete->layers[2].percettroni[i].bias;
+        output_final[i] = somma; // Non applica softmax qui, verrà fatto durante la loss
+    }
+
+    free(output_hidden);
+    return output_final;
+}
+
+// Backpropagation
+void backpropagation(ReteNeurale *rete, byte *input, byte target, double *output_final) {
+    // Calcola la softmax e la loss (cross-entropy)
+    double softmax_output[N_NEURONI_OUTPUT];
+    double sum_exp = 0.0;
+    for (int i = 0; i < N_NEURONI_OUTPUT; i++) {
+        sum_exp += exp(output_final[i]);
+    }
+    for (int i = 0; i < N_NEURONI_OUTPUT; i++) {
+        softmax_output[i] = exp(output_final[i]) / sum_exp;
+    }
+
+    // Gradiente della loss rispetto all'output
+    double grad_output[N_NEURONI_OUTPUT];
+    for (int i = 0; i < N_NEURONI_OUTPUT; i++) {
+        grad_output[i] = softmax_output[i] - (i == target ? 1 : 0);
+    }
+
+    // Gradiente rispetto ai pesi e bias del layer di output
+    for (int i = 0; i < N_NEURONI_OUTPUT; i++) {
+        for (int j = 0; j < N_NEURONI_HIDDEN; j++) {
+            rete->layers[2].percettroni[i].pesi[j] -= LEARNING_RATE * grad_output[i] * output_final[j];
+        }
+        rete->layers[2].percettroni[i].bias -= LEARNING_RATE * grad_output[i];
+    }
+
+    // Gradiente rispetto ai pesi e bias del layer nascosto
+    double grad_hidden[N_NEURONI_HIDDEN];
+    for (int j = 0; j < N_NEURONI_HIDDEN; j++) {
+        grad_hidden[j] = 0.0;
+        for (int i = 0; i < N_NEURONI_OUTPUT; i++) {
+            grad_hidden[j] += grad_output[i] * rete->layers[2].percettroni[i].pesi[j];
+        }
+        grad_hidden[j] *= relu_derivata(output_final[j]); // Derivata di ReLU
+    }
+
+    for (int j = 0; j < N_NEURONI_HIDDEN; j++) {
+        for (int k = 0; k < N_INPUTS; k++) {
+            rete->layers[1].percettroni[j].pesi[k] -= LEARNING_RATE * grad_hidden[j] * input[k];
+        }
+        rete->layers[1].percettroni[j].bias -= LEARNING_RATE * grad_hidden[j];
+    }
+}
+
+// Serializzazione della rete
+void salva_rete(ReteNeurale *rete, const char *filename) {
+    FILE *file = fopen(filename, "wb");
+    if (file == NULL) {
+        perror("Errore nell'apertura del file");
+        return;
+    }
+    fwrite(rete, sizeof(ReteNeurale), 1, file);
+    fclose(file);
+}
+
+// Deserializzazione della rete
+ReteNeurale carica_rete(const char *filename) {
+    FILE *file = fopen(filename, "rb");
+    if (file == NULL) {
+        perror("Errore nell'apertura del file");
+        exit(1);
+    }
+    ReteNeurale rete;
+    fread(&rete, sizeof(ReteNeurale), 1, file);
+    fclose(file);
+    return rete;
+}
+
+// Funzione per caricare 4 immagini casuali dal dataset
+void carica_immagini_casuali(Dataset *dataset, byte immagini[4][N_INPUTS], byte *etichette) {
+    for (int i = 0; i < 4; i++) {
+        int indice_casuale = rand() % dataset->size; // Sceglie un'immagine casuale
+        for (int j = 0; j < N_INPUTS; j++) {
+            immagini[i][j] = dataset->istanze[indice_casuale].dati[j]; // Copia i dati dell'immagine
+        }
+        etichette[i] = dataset->istanze[indice_casuale].classificazione; // Copia l'etichetta
+    }
+}
+
+// Funzione per fare previsioni su 4 immagini
+void fai_previsioni(ReteNeurale *rete, byte immagini[4][N_INPUTS], byte *etichette) {
+    for (int i = 0; i < 4; i++) {
+        double *output = prevedi(rete, immagini[i]); // Passa l'immagine attraverso la rete
+        int previsione = 0;
+        double max_prob = output[0];
+        for (int j = 1; j < N_NEURONI_OUTPUT; j++) {
+            if (output[j] > max_prob) {
+                max_prob = output[j];
+                previsione = j;
+            }
+        }
+        printf("Immagine %d: Etichetta vera = %d, Previsione = %d\n", i + 1, etichette[i], previsione);
+        free(output); // Libera la memoria allocata per l'output
+    }
+}
+
+int main() {
+    srand(time(NULL));
+
+    printf("Mi appresto a caricare la rete\n");
+    // Creazione della rete
+    ReteNeurale rete = crea_rete();
+
+    printf("Mi appresto a caricare il dataset\n");
+    // Caricamento del dataset (da implementare)
+    Dataset *dataset;
+    dataset = get_dataset("cifar-10/data_batch_1.bin");
+
+    printf("Mi appresto ad allenare\n");
+    // Addestramento della rete
+    allena(&rete, dataset);
+
+    // Salvataggio della rete
+    salva_rete(&rete, "rete_neurale.bin");
+
+    // Caricamento di 4 immagini casuali
+    byte immagini[4][N_INPUTS];
+    byte etichette[4];
+    carica_immagini_casuali(dataset, immagini, etichette);
+
+    // Previsioni sulle immagini
+    fai_previsioni(&rete, immagini, etichette);
+
+    // Liberazione della memoria
+    // (Da implementare)
+
+    return 0;
+}

deep_seek_singolo.c

@@ -0,0 +1,228 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+#include <math.h>
+#include <string.h>
+
+#include "cifar-10/cifar10_manager.h"
+
+// Costanti configurabili
+#define N_LAYERS 3                // Numero di layer (input, hidden, output)
+#define N_NEURONI_HIDDEN 128      // Numero di neuroni nei layer nascosti
+#define N_NEURONI_OUTPUT 1        // Un solo neurone di output (binario)
+#define N_EPOCHE 10               // Numero di epoche di addestramento
+#define LEARNING_RATE 0.01        // Tasso di apprendimento
+#define N_INPUTS 3072             // Dimensioni di un'immagine CIFAR-10 (32x32x3)
+
+typedef struct {
+    double *pesi;
+    double bias;
+    int size;
+} Percettrone;
+
+typedef struct {
+    Percettrone *percettroni;
+    int size;
+} Layer;
+
+typedef struct {
+    Layer *layers;
+    int size;
+} ReteNeurale;
+
+
+double sigmoide(double);
+double relu(double);
+double relu_derivata(double);
+double softmax(double*, int, int);
+ReteNeurale crea_rete();
+int prevedi(ReteNeurale*, byte*);
+void allena(ReteNeurale*, Dataset*);
+void salva_rete(ReteNeurale*, const char*);
+ReteNeurale carica_rete(const char*);
+void carica_immagini_casuali(Dataset*, byte[][N_INPUTS], byte*);
+void fai_previsioni(ReteNeurale*, byte[][N_INPUTS], byte*);
+void backpropagation(ReteNeurale*, byte*, byte, double);
+double forward_pass(ReteNeurale*, byte*);
+
+
+// Funzioni di utilità
+double sigmoide(double x) {
+    return 1.0 / (1.0 + exp(-x));
+}
+
+double sigmoide_derivata(double x) {
+    return sigmoide(x) * (1 - sigmoide(x));
+}
+
+double relu(double x) {
+    return x > 0 ? x : 0;
+}
+
+double relu_derivata(double x) {
+    return x > 0 ? 1 : 0;
+}
+
+// Inizializzazione della rete
+ReteNeurale crea_rete() {
+    ReteNeurale rete;
+    rete.size = N_LAYERS;
+    rete.layers = (Layer *)malloc(N_LAYERS * sizeof(Layer));
+
+    // Layer di input (non ha pesi, solo pass-through)
+    rete.layers[0].size = N_INPUTS;
+    rete.layers[0].percettroni = NULL;
+
+    // Layer nascosto
+    rete.layers[1].size = N_NEURONI_HIDDEN;
+    rete.layers[1].percettroni = (Percettrone *)malloc(N_NEURONI_HIDDEN * sizeof(Percettrone));
+    for (int i = 0; i < N_NEURONI_HIDDEN; i++) {
+        rete.layers[1].percettroni[i].size = N_INPUTS;
+        rete.layers[1].percettroni[i].pesi = (double *)malloc(N_INPUTS * sizeof(double));
+        for (int j = 0; j < N_INPUTS; j++) {
+            rete.layers[1].percettroni[i].pesi[j] = ((double)rand() / RAND_MAX) * 2 - 1; // Pesi casuali tra -1 e 1
+        }
+        rete.layers[1].percettroni[i].bias = ((double)rand() / RAND_MAX) * 2 - 1; // Bias casuale tra -1 e 1
+    }
+
+    // Layer di output
+    rete.layers[2].size = N_NEURONI_OUTPUT;
+    rete.layers[2].percettroni = (Percettrone *)malloc(N_NEURONI_OUTPUT * sizeof(Percettrone));
+    for (int i = 0; i < N_NEURONI_OUTPUT; i++) {
+        rete.layers[2].percettroni[i].size = N_NEURONI_HIDDEN;
+        rete.layers[2].percettroni[i].pesi = (double *)malloc(N_NEURONI_HIDDEN * sizeof(double));
+        for (int j = 0; j < N_NEURONI_HIDDEN; j++) {
+            rete.layers[2].percettroni[i].pesi[j] = ((double)rand() / RAND_MAX) * 2 - 1; // Pesi casuali tra -1 e 1
+        }
+        rete.layers[2].percettroni[i].bias = ((double)rand() / RAND_MAX) * 2 - 1; // Bias casuale tra -1 e 1
+    }
+
+    return rete;
+}
+
+// Forward pass
+double forward_pass(ReteNeurale *rete, byte *input) {
+    double *output_hidden = (double *)malloc(N_NEURONI_HIDDEN * sizeof(double));
+    double output_final;
+
+    // Layer nascosto
+    for (int i = 0; i < N_NEURONI_HIDDEN; i++) {
+        double somma = 0.0;
+        for (int j = 0; j < N_INPUTS; j++) {
+            somma += input[j] * rete->layers[1].percettroni[i].pesi[j];
+        }
+        somma += rete->layers[1].percettroni[i].bias;
+        output_hidden[i] = relu(somma); // Applica ReLU
+    }
+
+    // Layer di output
+    double somma = 0.0;
+    for (int j = 0; j < N_NEURONI_HIDDEN; j++) {
+        somma += output_hidden[j] * rete->layers[2].percettroni[0].pesi[j];
+    }
+    somma += rete->layers[2].percettroni[0].bias;
+    output_final = sigmoide(somma); // Applica sigmoide
+
+    free(output_hidden);
+    return output_final;
+}
+
+// Backpropagation
+void backpropagation(ReteNeurale *rete, byte *input, byte target, double output_final) {
+    // Gradiente della loss (binary cross-entropy)
+    double grad_output = output_final - target;
+
+    // Gradiente rispetto ai pesi e bias del layer di output
+    for (int j = 0; j < N_NEURONI_HIDDEN; j++) {
+        rete->layers[2].percettroni[0].pesi[j] -= LEARNING_RATE * grad_output * output_final * (1 - output_final) * input[j];
+    }
+    rete->layers[2].percettroni[0].bias -= LEARNING_RATE * grad_output * output_final * (1 - output_final);
+
+    // Gradiente rispetto ai pesi e bias del layer nascosto
+    double grad_hidden[N_NEURONI_HIDDEN];
+    for (int j = 0; j < N_NEURONI_HIDDEN; j++) {
+        grad_hidden[j] = grad_output * output_final * (1 - output_final) * rete->layers[2].percettroni[0].pesi[j];
+        grad_hidden[j] *= relu_derivata(output_final); // Derivata di ReLU
+    }
+
+    for (int j = 0; j < N_NEURONI_HIDDEN; j++) {
+        for (int k = 0; k < N_INPUTS; k++) {
+            rete->layers[1].percettroni[j].pesi[k] -= LEARNING_RATE * grad_hidden[j] * input[k];
+        }
+        rete->layers[1].percettroni[j].bias -= LEARNING_RATE * grad_hidden[j];
+    }
+}
+
+// Addestramento
+void allena(ReteNeurale *rete, Dataset *dataset) {
+    for (int epoca = 0; epoca < N_EPOCHE; epoca++) {
+        printf("Epoca %d\n", epoca+1);
+        for (int i = 0; i < dataset->size; i++) {
+            byte *input = dataset->istanze[i].dati;
+            byte target = (dataset->istanze[i].classificazione == 7) ? 1 : 0; // 1 per cavalli, 0 per il resto
+
+            // Forward pass
+            double output_final = forward_pass(rete, input);
+
+            // Backpropagation
+            backpropagation(rete, input, target, output_final);
+        }
+        printf("Epoca %d completata\n", epoca + 1);
+    }
+}
+
+// Funzione per fare previsioni
+int prevedi(ReteNeurale *rete, byte *input) {
+    double output_final = forward_pass(rete, input);
+    return (output_final >= 0.5) ? 2 : 0; // 2 per cavalli, 0 per il resto
+}
+
+// Funzione per caricare 4 immagini casuali dal dataset
+void carica_immagini_casuali(Dataset *dataset, byte immagini[4][N_INPUTS], byte *etichette) {
+    for (int i = 0; i < 4; i++) {
+        int indice_casuale = rand() % dataset->size; // Sceglie un'immagine casuale
+        for (int j = 0; j < N_INPUTS; j++) {
+            immagini[i][j] = dataset->istanze[indice_casuale].dati[j]; // Copia i dati dell'immagine
+        }
+        etichette[i] = dataset->istanze[indice_casuale].classificazione; // Copia l'etichetta
+    }
+}
+
+// Funzione per fare previsioni su 4 immagini
+void fai_previsioni(ReteNeurale *rete, byte immagini[4][N_INPUTS], byte *etichette) {
+    for (int i = 0; i < 4; i++) {
+        int previsione = prevedi(rete, immagini[i]);
+        printf("Immagine %d: Etichetta vera = %d, Previsione = %d\n", i + 1, etichette[i], previsione);
+    }
+}
+
+int main() {
+    srand(time(NULL));
+
+    // Creazione della rete
+    ReteNeurale rete = crea_rete();
+
+    // Caricamento del dataset (da implementare)
+    Dataset *dataset;
+    dataset = get_dataset("cifar-10/data_batch_1.bin");
+    // dataset = carica_dataset("cifar10.bin");
+
+    // Addestramento della rete
+    allena(&rete, dataset);
+
+    // Salvataggio della rete
+    // salva_rete(&rete, "rete_neurale.bin");
+
+    // Caricamento di 4 immagini casuali
+    byte immagini[4][N_INPUTS];
+    byte etichette[4];
+    carica_immagini_casuali(dataset, immagini, etichette);
+
+    // Previsioni sulle immagini
+    fai_previsioni(&rete, immagini, etichette);
+
+    // Liberazione della memoria
+    // (Da implementare)
+
+    return 0;
+}

percettroni.h

@@ -10,12 +10,12 @@ char *file_label = "mnist/train-labels.idx1-ubyte"; */
 
 // #include "mnist/mnist_manager.h"
 #include "cifar-10/cifar10_manager.h";
-//char *file_immagini = "cifar-10/data_batch_1.bin";
+char *file_immagini = "cifar-10/data_batch_1.bin";
 // char *file_immagini = "cifar-10/data_batch_2.bin";
 // char *file_immagini = "cifar-10/data_batch_3.bin";
 // char *file_immagini = "cifar-10/data_batch_4.bin";
 // char *file_immagini = "cifar-10/data_batch_5.bin";
-char *file_immagini = "cifar-10/test_batch.bin";
+//char *file_immagini = "cifar-10/test_batch.bin";
 
 // #include "xor_manager.h"
 
@@ -51,9 +51,14 @@ ReteNeurale inizializza_rete_neurale(int, int, int);
 Layer inizializza_layer(int, int);
 
 double sigmoide(Percettrone p, double *);
+double derivata_sigmoide(double);
 double **elabora_sigmoidi(ReteNeurale, Istanza);
+
+double **elabora_gradienti(ReteNeurale, double, double **);
 void discesa_gradiente(ReteNeurale, double **, double **);
 double calcola_gradiente_disceso(ReteNeurale, int, int, double **);
+
+void aggiorna_pesi(ReteNeurale*, double**, double**, Istanza);
 void correggi_pesi_percettrone_double(Percettrone *, int, double **, double);
 void correggi_pesi_percettrone_byte(Percettrone *, Istanza, double, int);
 
@@ -76,7 +81,8 @@ 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();
     }
 
@@ -130,16 +136,33 @@ ReteNeurale inizializza_rete_neurale(int numero_layers, int numero_percettroni_i
     return r;
 }
 
-
 /*
     ################# PREVISIONI ################################
 */
 
+double **elabora_gradienti(ReteNeurale rete_neurale, double gradiente_errore, double **sigmoidi)
+{
+    double **gradienti = (double **)malloc(sizeof(double *) * rete_neurale.size);
+
+    // Alloco la dimensione per ogni layer
+    for (int indice_layer = 0; indice_layer < rete_neurale.size; indice_layer++)
+    {
+        gradienti[indice_layer] = (double *)malloc(sizeof(double) * rete_neurale.layers[indice_layer].size);
+    }
+
+    // Gradiente del percettrone output
+    gradienti[rete_neurale.size - 1][0] = gradiente_errore * derivata_sigmoide(sigmoidi[rete_neurale.size - 1][0]);
+
+    discesa_gradiente(rete_neurale, sigmoidi, gradienti);
+
+    return gradienti;
+}
 
 double sigmoide(Percettrone p, double *valori)
 {
     double sommatoria = 0.0;
-    for (int i = 0; i < p.size; i++) {
+    for (int i = 0; i < p.size; i++)
+    {
         sommatoria += (valori[i] * p.pesi[i]);
         // printf("valore [%f] peso[%f] ", valori[i], p.pesi[i]);
     }
@@ -151,6 +174,11 @@ double sigmoide(Percettrone p, double *valori)
     return risultato;
 }
 
+double derivata_sigmoide(double valore)
+{
+    return (valore * (1.0 - valore));
+}
+
 int previsione(double valore)
 {
     if (valore >= soglia_sigmoide)
@@ -161,36 +189,21 @@ int previsione(double valore)
 
 void discesa_gradiente(ReteNeurale rete, double **sigmoidi, double **gradienti)
 {
-    //printf("Qui?\n");
-    // For che scorre i layer dal penultimo al primo QUINI SIZE -2
     for (int indice_layer = rete.size - 2; indice_layer >= 0; indice_layer--)
     {
-        //printf("layer: %d ", indice_layer);
-        // printf("Mi trovo nel layer %d, ho %d percettroni\n", indice_layer, rete.layers[indice_layer].size);
-
-        // For che scorre i percettroni del layer partendo dal primo
-        // Per ogni percettrone mi devo prendere il gradiente disceso dal livello sopra e moltiplicarlo per la derivata di attivazione
         for (int indice_percettrone = 0; indice_percettrone < rete.layers[indice_layer].size; indice_percettrone++)
         {
-            //printf("percettrone: %d ", indice_percettrone);
             double derivata_attivazione = sigmoidi[indice_layer][indice_percettrone] * (1.0 - sigmoidi[indice_layer][indice_percettrone]);
-
-            // Passo anche l'indice del percettrone perchè corrisponde all'indice del peso del livello sopra
             double gradiente_disceso = calcola_gradiente_disceso(rete, indice_layer + 1, indice_percettrone, gradienti);
 
             gradienti[indice_layer][indice_percettrone] = gradiente_disceso * derivata_attivazione;
         }
-        //printf("\n");
     }
-    //printf("Qui ?\n");
 }
 
 double calcola_gradiente_disceso(ReteNeurale rete, int livello, int indice_peso, double **gradienti)
 {
-    // printf("Qui ci arrivo\n");
     double sommatoria = 0.0;
-    // printf("Layer %d: N_percettroni: %d\n", livello, rete.layers[livello].size);
-    // Calcolo la sommatoria dei gradienti dei percettroni per i pesi
     for (int indice_percettrone = 0; indice_percettrone < rete.layers[livello].size; indice_percettrone++)
     {
         sommatoria += (gradienti[livello][indice_peso] * rete.layers[livello].percettroni[indice_percettrone].pesi[indice_peso]);
@@ -201,22 +214,24 @@ double calcola_gradiente_disceso(ReteNeurale rete, int livello, int indice_peso,
 
 double **elabora_sigmoidi(ReteNeurale rete, Istanza istanza)
 {
-    // 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 *) * rete.size);
     double *inputs = (double *)malloc(sizeof(double *) * N_INPUTS);
-    for(int i = 0; i < N_INPUTS; i++) {
+    for (int i = 0; i < N_INPUTS; i++)
+    {
         inputs[i] = (double)istanza.dati[i];
     }
 
     sigmoidi[0] = (double *)malloc(sizeof(double) * rete.layers[0].size);
-    for(int indice_percettrone = 0; indice_percettrone < rete.layers[0].size; indice_percettrone ++) {
+    for (int indice_percettrone = 0; indice_percettrone < rete.layers[0].size; indice_percettrone++)
+    {
         sigmoidi[0][indice_percettrone] = sigmoide(rete.layers[0].percettroni[indice_percettrone], inputs);
     }
 
-    for(int indice_layer = 1; indice_layer < rete.size; indice_layer ++) {
+    for (int indice_layer = 1; indice_layer < rete.size; indice_layer++)
+    {
         sigmoidi[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 ++) {
+        for (int indice_percettrone = 0; indice_percettrone < rete.layers[indice_layer].size; indice_percettrone++)
+        {
             sigmoidi[indice_layer][indice_percettrone] = sigmoide(rete.layers[indice_layer].percettroni[indice_percettrone], sigmoidi[indice_layer - 1]);
         }
     }
@@ -224,11 +239,38 @@ double **elabora_sigmoidi(ReteNeurale rete, Istanza istanza)
     return sigmoidi;
 }
 
-
 /*
     ################# CORREZIONI ################################
 */
 
+void aggiorna_pesi(ReteNeurale *rete_neurale, double **sigmoidi, double **gradienti, Istanza istanza)
+{
+    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] * sigmoidi[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;
+
+    // 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, sigmoidi, gradienti[indice_layer][indice_percettrone]);
+            }
+            else
+            {
+                correggi_pesi_percettrone_byte(&rete_neurale->layers[0].percettroni[indice_percettrone], istanza, gradienti[0][indice_percettrone], indice_percettrone);
+            }
+        }
+    }
+}
 
 void correggi_pesi_percettrone_double(Percettrone *p, int layer, double **input, double gradiente_percettrone)
 {
@@ -259,8 +301,6 @@ void correggi_pesi_percettrone_byte(Percettrone *p, Istanza input, double gradie
     p->bias += (gradiente_percettrone * LRE);
 }
 
-
-
 /*
     ################# IMPORT EXPORT ################################
 */
@@ -352,129 +392,3 @@ ReteNeurale *caricaReteNeurale(const char *filename)
     fclose(file);
     return rete;
 }
-
-
-
-
-
-
-
-
-
-/* double sigmoide_byte(Percettrone, byte *, int);
-double sigmoide_double(Percettrone, double *, int);
-double *funzioni_attivazione_layer_byte(Layer, byte *);
-double *funzioni_attivazione_layer_double(Layer, double *); */
-/* void correggi_layer_interni(ReteNeurale *, double **, double **);
-void correggi_layer_input(Layer *, double **, double **, byte *, int); */
-/* // 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++)
-    {
-        funzioni[i] = sigmoide_byte(layer.percettroni[i], inputs, layer.percettroni[i].size);
-        // printf("\tsigmoide layer input %f\n", funzioni[i]);
-    }
-
-    return funzioni;
-}
-
-// Questa funzione calcola tutte le funzioni di attivazione dei percettroni del layer che prende dei double come inputs (le sigmoidi del livello precedente)
-double *funzioni_attivazione_layer_double(Layer layer, double *inputs)
-{
-
-    double *funzioni = (double *)malloc(sizeof(double) * layer.size);
-
-    for (int i = 0; i < layer.size; i++)
-    {
-        funzioni[i] = sigmoide_double(layer.percettroni[i], inputs, layer.percettroni[i].size);
-        // printf("\tsigmoide layer %d: %f\n", i, funzioni[i]);
-    }
-
-    return funzioni;
-}
- */
-/* // Questa funzione prende la matrice dei gradienti e la matrice delle sigmoidi per correggere tutti i layer tranne quello di ingresso
-void correggi_layer_interni(ReteNeurale *rete, double **gradienti, double **sigmoidi)
-{
-
-    for (int indice_layer = rete->size - 1; indice_layer > 0; indice_layer--)
-    {
-        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]);
-            }
-            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);
-        }
-    }
-}
-// Questa funzione prende tutti i parametri della precedente + gli input passati dal dataset per correggere il layer di ingresso
-void correggi_layer_input(Layer *layer, double **gradienti, double **sigmoidi, byte *inputs, int n_layers)
-{
-    // L'indice del layer d'ingresso che prende byte per input
-    int indice_layer = 0;
-    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]);
-        }
-        layer->percettroni[indice_percettrone].bias += (gradienti[n_layers - 1][0] * LRE);
-    }
-}
- */
-/* 
-// Questa funzione viene usata per il primo livello perchè ha un vettore di byte (unsigned char) in input
-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]);
-    }
-    // printf("sommatoria= %f\n", sommatoria);
-    double funzione = sommatoria + p.bias;
-    double potenza_e = exp(-funzione);
-    // printf("potenza_e= %f\n", potenza_e);
-    // formula sigmoide
-    double risultato = 1.0 / (1.0 + potenza_e);
-    // printf("risultato= %f\n", risultato);
-    return risultato;
-}
-
-// 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]);
-    }
-
-    double funzione = sommatoria + p.bias;
-    // printf("sommatoria= %f\n", sommatoria);
-    double potenza_e = exp(-funzione);
-    // printf("potenza_e= %f\n", potenza_e);
-    // formula sigmoide
-    double risultato = 1.0 / (1.0 + potenza_e);
-    // printf("risultato= %f\n", risultato);
-
-    return risultato;
-}
- */