dovrebbe convergere su mnist, da completare con persistenza e visualizzatore
This commit is contained in:
@@ -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
|
||||
gcc -o classificatore_singolo_mnist classificatore_singolo.c -lm
|
||||
# Main classifier (MNIST) - multi-class classifier (default)
|
||||
gcc -o classificatore_mnist classificatore.c -lm
|
||||
|
||||
# XOR test/demo - simple test to verify neural network works
|
||||
gcc -o codice_ricordo codice_ricordo.c -lm
|
||||
# XOR test - quick validation that neural network converges
|
||||
# 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
|
||||
gcc -o rete_neurale rete_neurale.c -lm
|
||||
# Training with pre-trained weights
|
||||
./classificatore_mnist_50_epoche
|
||||
```
|
||||
|
||||
### Running Tests
|
||||
```bash
|
||||
# Run XOR validation test (quick sanity check for neural network)
|
||||
./codice_ricordo
|
||||
# Quick test - compile and run MNIST classifier
|
||||
gcc -o classificatore_mnist classificatore.c -lm && ./classificatore_mnist
|
||||
|
||||
# Run full training loop with existing compiled binary
|
||||
./classificatore_singolo_mnist
|
||||
# Memory leak detection
|
||||
valgrind --leak-check=full ./classificatore_mnist
|
||||
|
||||
# Automated training with pauses (prevents overheating)
|
||||
./addestratore.sh
|
||||
|
||||
# Memory leak detection (valgrind)
|
||||
valgrind --leak-check=full ./codice_ricordo
|
||||
# Run pre-compiled binary (50 epochs)
|
||||
./classificatore_mnist_50_epoche
|
||||
```
|
||||
|
||||
### Running a Single Test
|
||||
```bash
|
||||
# Compile and run XOR test (single test case)
|
||||
gcc -o codice_ricordo codice_ricordo.c -lm && ./codice_ricordo
|
||||
# Compile and run MNIST classifier (single test)
|
||||
gcc -o classificatore_mnist classificatore.c -lm && ./classificatore_mnist
|
||||
|
||||
# Compile and run classifier with specific category
|
||||
gcc -o classificatore_singolo_mnist classificatore_singolo.c -lm && ./classificatore_singolo_mnist
|
||||
# For XOR test - edit percettroni.h first, then:
|
||||
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)
|
||||
- `LRE = 0.1` (learning rate - was 1.414, now 0.1)
|
||||
- `soglia_sigmoide = 0.5` (sigmoid threshold for binary classification)
|
||||
## Key Constants (from percettroni.h)
|
||||
- `LRE = 0.1` (learning rate)
|
||||
- `soglia_sigmoide = 0.5` (sigmoid threshold)
|
||||
- `file_pesi = "rete_pesi.bin"` (model weights file)
|
||||
- `SOFTMAX = 1` (use softmax for multi-class prediction)
|
||||
|
||||
### Dataset Configuration
|
||||
In `percettroni.h`, uncomment the desired dataset section:
|
||||
- XOR: `#include "xor_manager.h"` (for testing - currently active)
|
||||
- MNIST: Uncomment mnist includes and set file paths
|
||||
- CIFAR-10: Uncomment cifar-10 includes and file paths
|
||||
## Dataset Configuration
|
||||
In `percettroni.h`, include the desired dataset manager:
|
||||
- MNIST: `#include "mnist/mnist_manager.h"` (currently active)
|
||||
- XOR: `#include "xor_manager.h"` (for testing)
|
||||
- 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)
|
||||
2. Visual inspection of weight outputs via `stampa_pesi_rete()`
|
||||
1. `xor_manager.h` - XOR validation (quick convergence test)
|
||||
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)
|
||||
- `classificatore_singolo.c` - Single-category classifier main program
|
||||
- `codice_ricordo.c` - XOR test/demo
|
||||
- `xor_manager.h` - XOR dataset for testing
|
||||
- `percettroni.h` - Core neural network (header-only library)
|
||||
- `classificatore.c` - Main classifier program
|
||||
- `xor_manager.h` - XOR dataset (4 samples)
|
||||
- `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
|
||||
- Verify dataset loading before training loop
|
||||
- Reference `xor_manager.h` for minimal working example
|
||||
- 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)
|
||||
- Use `addestratore.sh` with sleep intervals to prevent overheating
|
||||
- Memory allocated dynamically based on network architecture
|
||||
- Training is CPU-intensive (minutes per epoch)
|
||||
- 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)
|
||||
|
||||
@@ -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.
|
||||
|
||||
@@ -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
|
||||
@@ -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%
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
Executable
BIN
Binary file not shown.
@@ -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);
|
||||
}
|
||||
}
|
||||
Binary file not shown.
@@ -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;
|
||||
}
|
||||
}
|
||||
+11
-6
@@ -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).istanze = istanze;
|
||||
set->size = numero_righe;
|
||||
set->istanze = istanze;
|
||||
|
||||
fclose(file);
|
||||
return set;
|
||||
|
||||
+256
-104
@@ -5,11 +5,7 @@
|
||||
|
||||
char *file_pesi = "rete_pesi.bin";
|
||||
|
||||
// #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 "mnist/mnist_manager.h"
|
||||
|
||||
// #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 ################################
|
||||
*/
|
||||
// Questa funzione genera un valore reale random compreso nell'intervallo [-1, 1]
|
||||
* 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.
|
||||
*/
|
||||
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,15 +278,20 @@ 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);
|
||||
}
|
||||
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, double gradiente_errore, double **sigmoidi)
|
||||
double **elabora_gradienti(ReteNeurale *rete_neurale, byte output_corretto, 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++)
|
||||
gradienti[rete_neurale->size - 1][indice_percettrone] = gradiente_errore * derivata_sigmoide(sigmoidi[rete_neurale->size - 1][indice_percettrone]);
|
||||
for(int indice_percettrone = 0; indice_percettrone < rete_neurale->layers[rete_neurale->size - 1].size; indice_percettrone++) {
|
||||
double gradiente_errore = 0.0;
|
||||
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]);
|
||||
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(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];
|
||||
|
||||
-162
@@ -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;
|
||||
}
|
||||
Binary file not shown.
Reference in New Issue
Block a user