IA/classificatore_immagini
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Aggiunto qualche printf

Browse Source
This commit is contained in:
mirimatcode
2026-03-25 18:25:38 +01:00
parent 59fae5238b
commit 37c01285ca
4 changed files with 64 additions and 50 deletions
Download Patch File Download Diff File Expand all files Collapse all files
percettroni.h
+55 -43
View File
@@ -15,7 +15,7 @@ char *file_pesi = "rete_mnist.bin";
// 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"
typedef unsigned char byte;
@@ -44,7 +44,7 @@ typedef struct
/*
* 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),
* 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();
@@ -62,7 +62,7 @@ Percettrone inzializza_percettrone(int);
* - 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.
@@ -102,12 +102,12 @@ 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).
*/
@@ -115,31 +115,31 @@ 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 **);
@@ -150,21 +150,21 @@ void discesa_gradiente(ReteNeurale *, double **, double **);
* 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);
// 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);
@@ -201,7 +201,7 @@ int previsione_softmax(double *, int);
* - 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.
*/
@@ -210,7 +210,7 @@ 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 *);
@@ -274,18 +274,21 @@ ReteNeurale inizializza_rete_neurale(int numero_input, int numero_layers, int nu
if (livello == numero_layers - 1)
numero_percettroni_livello = numero_percettroni_finali;
else {
double frazione = (double) (numero_layers - livello) / (double) numero_layers;
else
{
double frazione = (double)(numero_layers - livello) / (double)numero_layers;
numero_percettroni_livello = (int)((double)(numero_percettroni_iniziali * 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);
somma_parametri += (numero_percettroni_livello * numero_input);
}
else {
else
{
r.layers[livello] = inizializza_layer(numero_percettroni_livello, r.layers[livello - 1].size);
somma_parametri += (numero_percettroni_livello * r.layers[livello - 1].size);
}
@@ -309,12 +312,15 @@ double **elabora_gradienti(ReteNeurale *rete_neurale, byte output_corretto, doub
gradienti[indice_layer] = (double *)malloc(sizeof(double) * rete_neurale->layers[indice_layer].size);
}
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;
if(indice_percettrone == output_corretto) {
if (indice_percettrone == output_corretto)
{
gradiente_errore = 1 - sigmoidi[rete_neurale->size - 1][indice_percettrone];
}
else {
else
{
gradiente_errore = 0 - sigmoidi[rete_neurale->size - 1][indice_percettrone];
}
@@ -337,10 +343,10 @@ double sigmoide(Percettrone p, double *valori)
sommatoria += p.bias;
//Sigmoide
// Sigmoide
double risultato = 1.0 / (1.0 + exp(-sommatoria));
//ReLU
//double risultato = sommatoria > 0 ? sommatoria : 0.0f;
// ReLU
// double risultato = sommatoria > 0 ? sommatoria : 0.0f;
// printf(" sommatoria %f -> %f\n",sommatoria, risultato);
@@ -349,19 +355,21 @@ double sigmoide(Percettrone p, double *valori)
double derivata_sigmoide(double valore)
{
double derivata = valore * (1.0 - valore);
double derivata = valore * (1.0 - valore);
return derivata;
}
void softmax(double *input, int size) {
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++) {
for (int i = 0; i < size; i++)
{
input[i] = expf(input[i] - max);
sum += input[i];
}
@@ -378,13 +386,15 @@ int previsione(double valore)
return 0;
}
int previsione_softmax(double *livello_percettroni, int size) {
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])
for (int i = 1; i < size; i++)
{
if (livello_percettroni[i] > livello_percettroni[max])
max = i;
}
@@ -397,7 +407,7 @@ void discesa_gradiente(ReteNeurale *rete, double **sigmoidi, double **gradienti)
{
for (int indice_percettrone = 0; indice_percettrone < rete->layers[indice_layer].size; indice_percettrone++)
{
double derivata_attivazione = derivata_sigmoide(sigmoidi[indice_layer][indice_percettrone]);
double derivata_attivazione = derivata_sigmoide(sigmoidi[indice_layer][indice_percettrone]);
double gradiente_disceso = calcola_gradiente_disceso(rete, indice_layer + 1, indice_percettrone, gradienti);
gradienti[indice_layer][indice_percettrone] = gradiente_disceso * derivata_attivazione;
@@ -452,7 +462,8 @@ double **elabora_sigmoidi(ReteNeurale *rete, Istanza istanza)
void aggiorna_pesi(ReteNeurale *rete_neurale, double **sigmoidi, double **gradienti, Istanza istanza)
{
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++)
{
for (int indice_peso = 0; indice_peso < rete_neurale->layers[rete_neurale->size - 1].percettroni[indice_percettrone].size; indice_peso++)
{
@@ -514,25 +525,26 @@ char addestra(ReteNeurale *rete_neurale, Dataset set)
byte output_corretto = set.istanze[indice_set].classificazione;
double **sigmoidi = elabora_sigmoidi(rete_neurale, set.istanze[indice_set]);
double *sigmoidi_softmax = (double *)malloc(sizeof(double) * rete_neurale->layers[rete_neurale->size - 1].size);
memcpy(sigmoidi_softmax, sigmoidi[rete_neurale->size - 1], rete_neurale->layers[rete_neurale->size - 1].size * sizeof(double));
double **gradienti = elabora_gradienti(rete_neurale, output_corretto, sigmoidi);
int previsto = previsione_softmax(sigmoidi_softmax, rete_neurale->layers[rete_neurale->size - 1].size);
if (previsto == output_corretto) {
if (previsto == output_corretto)
{
corrette++;
}
aggiorna_pesi(rete_neurale, sigmoidi, gradienti, set.istanze[indice_set]);
for(int i = 0; i < rete_neurale->size; i++)
for (int i = 0; i < rete_neurale->size; i++)
free(gradienti[i]);
free(gradienti);
for(int i = 0; i < rete_neurale->size; i++)
for (int i = 0; i < rete_neurale->size; i++)
free(sigmoidi[i]);
free(sigmoidi);
free(sigmoidi_softmax);
@@ -542,7 +554,7 @@ char addestra(ReteNeurale *rete_neurale, Dataset set)
printf("Risposte corrette: %d%%\n", percentuale);
if(percentuale >= TOLLERANZA)
if (percentuale >= TOLLERANZA)
return 1;
else
return 0;