dovrebbe convergere su mnist, da completare con persistenza e visualizzatore

AGENTS.md

@@ -1,47 +1,45 @@
 # AGENTS.md - Agentic Coding Guidelines
 
 ## Project Overview
-C-based neural network implementation from scratch for image classification on CIFAR-10 and MNIST datasets.
+C-based neural network implementation from scratch for image classification on MNIST and CIFAR-10 datasets. Uses header-only library design with `percettroni.h`.
 
 ## Build Commands
 
 ### Compilation
 ```bash
-# Main classifier (MNIST) - compiles the single-classifier training program
+# Main classifier (MNIST) - multi-class classifier (default)
-gcc -o classificatore_singolo_mnist classificatore_singolo.c -lm
+gcc -o classificatore_mnist classificatore.c -lm
 
-# XOR test/demo - simple test to verify neural network works
+# XOR test - quick validation that neural network converges
-gcc -o codice_ricordo codice_ricordo.c -lm
+# Change percettroni.h: uncomment `#include "xor_manager.h"` and comment out MNIST include
+gcc -o classificatore_xor classificatore.c -lm
 
 # Visualizer (requires Allegro library)
 gcc -o visualizzatore visualizzatore.c -lalleg -lm
 
-# Older multi-layer implementation
+# Training with pre-trained weights
-gcc -o rete_neurale rete_neurale.c -lm
+./classificatore_mnist_50_epoche
 ```
 
 ### Running Tests
 ```bash
-# Run XOR validation test (quick sanity check for neural network)
+# Quick test - compile and run MNIST classifier
-./codice_ricordo
+gcc -o classificatore_mnist classificatore.c -lm && ./classificatore_mnist
 
-# Run full training loop with existing compiled binary
+# Memory leak detection
-./classificatore_singolo_mnist
+valgrind --leak-check=full ./classificatore_mnist
 
-# Automated training with pauses (prevents overheating)
+# Run pre-compiled binary (50 epochs)
-./addestratore.sh
+./classificatore_mnist_50_epoche
-
-# Memory leak detection (valgrind)
-valgrind --leak-check=full ./codice_ricordo
 ```
 
 ### Running a Single Test
 ```bash
-# Compile and run XOR test (single test case)
+# Compile and run MNIST classifier (single test)
-gcc -o codice_ricordo codice_ricordo.c -lm && ./codice_ricordo
+gcc -o classificatore_mnist classificatore.c -lm && ./classificatore_mnist
 
-# Compile and run classifier with specific category
+# For XOR test - edit percettroni.h first, then:
-gcc -o classificatore_singolo_mnist classificatore_singolo.c -lm && ./classificatore_singolo_mnist
+gcc -o test_xor classificatore.c -lm && ./test_xor
 ```
 
 ## Code Style Guidelines
@@ -63,8 +61,8 @@ gcc -o classificatore_singolo_mnist classificatore_singolo.c -lm && ./classifica
 - Functions: `snake_case` (e.g., `inizializza_rete_neurale`)
 - Structs: `PascalCase` (e.g., `ReteNeurale`)
 - Constants: `UPPER_SNAKE_CASE` (e.g., `EPOCHE`)
-- Global variables: file scope preferred
 - Types: use `typedef` for structs
+- Global variables: file scope preferred
 
 ### Types
 - Use `byte` (typedef for `unsigned char`) for values 0-255
@@ -75,7 +73,6 @@ gcc -o classificatore_singolo_mnist classificatore_singolo.c -lm && ./classifica
 ### Imports
 - Standard library headers first (`<stdio.h>`, `<stdlib.h>`, `<math.h>`, `<time.h>`)
 - Project headers after (use `"quotes"`)
-- No include guards needed for header-only library
 - Group related includes together
 
 ### Memory Management
@@ -90,67 +87,60 @@ gcc -o classificatore_singolo_mnist classificatore_singolo.c -lm && ./classifica
 - Exit with `EXIT_FAILURE` on unrecoverable errors
 - Validate function inputs at entry points
 
-### Key Constants (from percettroni.h)
+## Key Constants (from percettroni.h)
-- `LRE = 0.1` (learning rate - was 1.414, now 0.1)
+- `LRE = 0.1` (learning rate)
-- `soglia_sigmoide = 0.5` (sigmoid threshold for binary classification)
+- `soglia_sigmoide = 0.5` (sigmoid threshold)
 - `file_pesi = "rete_pesi.bin"` (model weights file)
+- `SOFTMAX = 1` (use softmax for multi-class prediction)
 
-### Dataset Configuration
+## Dataset Configuration
-In `percettroni.h`, uncomment the desired dataset section:
+In `percettroni.h`, include the desired dataset manager:
-- XOR: `#include "xor_manager.h"` (for testing - currently active)
+- MNIST: `#include "mnist/mnist_manager.h"` (currently active)
-- MNIST: Uncomment mnist includes and set file paths
+- XOR: `#include "xor_manager.h"` (for testing)
-- CIFAR-10: Uncomment cifar-10 includes and file paths
+- CIFAR-10: `#include "cifar-10/cifar10_manager.h"`
 
 ## Testing
 No formal test framework. Use these approaches:
-1. `codice_ricordo.c` - XOR validation (4 inputs, quick convergence test)
+1. `xor_manager.h` - XOR validation (quick convergence test)
-2. Visual inspection of weight outputs via `stampa_pesi_rete()`
+2. Visual inspection via `stampa_pesi_rete()`
 3. Monitor epoch error rates in training output
-4. Check for memory leaks with valgrind
+4. Check memory leaks with valgrind
 
 ## Project Structure
-- `percettroni.h` - Core neural network (header-only library with implementations)
+- `percettroni.h` - Core neural network (header-only library)
-- `classificatore_singolo.c` - Single-category classifier main program
+- `classificatore.c` - Main classifier program
-- `codice_ricordo.c` - XOR test/demo
+- `xor_manager.h` - XOR dataset (4 samples)
-- `xor_manager.h` - XOR dataset for testing
 - `mnist/mnist_manager.h` - MNIST dataset loader
 - `cifar-10/cifar10_manager.h` - CIFAR-10 dataset loader
 - `rete_pesi.bin` - Saved model weights
-- `addestratore.sh` - Training automation script
+- `visualizzatore.c` - Image visualizer (requires Allegro)
 
 ## Neural Network Architecture
 - Activation: sigmoid function
 - Training: backpropagation with gradient descent
+- Prediction: softmax for multi-class, sigmoid threshold for binary
 - Configurable: layer count and perceptrons per layer
 - Learning rate: controlled via `LRE` constant (default 0.1)
-- Binary threshold: 0.5 for classification decisions
 
 ## Development Workflow
 
-### Adding a New Dataset
+### Adding a Dataset
 1. Create manager header (e.g., `custom_manager.h`)
-2. Define `N_INPUTS` constant for input size
+2. Define `N_INPUTS` constant
 3. Implement `get_dataset()` returning `Dataset*`
-4. Update `percettroni.h` includes and file paths
+4. Update `percettroni.h` includes
 
 ### Debugging Tips
 - Call `stampa_pesi_rete(rete)` to inspect weights
-- Reference `codice_ricordo.c` for minimal working example
+- Reference `xor_manager.h` for minimal working example
-- Verify dataset loading before training loop
 - Check epoch timing to monitor training progress
 
-### File I/O
-- Weights saved as binary in `rete_pesi.bin`
-- Use `salvaReteNeurale()` and `caricaReteNeurale()` for persistence
-- Dataset files must match expected binary format
-
 ## Performance Notes
-- Training is CPU-intensive (minutes per epoch expected)
+- Training is CPU-intensive (minutes per epoch)
-- Use `addestratore.sh` with sleep intervals to prevent overheating
-- Memory allocated dynamically based on network architecture
 - No GPU acceleration - pure CPU implementation
+- Pre-compiled binary available for quick testing
 
 ## Language Reference
-Technical terms (English): activation function, gradient descent, sigmoid, neural network, backpropagation
+Technical terms (English): activation function, gradient descent, sigmoid, neural network, backpropagation, softmax
 
-Italian terms: pesi (weights), bias, livello (layer), percettrone (perceptron), addestramento (training), epoca (epoch), errore (error), classificazione (label/classification), previsione (prediction), istanza (instance)
+Italian terms: pesi (weights), bias, livello (layer), percettrone (perceptron), addestramento (training), epoca (epoch), errore (error), classificazione (label), previsione (prediction), istanza (instance)

README.md

@@ -1,2 +1,199 @@
-# cifar_10
+# Classificatore di Immagini con Rete Neurale
 
+Implementazione in C di una rete neurale from-scratch per la classificazione di immagini sui dataset MNIST e CIFAR-10.
+
+## Panoramica
+
+Questo progetto implementa una rete neurale fully-connected con:
+- **Attivazione**: funzione sigmoide
+- **Addestramento**: backpropagation con discesa del gradiente
+- **Predizione**: softmax per classificazione multi-classe
+
+## Struttura del Progetto
+
+```
+.
+├── classificatore.c          # Programma principale
+├── percettroni.h             # Libreria core della rete neurale (header-only)
+├── xor_manager.h             # Manager dataset XOR (4 campioni, test rapido)
+├── mnist/
+│   └── mnist_manager.h       # Manager dataset MNIST (28x28 pixel)
+├── cifar-10/
+│   └── cifar10_manager.h     # Manager dataset CIFAR-10 (32x32 RGB)
+├── visualizzatore.c          # Visualizzatore immagini (richiede Allegro)
+└── rete_pesi.bin             # Pesi pre-addestrati
+```
+
+## Compilazione
+
+### Classificatore MNIST (default)
+```bash
+gcc -o classificatore_mnist classificatore.c -lm
+./classificatore_mnist
+```
+
+### Test XOR (validazione rapida)
+Modifica `percettroni.h`:
+- Commenta: `// #include "mnist/mnist_manager.h"`
+- Decommenta: `#include "xor_manager.h"`
+
+```bash
+gcc -o classificatore_xor classificatore.c -lm
+./classificatore_xor
+```
+
+### Visualizzatore
+```bash
+gcc -o visualizzatore visualizzatore.c -lalleg -lm
+```
+
+## Componenti Principali
+
+### percettroni.h
+
+Libreria header-only che implementa la rete neurale completa.
+
+**Strutture dati:**
+- `Percettrone`: singolo neurone con pesi, bias e dimensione
+- `Layer`: strato di percettroni
+- `ReteNeurale`: rete completa con array di layer
+
+**Funzioni principali:**
+
+```c
+// Inizializzazione
+ReteNeurale inizializza_rete_neurale(int numero_input, int numero_layers, 
+                                      int numero_percettroni_iniziali, 
+                                      int numero_percettroni_finali);
+
+// Forward propagation
+double **elabora_sigmoidi(ReteNeurale *rete, Istanza istanza);
+
+// Backpropagation
+double **elabora_gradienti(ReteNeurale *rete, byte output_corretto, double **sigmoidi);
+void aggiorna_pesi(ReteNeurale *rete, double **sigmoidi, double **gradienti, Istanza istanza);
+
+// Predizione
+int previsione_softmax(double *output, int size);
+
+// Persistenza
+void salvaReteNeurale(const char *filename, ReteNeurale *rete);
+ReteNeurale *caricaReteNeurale(const char *filename);
+```
+
+**Architettura dinamica:**
+I layer intermedi riducono progressivamente i percettroni secondo la formula:
+```
+percettroni = percettroni_iniziali * (layer_rimanenti / layer_totali)
+```
+
+### classificatore.c
+
+Programma principale che configura e addestra la rete.
+
+```c
+#define EPOCHE 50
+
+void main() {
+    // Rete: 784 input (MNIST), 10 layer, 256 percettroni iniziali, 10 output
+    ReteNeurale rete = inizializza_rete_neurale(N_INPUTS, 10, 256, 10);
+    Dataset mnist = *get_dataset();
+
+    for(int epoca = 0; epoca < EPOCHE; epoca++) {
+        if (addestra(&rete, mnist))
+            break;  // Stop se accuratezza 100%
+    }
+}
+```
+
+### Manager Dataset
+
+Ogni manager definisce:
+- `N_INPUTS`: dimensione input (es. 784 per MNIST 28x28)
+- `Istanza`: struct con `classificazione` e `dati[]`
+- `Dataset`: struct con array di istanze e dimensione
+- `get_dataset()`: funzione che carica i dati
+
+#### xor_manager.h
+Dataset semplice per test (4 campioni):
+- Input: 2 valori binari
+- Output: 1 valore (XOR)
+- Perfetto per verificare convergenza
+
+#### mnist/mnist_manager.h
+Dataset MNIST:
+- Input: 784 pixel (28×28)
+- Output: 10 classi (cifre 0-9)
+- Formato IDX: header binario + pixel raw
+- Supporta train (60k) e test (10k) set
+
+#### cifar-10/cifar10_manager.h
+Dataset CIFAR-10:
+- Input: 3072 valori (32×32 RGB)
+- Output: 10 classi (oggetti)
+- Formato binario: label + pixel RGB
+
+## Configurazione Dataset
+
+In `percettroni.h`, includi il manager desiderato:
+
+```c
+// Per MNIST
+#include "mnist/mnist_manager.h"
+
+// Per XOR (testing)
+// #include "xor_manager.h"
+
+// Per CIFAR-10
+// #include "cifar-10/cifar10_manager.h"
+```
+
+## Costanti Principali
+
+- `LRE = 0.1`: learning rate
+- `soglia_sigmoide = 0.5`: soglia per predizione binaria
+- `EPOCHE`: numero epoche addestramento
+
+## Debugging
+
+```bash
+# Ispezione pesi
+stampa_pesi_rete(&rete);
+
+# Controllo memory leak
+valgrind --leak-check=full ./classificatore_mnist
+
+# Monitoraggio training
+// Modifica addestra() per stampare errore per epoca
+```
+
+## Note Tecniche
+
+- **Normalizzazione**: input byte (0-255) convertiti in double (0.0-1.0)
+- **Inizializzazione**: pesi casuali in [-1, 1]
+- **Attivazione**: sigmoide con formula `1/(1+e^(-x))`
+- **Softmax**: usato solo sull'output per probabilità multi-classe
+- **Prestazioni**: training CPU-intensive (minuti per epoca su MNIST)
+
+## Esempio Output Training
+
+```
+Layer 0 -> percettroni: 256
+Layer 1 -> percettroni: 230
+...
+Layer 9 -> percettroni: 10
+Rete neurale da 123456 parametri
+Risposte corrette: 85%
+Risposte corrette: 92%
+...
+```
+
+## Requisiti
+
+- GCC o compilatore C compatibile
+- Libreria math (`-lm`)
+- Allegro (solo per visualizzatore)
+
+## Licenza
+
+Progetto didattico - Implementazione from-scratch per scopi educativi.

addestratore.sh

@@ -1,12 +0,0 @@
-#!/bin/bash
-
-contatore=0
-
-while [ $contatore -lt 10 ]
-do
-	echo "Parto con l'addestramento"
-	./classificatore_singolo_mnist >> ciclo_addestramento_$contatore.txt 
-	contatore=`expr $contatore + 1`
-	echo "Fine ciclo addestramento $contatore"
-	sleep 2m
-done

ciclo_addestramento_0.txt

@@ -1,200 +0,0 @@
-Caricate impostazioni rete neurale da file
-Numero elementi nel dataset: 60000
-Epoca 0
-Errore: 0.036221, risposte corrette: 96%
-Epoca 1
-Tempo dall'epoca precedente: 0:31
-Tempo dall'inizio: 0:31
-Errore: 0.036884, risposte corrette: 95%
-Epoca 2
-Tempo dall'epoca precedente: 0:32
-Tempo dall'inizio: 1:3
-Errore: 0.035890, risposte corrette: 96%
-Epoca 3
-Tempo dall'epoca precedente: 0:31
-Tempo dall'inizio: 1:34
-Errore: 0.036380, risposte corrette: 96%
-Epoca 4
-Tempo dall'epoca precedente: 0:31
-Tempo dall'inizio: 2:5
-Errore: 0.036256, risposte corrette: 95%
-Epoca 5
-Tempo dall'epoca precedente: 0:32
-Tempo dall'inizio: 2:37
-Errore: 0.036077, risposte corrette: 96%
-Epoca 6
-Tempo dall'epoca precedente: 0:31
-Tempo dall'inizio: 3:8
-Errore: 0.036191, risposte corrette: 95%
-Epoca 7
-Tempo dall'epoca precedente: 0:32
-Tempo dall'inizio: 3:40
-Errore: 0.036500, risposte corrette: 96%
-Epoca 8
-Tempo dall'epoca precedente: 0:31
-Tempo dall'inizio: 4:11
-Errore: 0.036235, risposte corrette: 96%
-Epoca 9
-Tempo dall'epoca precedente: 0:32
-Tempo dall'inizio: 4:43
-Errore: 0.035910, risposte corrette: 96%
-Epoca 10
-Tempo dall'epoca precedente: 0:31
-Tempo dall'inizio: 5:14
-Errore: 0.036595, risposte corrette: 96%
-Epoca 11
-Tempo dall'epoca precedente: 0:31
-Tempo dall'inizio: 5:45
-Errore: 0.036101, risposte corrette: 96%
-Epoca 12
-Tempo dall'epoca precedente: 0:32
-Tempo dall'inizio: 6:17
-Errore: 0.037006, risposte corrette: 95%
-Epoca 13
-Tempo dall'epoca precedente: 0:31
-Tempo dall'inizio: 6:48
-Errore: 0.036310, risposte corrette: 96%
-Epoca 14
-Tempo dall'epoca precedente: 0:32
-Tempo dall'inizio: 7:20
-Errore: 0.036653, risposte corrette: 95%
-Epoca 15
-Tempo dall'epoca precedente: 0:31
-Tempo dall'inizio: 7:51
-Errore: 0.036671, risposte corrette: 95%
-Epoca 16
-Tempo dall'epoca precedente: 0:32
-Tempo dall'inizio: 8:23
-Errore: 0.036005, risposte corrette: 96%
-Epoca 17
-Tempo dall'epoca precedente: 0:31
-Tempo dall'inizio: 8:54
-Errore: 0.035876, risposte corrette: 96%
-Epoca 18
-Tempo dall'epoca precedente: 0:31
-Tempo dall'inizio: 9:25
-Errore: 0.036562, risposte corrette: 95%
-Epoca 19
-Tempo dall'epoca precedente: 0:32
-Tempo dall'inizio: 9:57
-Errore: 0.035936, risposte corrette: 96%
-Epoca 20
-Tempo dall'epoca precedente: 0:31
-Tempo dall'inizio: 10:28
-Errore: 0.036783, risposte corrette: 95%
-Epoca 21
-Tempo dall'epoca precedente: 0:32
-Tempo dall'inizio: 11:0
-Errore: 0.036031, risposte corrette: 96%
-Epoca 22
-Tempo dall'epoca precedente: 0:31
-Tempo dall'inizio: 11:31
-Errore: 0.036080, risposte corrette: 95%
-Epoca 23
-Tempo dall'epoca precedente: 0:31
-Tempo dall'inizio: 12:2
-Errore: 0.036065, risposte corrette: 96%
-Epoca 24
-Tempo dall'epoca precedente: 0:32
-Tempo dall'inizio: 12:34
-Errore: 0.036156, risposte corrette: 96%
-Epoca 25
-Tempo dall'epoca precedente: 0:31
-Tempo dall'inizio: 13:5
-Errore: 0.035987, risposte corrette: 96%
-Epoca 26
-Tempo dall'epoca precedente: 0:32
-Tempo dall'inizio: 13:37
-Errore: 0.036270, risposte corrette: 96%
-Epoca 27
-Tempo dall'epoca precedente: 0:31
-Tempo dall'inizio: 14:8
-Errore: 0.035895, risposte corrette: 96%
-Epoca 28
-Tempo dall'epoca precedente: 0:32
-Tempo dall'inizio: 14:40
-Errore: 0.036890, risposte corrette: 95%
-Epoca 29
-Tempo dall'epoca precedente: 0:31
-Tempo dall'inizio: 15:11
-Errore: 0.037329, risposte corrette: 95%
-Epoca 30
-Tempo dall'epoca precedente: 0:31
-Tempo dall'inizio: 15:42
-Errore: 0.036398, risposte corrette: 95%
-Epoca 31
-Tempo dall'epoca precedente: 0:32
-Tempo dall'inizio: 16:14
-Errore: 0.035868, risposte corrette: 96%
-Epoca 32
-Tempo dall'epoca precedente: 0:31
-Tempo dall'inizio: 16:45
-Errore: 0.036742, risposte corrette: 96%
-Epoca 33
-Tempo dall'epoca precedente: 0:32
-Tempo dall'inizio: 17:17
-Errore: 0.036120, risposte corrette: 96%
-Epoca 34
-Tempo dall'epoca precedente: 0:31
-Tempo dall'inizio: 17:48
-Errore: 0.035737, risposte corrette: 96%
-Epoca 35
-Tempo dall'epoca precedente: 0:32
-Tempo dall'inizio: 18:20
-Errore: 0.035885, risposte corrette: 96%
-Epoca 36
-Tempo dall'epoca precedente: 0:31
-Tempo dall'inizio: 18:51
-Errore: 0.036042, risposte corrette: 96%
-Epoca 37
-Tempo dall'epoca precedente: 0:31
-Tempo dall'inizio: 19:22
-Errore: 0.036020, risposte corrette: 96%
-Epoca 38
-Tempo dall'epoca precedente: 0:32
-Tempo dall'inizio: 19:54
-Errore: 0.035933, risposte corrette: 96%
-Epoca 39
-Tempo dall'epoca precedente: 0:31
-Tempo dall'inizio: 20:25
-Errore: 0.036811, risposte corrette: 95%
-Epoca 40
-Tempo dall'epoca precedente: 0:32
-Tempo dall'inizio: 20:57
-Errore: 0.036528, risposte corrette: 95%
-Epoca 41
-Tempo dall'epoca precedente: 0:31
-Tempo dall'inizio: 21:28
-Errore: 0.036102, risposte corrette: 96%
-Epoca 42
-Tempo dall'epoca precedente: 0:32
-Tempo dall'inizio: 22:0
-Errore: 0.036159, risposte corrette: 96%
-Epoca 43
-Tempo dall'epoca precedente: 0:31
-Tempo dall'inizio: 22:31
-Errore: 0.037031, risposte corrette: 95%
-Epoca 44
-Tempo dall'epoca precedente: 0:31
-Tempo dall'inizio: 23:2
-Errore: 0.036231, risposte corrette: 96%
-Epoca 45
-Tempo dall'epoca precedente: 0:32
-Tempo dall'inizio: 23:34
-Errore: 0.037214, risposte corrette: 95%
-Epoca 46
-Tempo dall'epoca precedente: 0:31
-Tempo dall'inizio: 24:5
-Errore: 0.035984, risposte corrette: 96%
-Epoca 47
-Tempo dall'epoca precedente: 0:32
-Tempo dall'inizio: 24:37
-Errore: 0.036427, risposte corrette: 95%
-Epoca 48
-Tempo dall'epoca precedente: 0:31
-Tempo dall'inizio: 25:8
-Errore: 0.035916, risposte corrette: 96%
-Epoca 49
-Tempo dall'epoca precedente: 0:32
-Tempo dall'inizio: 25:40
-Errore: 0.036036, risposte corrette: 96%

classificatore.c

@@ -0,0 +1,18 @@
+#include "percettroni.h"
+
+#define EPOCHE 50
+
+void main() {
+    //input, layers, perc iniz, perc fin
+    ReteNeurale rete = inizializza_rete_neurale(N_INPUTS, 10, 256, 10);
+    //stampa_pesi_rete(rete);
+
+    //Dataset xor = *crea_dataset_xor();
+    Dataset mnist = *get_dataset();
+
+    for(int epoca = 0; epoca < EPOCHE; epoca++) {
+        //printf("\nEPOCA %d\n", epoca);
+        if (addestra(&rete, mnist))
+            break;
+    }
+}

classificatore_singolo.c

@@ -1,119 +0,0 @@
-#include <time.h>
-#include "percettroni.h"
-
-// Scelgo quale categoria voglio identificare. nel caso dello xor -1
-#define CATEGORIA 7
-#define NUM_LAYERS 7
-#define PERCETTRONI_LAYER_0 128
-#define MAX_EPOCHE 50
-
-byte get_out_corretto(byte);
-void stampa_layer_indirizzo(Layer *);
-void stampa_tempo(time_t[], int);
-
-void main()
-{
-    time_t tempo_epoche[MAX_EPOCHE];
-
-    srand(time(NULL));
-
-    Dataset *set_appoggio = get_dataset(file_immagini, file_label); //get_dataset(file_immagini);
-
-    if (set_appoggio == NULL)
-        return;
-    Dataset set = *set_appoggio;
-    free(set_appoggio);
-
-    ReteNeurale rete_neurale;
-    ReteNeurale *puntatore_rete = caricaReteNeurale(file_pesi);
-    if (puntatore_rete == NULL)
-    {
-        rete_neurale = inizializza_rete_neurale(NUM_LAYERS, PERCETTRONI_LAYER_0, N_INPUTS);
-    }
-    else
-    {
-        rete_neurale = *puntatore_rete;
-        free(puntatore_rete);
-        printf("Caricate impostazioni rete neurale da file\n");
-    }
-
-    int corrette = 0;
-
-    printf("Numero elementi nel dataset: %d\n", set.size);
-
-    // ADDESTRAMENTO
-    for (int i = 0; i < MAX_EPOCHE; i++)
-    {
-        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; 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[rete_neurale.size - 1][0]) == output_corretto)
-                corrette++;
-
-            // Derivata funzione di perdita
-            double gradiente_errore = (output_corretto - sigmoidi[rete_neurale.size - 1][0]);
-            errore_totale += pow(gradiente_errore, 2);
-
-            double **gradienti = elabora_gradienti(rete_neurale, gradiente_errore, sigmoidi);
-
-            aggiorna_pesi(rete_neurale, sigmoidi, gradienti, set.istanze[indice_set]);
-
-        }
-
-        printf("Errore: %f, risposte corrette: %d%\n", errore_totale / set.size, (corrette * 100) / set.size);
-    }
-
-    salvaReteNeurale(file_pesi, &rete_neurale);
-}
-
-// Questa funzione ritorna 1 se la categoria è quella che voglio individuare, altrimenti 0
-byte get_out_corretto(byte categoria)
-{
-    if (CATEGORIA != -1)
-    {
-        if (categoria == CATEGORIA)
-            return 1;
-        else
-            return 0;
-    }
-    else
-        return categoria;
-}
-
-void stampa_layer_indirizzo(Layer *layer)
-{
-    for (int i = 0; i < layer->size; i++)
-    {
-        printf("Percettrone %d ->", i);
-        for (int j = 0; j < layer->percettroni->size; j++)
-        {
-            printf("\t peso %d, valore: %f", j, layer->percettroni[i].pesi[j]);
-            layer->percettroni[i].pesi[j] += 1;
-        }
-        printf("\n");
-    }
-}
-
-void stampa_tempo(time_t tempo_epoche[], int i)
-{
-
-    time(&tempo_epoche[i]);
-    if (i > 0)
-    {
-        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("Tempo dall'epoca precedente: %d:%d\n", minuti_epoca, secondi_epoca);
-        printf("Tempo dall'inizio: %d:%d\n", minuti_totali, secondi_totali);
-    }
-}

codice_ricordo.c

@@ -1,16 +0,0 @@
-#include "percettroni.h"
-
-#define EPOCHE 100000
-
-void main() {
-    ReteNeurale rete = inizializza_rete_neurale(2, 5, 50, 10);
-    //stampa_pesi_rete(rete);
-
-    Dataset xor = *crea_dataset_xor();
-
-    for(int epoca = 0; epoca < EPOCHE; epoca++) {
-        //printf("\nEPOCA %d\n", epoca);
-        if (addestra(&rete, xor))
-            break;
-    }
-}

mnist/mnist_manager.h

@@ -19,6 +19,11 @@ Byte 8 in poi: 60.000 byte, ognuno dei quali rappresenta l'etichetta di un'immag
 #include <stdlib.h>
 #include <stdio.h>
 
+char *file_immagini = "mnist/t10k-images.idx3-ubyte";
+char *file_label = "mnist/t10k-labels.idx1-ubyte";
+// char *file_immagini = "mnist/train-images.idx3-ubyte";
+// char *file_label = "mnist/train-labels.idx1-ubyte";
+
 #define N_INPUTS 784 // Immagine 28x28
 
 // Siccome il char è un byte che rappresenta il valore tra 0 e 255. Per evitare confusioni definisco il tipo "byte" come in Java
@@ -38,24 +43,24 @@ typedef struct
     Istanza *istanze;
 } Dataset;
 
-Dataset *get_dataset(char *, char *);
+Dataset *get_dataset();
 
 // 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.
-Dataset *get_dataset(char *path_mnist, char *path_categoria)
+Dataset *get_dataset()
 {
     Dataset *set = (Dataset *)malloc(sizeof(Dataset));
     FILE *file;
     FILE *categorie;
     Istanza *istanze = (Istanza *)malloc(sizeof(Istanza));
 
-    file = fopen(path_mnist, "rb");
+    file = fopen(file_immagini, "rb");
     if (file == NULL) {
         printf("Errore nella funzione fopen() nelle immagini\n");
         return NULL;
     }
 
-    categorie = fopen(path_categoria, "rb");
+    categorie = fopen(file_label, "rb");
     if (file == NULL) {
         printf("Errore nella funzione fopen() nelle categorie\n");
         return NULL;
@@ -74,8 +79,8 @@ Dataset *get_dataset(char *path_mnist, char *path_categoria)
         }
 
     // Dataset set;
-    (*set).size = numero_righe;
+    set->size = numero_righe;
-    (*set).istanze = istanze;
+    set->istanze = istanze;
 
     fclose(file);
     return set;

percettroni.h

@@ -5,11 +5,7 @@
 
 char *file_pesi = "rete_pesi.bin";
 
-// #include "mnist/mnist_manager.h"
+#include "mnist/mnist_manager.h"
-/* char *file_immagini = "mnist/t10k-images.idx3-ubyte";
-char *file_label = "mnist/t10k-labels.idx1-ubyte"; */
-// char *file_immagini = "mnist/train-images.idx3-ubyte";
-// char *file_label = "mnist/train-labels.idx1-ubyte";
 
 // #include "cifar-10/cifar10_manager.h";
 // char *file_immagini = "cifar-10/data_batch_1.bin";
@@ -19,12 +15,11 @@ char *file_label = "mnist/t10k-labels.idx1-ubyte"; */
 //  char *file_immagini = "cifar-10/data_batch_5.bin";
 // char *file_immagini = "cifar-10/test_batch.bin";
 
-#include "xor_manager.h"
+//#include "xor_manager.h"
 
-// Siccome il char è un byte che rappresenta il valore tra 0 e 255. Per evitare confusioni definisco il tipo "byte" come in Java
 typedef unsigned char byte;
 
-double LRE = 0.5;
+double LRE = 0.1;
 double soglia_sigmoide = 0.5;
 
 typedef struct
@@ -46,40 +41,191 @@ typedef struct
     int size;
 } ReteNeurale;
 
+/*
+ * Genera un valore casuale nell'intervallo [-1, 1] per inizializzare pesi e bias.
+ * Usa rand() modulo 101 (0-100) convertito in decimale (0.00-1.00), 
+ * poi scalato a [-1, 1] moltiplicando per 2 e sottraendo 1.
+ */
 double randomico();
 
+/*
+ * Inizializza un percettrone con n_pesi connessioni in entrata.
+ * Assegna valori casuali a tutti i pesi e al bias usando randomico().
+ * La dimensione n_pesi dipende dal layer precedente (o dagli input).
+ */
 Percettrone inzializza_percettrone(int);
-ReteNeurale inizializza_rete_neurale(int, 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);
-
-int previsione(double);
-
-void salvaReteNeurale(const char *, ReteNeurale *);
-ReteNeurale *caricaReteNeurale(const char *);
-
-void stampa_pesi_rete(ReteNeurale *);
 
 /*
-    ################# INIZIALIZZAZIONI ################################
+ * Crea una rete neurale con architettura dinamica:
+ * - numero_input: dimensione dei dati in ingresso (es. 784 per MNIST 28x28)
+ * - numero_layers: quanti strati nascosti + strato di output
+ * - numero_percettroni_iniziali: percettroni nel primo layer
+ * - numero_percettroni_finali: percettroni nell'output (10 per MNIST, 1 per XOR)
+ * 
+ * I layer intermedi hanno numero decrescente di percettroni calcolato come:
+ * numero_percettroni = numero_percettroni_iniziali * (layer_rimanenti / layer_totali)
+ * Questo crea una piramide: molti neuroni in ingresso, pochi in uscita.
  */
-// Questa funzione genera un valore reale random compreso nell'intervallo [-1, 1]
+ReteNeurale inizializza_rete_neurale(int, int, int, int);
+
+/*
+ * Crea un layer con n_percettroni, ognuno con n_pesi connessioni.
+ * Ogni percettrone viene inizializzato indipendentemente con pesi casuali.
+ */
+Layer inizializza_layer(int, int);
+
+/*
+ * Funzione di attivazione sigmoide: trasforma la somma pesata in valore tra 0 e 1.
+ * Calcola: sommatoria(input_i * peso_i) + bias, poi applica 1/(1+e^(-somma))
+ * La sigmoide introduce non-linearità e "schiaccia" i valori estremi.
+ */
+double sigmoide(Percettrone p, double *);
+
+/*
+ * Derivata della sigmoide: necessaria per il calcolo del gradiente.
+ * Formula: sigmoide(x) * (1 - sigmoide(x))
+ * Indica quanto velocemente cambia l'output rispetto all'input.
+ */
+double derivata_sigmoide(double);
+
+/*
+ * Softmax: normalizza l'output dell'ultimo layer in probabilità (somma = 1).
+ * Passaggi:
+ * 1. Trova il valore massimo per stabilità numerica (evita overflow)
+ * 2. Calcola e^(x_i - max) per ogni output
+ * 3. Divide ogni valore per la somma totale
+ * Utile per classificazione multi-classe: il percettrone con valore più alto
+ * rappresenta la classe predetta con la probabilità più alta.
+ */
+void softmax(double *, int);
+
+/*
+ * Forward propagation: calcola gli output di tutti i layer partendo dall'input.
+ * 
+ * Algoritmo:
+ * 1. Converte i byte input (0-255) in double normalizzati (0.0-1.0) dividendo per 255
+ * 2. Per il primo layer: applica sigmoide a ogni percettrone usando gli input
+ * 3. Per i layer successivi: usa gli output del layer precedente come input
+ * 
+ * Restituisce una matrice sigmoidi[layer][percettrone] con tutti i valori intermedi.
+ * Questi valori servono poi per il calcolo dei gradienti (backpropagation).
+ */
+double **elabora_sigmoidi(ReteNeurale *, Istanza);
+
+/*
+ * Calcola i gradienti dell'errore per ogni percettrone usando backpropagation.
+ * 
+ * Passaggi:
+ * 1. GRADIENTI OUTPUT (ultimo layer):
+ *    - Se il percettrone corrisponde alla classe corretta: errore = 1 - output
+ *    - Altrimenti: errore = 0 - output
+ *    - Moltiplica errore per derivata_sigmoide(output) per ottenere il gradiente
+ * 
+ * 2. GRADIENTI NASCOSTI (layer precedenti):
+ *    - Usa discesa_gradiente() per propagare l'errore all'indietro
+ *    - Ogni neurone riceve la somma pesata dei gradienti dei neuroni successivi
+ * 
+ * Il gradiente indica quanto e in che direzione modificare i pesi per ridurre l'errore.
+ */
+double **elabora_gradienti(ReteNeurale *, byte, double **);
+
+/*
+ * Propaga i gradienti dagli output verso i layer precedenti (backpropagation).
+ * 
+ * Per ogni layer (dall'ultimo al primo):
+ * - Per ogni percettrone del layer corrente:
+ *   1. Calcola derivata_sigmoide dell'output del percettrone
+ *   2. Calcola gradiente_disceso: somma pesata dei gradienti del layer successivo
+ *      moltiplicati per i pesi delle connessioni
+ *   3. Il gradiente finale = gradiente_disceso * derivata_sigmoide
+ * 
+ * Questo è l'algoritmo della "catena" di derivate (chain rule) del calcolo differenziale.
+ */
+void discesa_gradiente(ReteNeurale *, double **, double **);
+
+/*
+ * Calcola quanto l'errore del layer success influenza questo percettrone.
+ * Somma: gradiente[j] * peso_connessione[i][j] per ogni percettrone j del layer dopo.
+ * Questo è il "peso" dell'errore che deve essere corretto a questo livello.
+ */
+double calcola_gradiente_disceso(ReteNeurale *, int, int, double **);
+//double trova_gradiente_errore_softmax(double *, int , int);
+
+/*
+ * Aggiorna tutti i pesi della rete usando i gradienti calcolati (discesa del gradiente).
+ * 
+ * Formula di aggiornamento: peso_nuovo = peso_vecchio + (gradiente * learning_rate)
+ * 
+ * Per l'ultimo layer:
+ * - gradiente_peso = gradiente_percettrone * output_layer_precedente
+ * - Aggiorna pesi e bias
+ * 
+ * Per i layer nascosti:
+ * - Usa correggi_pesi_percettrone_double() per layer interni (input da double)
+ * - Usa correggi_pesi_percettrone_byte() per primo layer (input da byte originale)
+ * 
+ * Il learning rate (LRE) controlla la "velocità" di apprendimento.
+ */
+void aggiorna_pesi(ReteNeurale *, double **, double **, Istanza);
+
+/*
+ * Corregge i pesi di un percettrone usando input double (da layer precedenti).
+ * Per ogni peso:
+ * - gradiente_peso = gradiente_percettrone * input_corrispondente
+ * - peso += gradiente_peso * learning_rate
+ * - bias += gradiente_percettrone * learning_rate
+ */
+void correggi_pesi_percettrone_double(Percettrone *, int, double **, double);
+
+/*
+ * Corregge i pesi del primo layer usando input byte (dati originali).
+ * Simile a correggi_pesi_percettrone_double ma converte i byte in double.
+ * Necessario perché il primo layer riceve input non normalizzati dal dataset.
+ */
+void correggi_pesi_percettrone_byte(Percettrone *, Istanza, double, int);
+
+/*
+ * Predizione binaria: restituisce 1 se valore >= soglia_sigmoide (0.5), altrimenti 0.
+ * Usata per classificazione binaria (es. XOR o singola categoria MNIST).
+ */
+/*
+ * Predizione multi-classe: applica softmax all'output e restituisce l'indice
+ * del percettrone con valore più alto (la classe predetta).
+ * Usata per MNIST e CIFAR-10 (10 classi).
+ */
+int previsione_softmax(double *, int);
+
+/*
+ * Salva la rete neurale su file binario includendo:
+ * - Numero di layer
+ * - Per ogni layer: numero di percettroni
+ * - Per ogni percettrone: numero di pesi, array pesi, bias
+ * 
+ * Il formato binario permette di ricaricare il modello addestrato
+ * senza dover ripetere l'allenamento.
+ */
+void salvaReteNeurale(const char *, ReteNeurale *);
+
+/*
+ * Carica una rete neurale da file binario.
+ * Legge la struttura e alloca dinamicamente tutta la memoria necessaria.
+ * 
+ * Restituisce NULL se il file non esiste o c'è un errore di allocazione.
+ */
+ReteNeurale *caricaReteNeurale(const char *);
+
+/*
+ * Stampa su stdout tutti i pesi e i bias della rete.
+ * Utile per debugging e ispezione dello stato del modello.
+ * Formato: Livello -> Percettrone -> Peso[i]: valore
+ */
+void stampa_pesi_rete(ReteNeurale *);
+
+/*############# INIZIALIZZAZIONI #########################*/
+
 double randomico()
 {
-    // Genero numeri nell'intervallo [-1,1]
     return ((double)(rand() % 101 * 0.01 * 2.0) - 1.0);
-    //return (double)(rand() % 101 * 0.01);
 }
 
 Percettrone inizializza_percettrone(int n_pesi)
@@ -119,14 +265,10 @@ ReteNeurale inizializza_rete_neurale(int numero_input, int numero_layers, int nu
     ReteNeurale r;
     r.layers = (Layer *)malloc(sizeof(Layer) * numero_layers);
     r.size = numero_layers;
+    int somma_parametri = 0;
 
-    // Funzione esponenziale inversa layer
     for (int livello = 0; livello < numero_layers; livello++)
     {
-        //double esponente = (double)livello / (double)numero_layers;
-        //double frazione = (double)1 / (double)numero_percettroni_iniziali;
-        //int numero_percettroni_livello = (int)((double)numero_percettroni_iniziali * pow(frazione, esponente));
-
         int numero_percettroni_livello = 1;
 
         if (livello == numero_layers - 1)
@@ -136,14 +278,19 @@ ReteNeurale inizializza_rete_neurale(int numero_input, int numero_layers, int nu
             numero_percettroni_livello = (int)((double)(numero_percettroni_iniziali * frazione));
         }
 
-        // printf("esponente %f -> frazione: %f\n", esponente, frazione);
         printf("Layer %d -> percettroni: %d\n", livello, numero_percettroni_livello);
 
-        if (livello == 0)
+        if (livello == 0) {
             r.layers[livello] = inizializza_layer(numero_percettroni_livello, numero_input);
-        else
+            somma_parametri += (numero_percettroni_livello * numero_input);
-            r.layers[livello] = inizializza_layer(numero_percettroni_livello, r.layers[livello - 1].size);
         }
+        else {
+            r.layers[livello] = inizializza_layer(numero_percettroni_livello, r.layers[livello - 1].size);
+            somma_parametri += (numero_percettroni_livello * r.layers[livello - 1].size);
+        }
+    }
+
+    printf("Rete neurale da %d parametri\n", somma_parametri);
 
     return r;
 }
@@ -152,28 +299,32 @@ ReteNeurale inizializza_rete_neurale(int numero_input, int numero_layers, int nu
     ################# PREVISIONI ################################
 */
 
-// Da eseguire a mano 2
+double **elabora_gradienti(ReteNeurale *rete_neurale, byte output_corretto, double **sigmoidi)
-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);
     }
 
-    // Qui mi trovo il gradiente del percettrone output (ultimo livello)
+    for(int indice_percettrone = 0; indice_percettrone < rete_neurale->layers[rete_neurale->size - 1].size; indice_percettrone++) {
-    for(int indice_percettrone = 0; indice_percettrone < rete_neurale->layers[rete_neurale->size - 1].size; indice_percettrone++)
+        double gradiente_errore = 0.0;
-        gradienti[rete_neurale->size - 1][indice_percettrone] = gradiente_errore * derivata_sigmoide(sigmoidi[rete_neurale->size - 1][indice_percettrone]);
+        if(indice_percettrone == output_corretto) {
+            gradiente_errore = 1 - sigmoidi[rete_neurale->size - 1][indice_percettrone];
+        }
+        else {
+            gradiente_errore = 0 - sigmoidi[rete_neurale->size - 1][indice_percettrone];
+        }
+
+        gradienti[rete_neurale->size - 1][indice_percettrone] = gradiente_errore * derivata_sigmoide(sigmoidi[rete_neurale->size - 1][indice_percettrone]);
+    }
 
-    //Dal gradiente trovato per l'output, mi discendo tutti gli altri
     discesa_gradiente(rete_neurale, sigmoidi, gradienti);
 
     return gradienti;
 }
 
-// Invocata da elabora_sigmoidi()
 double sigmoide(Percettrone p, double *valori)
 {
     double sommatoria = 0.0;
@@ -195,30 +346,50 @@ double sigmoide(Percettrone p, double *valori)
     return risultato;
 }
 
-// Invocata da elabora_gradienti()
 double derivata_sigmoide(double valore)
 {
-    //Sigmoide
     double derivata = valore * (1.0 - valore);   
-    //ReLU
-    //double derivata = valore > 0 ? 1.0f : 0.0f;
-    
     return derivata;
 }
 
+void softmax(double *input, int size) {
+    float max = input[0];
+
+    for (int i = 1; i < size; i++)
+        if (input[i] > max)
+            max = input[i];
+    
+    float sum = 0.0f;
+    for (int i = 0; i < size; i++) {
+        input[i] = expf(input[i] - max);
+        sum += input[i];
+    }
+
+    for (int i = 0; i < size; i++)
+        input[i] /= sum;
+}
+
 int previsione(double valore)
 {
-    //Sigmoide
     if (valore >= soglia_sigmoide)
         return 1;
     else
         return 0;
-
-    //ReLU
-    //return valore > 0 ? 1 : 0;
 }
 
-// Invocata da elabora_gradienti()
+int previsione_softmax(double *livello_percettroni, int size) {
+
+    softmax(livello_percettroni, size);
+    int max = 0;
+    
+    for(int i = 1; i < size; i++) {
+        if(livello_percettroni[i] > livello_percettroni[max])
+            max = i;
+    }
+
+    return max;
+}
+
 void discesa_gradiente(ReteNeurale *rete, double **sigmoidi, double **gradienti)
 {
     for (int indice_layer = rete->size - 2; indice_layer >= 0; indice_layer--)
@@ -233,7 +404,6 @@ void discesa_gradiente(ReteNeurale *rete, double **sigmoidi, double **gradienti)
     }
 }
 
-// Invocata da discesa_gradienti()
 double calcola_gradiente_disceso(ReteNeurale *rete, int livello, int indice_peso, double **gradienti)
 {
     double sommatoria = 0.0;
@@ -245,14 +415,13 @@ double calcola_gradiente_disceso(ReteNeurale *rete, int livello, int indice_peso
     return sommatoria;
 }
 
-// Da eseguire a mano 1
 double **elabora_sigmoidi(ReteNeurale *rete, Istanza istanza)
 {
     double **sigmoidi = (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];
+        inputs[i] = (double)istanza.dati[i] / 255.0;
     }
 
     sigmoidi[0] = (double *)malloc(sizeof(double) * rete->layers[0].size);
@@ -279,21 +448,21 @@ double **elabora_sigmoidi(ReteNeurale *rete, Istanza istanza)
 
 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_percettrone = 0; indice_percettrone < rete_neurale->layers[rete_neurale->size - 1].size; indice_percettrone++) {
+
+        for (int indice_peso = 0; indice_peso < rete_neurale->layers[rete_neurale->size - 1].percettroni[indice_percettrone].size; indice_peso++)
+        {
+            double gradiente_peso = gradienti[rete_neurale->size - 1][indice_percettrone] * sigmoidi[rete_neurale->size - 2][indice_peso];
+            rete_neurale->layers[rete_neurale->size - 1].percettroni[indice_percettrone].pesi[indice_peso] += gradiente_peso * LRE;
+        }
+        rete_neurale->layers[rete_neurale->size - 1].percettroni[indice_percettrone].bias += gradienti[rete_neurale->size - 1][indice_percettrone] * LRE;
+    }
+
     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]);
@@ -311,10 +480,7 @@ void correggi_pesi_percettrone_double(Percettrone *p, int layer, double **input,
 
     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];
-
-        // Modifico il peso
         p->pesi[indice_peso] += (gradiente_peso * LRE);
     }
 
@@ -325,10 +491,7 @@ void correggi_pesi_percettrone_byte(Percettrone *p, Istanza input, double gradie
 {
     for (int indice_peso = 0; indice_peso < p->size; indice_peso++)
     {
-        // Determino il gradiente del peso
         double gradiente_peso = gradiente_percettrone * (double)input.dati[indice_peso];
-
-        // Modifico il peso
         p->pesi[indice_peso] += (gradiente_peso * LRE);
     }
 
@@ -338,44 +501,39 @@ void correggi_pesi_percettrone_byte(Percettrone *p, Istanza input, double gradie
 /*
     ################### ADDESTRAMENTO #########################
 */
-//Elabora un'epoca. Restituisce 1 se ha dato il 100% di previsioni corrette
+
-byte addestra(ReteNeurale *rete_neurale, Dataset set)
+char addestra(ReteNeurale *rete_neurale, Dataset set)
 {
     int corrette = 0;
-    double errore_totale = 0.0;
 
-    //Per ogni istanza del dataset
     for (int indice_set = 0; indice_set < set.size; indice_set++)
     {
-        double **sigmoidi = elabora_sigmoidi(rete_neurale, set.istanze[indice_set]);
-
         byte output_corretto = set.istanze[indice_set].classificazione;
-        int previsto = previsione(sigmoidi[rete_neurale->size - 1][0]);
 
-        //printf("\tPrevisto: %d, corretto: %d\n", previsto, output_corretto);
+        double **sigmoidi = elabora_sigmoidi(rete_neurale, set.istanze[indice_set]);
+        double *sigmoidi_softmax = elabora_sigmoidi(rete_neurale, set.istanze[indice_set])[rete_neurale->size -1];
+        double **gradienti = elabora_gradienti(rete_neurale, output_corretto, sigmoidi);
+        
+        int previsto = previsione_softmax(sigmoidi_softmax, rete_neurale->layers[rete_neurale->size -1].size);
+
+        //printf("Previsione: %d - out: %d\n", previsto, output_corretto);
 
         if (previsto == output_corretto) {
             corrette++;
         }
-        else {
-            // Derivata funzione di perdita
-            double gradiente_errore = (output_corretto - sigmoidi[rete_neurale->size - 1][0]);
-            errore_totale += pow(gradiente_errore, 2);
 
-            double **gradienti = elabora_gradienti(rete_neurale, gradiente_errore, sigmoidi);
         aggiorna_pesi(rete_neurale, sigmoidi, gradienti, set.istanze[indice_set]);
 
         for(int i = 0; i < rete_neurale->size; i++)
             free(gradienti[i]);
         free(gradienti);
-        }
 
         for(int i = 0; i < rete_neurale->size; i++)
             free(sigmoidi[i]);
         free(sigmoidi);
     }
 
-    //printf("Errore: %f, risposte corrette: %d%\n", errore_totale, (corrette * 100) / set.size);
+    printf("Risposte corrette: %d%\n", (corrette * 100) / set.size);
 
     if(corrette == set.size)
         return 1;
@@ -395,16 +553,13 @@ void salvaReteNeurale(const char *filename, ReteNeurale *rete)
         exit(EXIT_FAILURE);
     }
 
-    // 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];
@@ -434,7 +589,6 @@ ReteNeurale *caricaReteNeurale(const char *filename)
         return NULL;
     }
 
-    // Leggi il numero di layer
     fread(&rete->size, sizeof(int), 1, file);
     rete->layers = malloc(rete->size * sizeof(Layer));
     if (!rete->layers)
@@ -443,7 +597,6 @@ ReteNeurale *caricaReteNeurale(const char *filename)
         return NULL;
     }
 
-    // Leggi ogni layer
     for (int i = 0; i < rete->size; i++)
     {
         Layer *layer = &rete->layers[i];
@@ -455,7 +608,6 @@ ReteNeurale *caricaReteNeurale(const char *filename)
             return NULL;
         }
 
-        // Leggi ogni percettrone nel layer
         for (int j = 0; j < layer->size; j++)
         {
             Percettrone *perc = &layer->percettroni[j];

rete_neurale.c

@@ -1,162 +0,0 @@
-#include <stdio.h>
-#include <time.h>
-#include "percettroni.h"
-
-#define PERCETTRONI_1 256
-#define PERCETTRONI_2 128
-#define PERCETTRONI_OUT 10
-
-#define MAX_EPOCHE 1
-
-double** alloca_memoria_bidimensionale(int, int);
-
-void main()
-{
-    srand(time(NULL));
-
-    Percettrone livello_uno[PERCETTRONI_1];
-    Percettrone livello_due[PERCETTRONI_2];
-    Percettrone livello_out[PERCETTRONI_OUT];
-
-    for (int i = 0; i < PERCETTRONI_1; i++)
-    {
-        inizializza_percettrone(&livello_uno[i], INPUT_LIV1);
-        if (i < PERCETTRONI_2)
-        {
-            inizializza_percettrone(&livello_due[i], INPUT_LIV2);
-            if (i < PERCETTRONI_OUT)
-                inizializza_percettrone(&livello_out[i], INPUT_LIV3);
-        }
-    }
-
-    Dataset *set_appoggio = get_dataset("cifar-10-batches/data_batch_1.bin");
-    if (set_appoggio == NULL)
-        return;
-
-    Dataset dataset = *set_appoggio;
-    free(set_appoggio);
-
-    // Ciclo esterno per contare le epoche
-    for (int indice_epoca = 0; indice_epoca < MAX_EPOCHE; indice_epoca++)
-    {
-
-        // Ciclo interno per contare tutte le istanze del dataset da analizzare nell'epoca corrente
-        for (int indice_dataset = 0; indice_dataset < dataset.size; indice_dataset++)
-        {
-
-            // Qui memorizzo tutte le sigmoidi della rete
-            double sigmoidi_livello_uno[PERCETTRONI_1];
-            double sigmoidi_livello_due[PERCETTRONI_2];
-            double sigmoidi_livello_out[PERCETTRONI_OUT];
-
-            // Livello 1
-            // Ho 256 percettroni da riempire
-            for (int i = 0; i < PERCETTRONI_1; i++)
-                sigmoidi_livello_uno[i] = funzione_sigmoide_primo_livello(livello_uno[i], dataset.istanze[indice_dataset].immagine, INPUT_LIV1);
-
-            // Livello 2
-            // Ho 128 percettroni da riempire
-            for (int i = 0; i < PERCETTRONI_2; i++)
-                sigmoidi_livello_due[i] = funzione_sigmoide(livello_due[i], sigmoidi_livello_uno, INPUT_LIV2);
-
-            // Livello OUT
-            // Ho 10 percettroni da riempire
-            for (int i = 0; i < PERCETTRONI_OUT; i++)
-            {
-                sigmoidi_livello_out[i] = funzione_sigmoide(livello_out[i], sigmoidi_livello_due, INPUT_LIV3);
-                printf("Sigmoide %d: %f\n", i, sigmoidi_livello_out[i]);
-            }
-
-            // Determinare l'errore e la previsione
-            // Ho 10 percettroni in uscita, la previsione è che uno sarà 1 mentre tutti gli altri 0.
-            // Il percettrone con 1 è quello di indice dataset.istanze[indice_dataset].categoria
-            int indice_corretto = dataset.istanze[indice_dataset].categoria;
-
-            double errori[PERCETTRONI_OUT];
-
-            printf("Fino a qui ci arrivo 1\n");
-
-            double **gradienti_out = alloca_memoria_bidimensionale(PERCETTRONI_OUT, INPUT_LIV3);
-            double gradienti_bias_out[PERCETTRONI_OUT];
-
-            double **gradienti_2 = alloca_memoria_bidimensionale(PERCETTRONI_2, INPUT_LIV2);
-            double gradienti_bias_2[PERCETTRONI_2];
-
-            double **gradienti_1 = alloca_memoria_bidimensionale(PERCETTRONI_1, INPUT_LIV1);
-            double gradienti_bias_1[PERCETTRONI_1];
-
-            // Per ogni percettrone di uscita vedo se ha commesso errore e mi calcolo il gradiente
-            for (int i = 0; i < PERCETTRONI_OUT; i++)
-            {
-                // Se la i corrisponde all'indice corretto, la previsione dovrebbe essere 1, se non lo è c'è errore
-                if (i == indice_corretto)
-                {
-                    if (prevedi(sigmoidi_livello_out[i]) != 1)
-                    { // Errore
-                        errori[i] = 1 - sigmoidi_livello_out[i];
-
-                        for (int j = 0; j < INPUT_LIV3; j++)
-                            gradienti_out[i][j] = errori[i] * sigmoidi_livello_out[i] * (1 - sigmoidi_livello_out[i]) /* * sigmoidi_livello_due[j] */;
-                        gradienti_bias_out[i] = errori[i] * sigmoidi_livello_out[i] * (1 - sigmoidi_livello_out[i]);
-
-                        //Qui potrei moltiplicarmi i pesi per i gradienti quindi correggere il livello output
-
-                        for (int j = 0; j < PERCETTRONI_2; j++)
-                        {
-                            for (int k = 0; k < INPUT_LIV2; k++)
-                                gradienti_2[j][k] = gradienti_out[i][j] * sigmoidi_livello_due[j] * (1 - sigmoidi_livello_due[j]);
-                            gradienti_bias_2[j] = gradienti_out[i][j] * sigmoidi_livello_due[j] * (1 - sigmoidi_livello_due[j]);
-
-                            //Qui potrei moltiplicarmi i pesi per i gradienti quindi correggere il livello due
-
-                            for (int y = 0; y < PERCETTRONI_1; y++)
-                            {
-                                for (int z = 0; z < INPUT_LIV1; z++)
-                                    gradienti_1[y][z] = gradienti_out[i][j] * gradienti_2[j][y] * sigmoidi_livello_uno[y] * (1 - sigmoidi_livello_uno[y]);
-                                gradienti_bias_1[y] = gradienti_out[i][j] * gradienti_2[j][y] * sigmoidi_livello_uno[y] * (1 - sigmoidi_livello_uno[y]);
-
-                                //Qui potrei moltiplicarmi i pesi per i gradienti quindi correggere il livello uno
-                            }
-                        }
-                    }
-                }
-                else
-                {
-                    // Qui determino quando deve valere zero
-                }
-            }
-
-            printf("Fino a qui ci arrivo 2\n");
-            /*
-                Devo dichiarare i gradienti col malloc
-            */
-            correggi_pesi_layer(livello_out, PERCETTRONI_OUT, INPUT_LIV3, gradienti_out, sigmoidi_livello_due, gradienti_bias_out);
-            printf("Fino a qui ci arrivo 3\n");
-            correggi_pesi_layer(livello_due, PERCETTRONI_2, INPUT_LIV2, gradienti_2, sigmoidi_livello_uno, gradienti_bias_2);
-            printf("Fino a qui ci arrivo 4\n");
-            correggi_pesi_layer_uno(livello_uno, PERCETTRONI_1, INPUT_LIV1, gradienti_1, dataset.istanze[indice_dataset].immagine, gradienti_bias_1);
-            printf("Fino a qui ci arrivo 5\n");
-        }
-    }
-
-    // Stampa di debug
-    /* for(int i = 0; i < PERCETTRONI_1; i++) {
-        printf("\nPercettrone esterno %d: w78: %f, bias: %f",i, livello_uno[i].pesi[77], livello_uno[i].bias);
-        if(i < PERCETTRONI_2) {
-            printf("\n\tPercettrone interno %d: w78: %f, bias: %f", i, livello_due[i].pesi[77], livello_due[i].bias);
-            if(i < PERCETTRONI_OUT)
-                printf("\n\t\tPercettrone output %d: w78: %f, bias: %f", i, livello_out[i].pesi[77], livello_out[i].bias);
-        }
-    }*/
-
-    printf("\r");
-}
-
-double** alloca_memoria_bidimensionale(int x, int y) {
-    double **vettore = (double **)malloc(sizeof(double*) * x);
-
-    for(int i = 0; i < x; i++)
-        vettore[i] = (double *)malloc(sizeof(double) * y);
-
-    return vettore;
-}