From 524f33a690b4f39fe1287ed2744ead73b2aa1b42 Mon Sep 17 00:00:00 2001 From: mirimatcode Date: Tue, 24 Mar 2026 14:06:37 +0100 Subject: [PATCH] aggiornamento codice percettroni.h --- AGENTS.md | 5 ++- codice_ricordo | Bin 21616 -> 0 bytes codice_ricordo.c | 22 +--------- percettroni.h | 106 +++++++++++++++++++++++++++-------------------- 4 files changed, 68 insertions(+), 65 deletions(-) delete mode 100755 codice_ricordo diff --git a/AGENTS.md b/AGENTS.md index 231fcdf..b1a2b41 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -30,6 +30,9 @@ gcc -o rete_neurale rete_neurale.c -lm # Automated training with pauses (prevents overheating) ./addestratore.sh + +# Memory leak detection (valgrind) +valgrind --leak-check=full ./codice_ricordo ``` ### Running a Single Test @@ -103,7 +106,7 @@ 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()` 3. Monitor epoch error rates in training output -4. Check for memory leaks with valgrind: `valgrind --leak-check=full ./codice_ricordo` +4. Check for memory leaks with valgrind ## Project Structure - `percettroni.h` - Core neural network (header-only library with implementations) diff --git a/codice_ricordo b/codice_ricordo deleted file mode 100755 index 44b9f84678ecdc86faa8c3734da068838ff81b59..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 21616 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 diff --git a/codice_ricordo.c b/codice_ricordo.c index 176b0d3..8708a6c 100644 --- a/codice_ricordo.c +++ b/codice_ricordo.c @@ -3,32 +3,14 @@ #define EPOCHE 100000 void main() { - ReteNeurale rete = inizializza_rete_neurale(2, 2, 2); + ReteNeurale rete = inizializza_rete_neurale(2, 5, 50, 10); //stampa_pesi_rete(rete); Dataset xor = *crea_dataset_xor(); - //for(int i = 0; i < xor->size; i++) { - // printf("%d\n", xor->istanze[i].classificazione); - //} - - //double **sigmoidi; - - /* for(int epoca = 0; epoca < EPOCHE; epoca++) { - for(int indice_istanza = 0; indice_istanza < xor->size; indice_istanza++) { - sigmoidi = elabora_sigmoidi(rete, xor->istanze[indice_istanza]); - } - } */ - for(int epoca = 0; epoca < EPOCHE; epoca++) { - printf("\nEPOCA %d\n", epoca); + //printf("\nEPOCA %d\n", epoca); if (addestra(&rete, xor)) break; } - - //0:0 -> 0 - /* sigmoidi = elabora_sigmoidi(rete, xor->istanze[0]); - - int previsto = previsione(sigmoidi[rete.size -1][0]); - printf("La previsione per la prima istanza: %d\n", previsto); */ } \ No newline at end of file diff --git a/percettroni.h b/percettroni.h index 6094387..d63684c 100644 --- a/percettroni.h +++ b/percettroni.h @@ -49,16 +49,16 @@ typedef struct double randomico(); Percettrone inzializza_percettrone(int); -ReteNeurale inizializza_rete_neurale(int, int, 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_sigmoidi(ReteNeurale *, Istanza); -double **elabora_gradienti(ReteNeurale, double, double **); -void discesa_gradiente(ReteNeurale, double **, double **); -double calcola_gradiente_disceso(ReteNeurale, int, int, double **); +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); @@ -69,7 +69,7 @@ int previsione(double); void salvaReteNeurale(const char *, ReteNeurale *); ReteNeurale *caricaReteNeurale(const char *); -void stampa_pesi_rete(ReteNeurale); +void stampa_pesi_rete(ReteNeurale *); /* ################# INIZIALIZZAZIONI ################################ @@ -79,6 +79,7 @@ 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) @@ -112,22 +113,28 @@ Layer inizializza_layer(int n_percettroni, int n_pesi) return layer; } -ReteNeurale inizializza_rete_neurale(int numero_layers, int numero_percettroni_iniziali, int numero_input) +ReteNeurale inizializza_rete_neurale(int numero_input, int numero_layers, int numero_percettroni_iniziali, int numero_percettroni_finali) { srand(time(NULL)); ReteNeurale r; r.layers = (Layer *)malloc(sizeof(Layer) * numero_layers); r.size = numero_layers; - // Funzione esponenziale inversa layer 5 + // 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; + //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; - int numero_percettroni_livello = (int)((double)numero_percettroni_iniziali * pow(frazione, esponente)); if (livello == numero_layers - 1) - numero_percettroni_livello = 1; + numero_percettroni_livello = numero_percettroni_finali; + else { + double frazione = (double) (numero_layers - livello) / (double) numero_layers; + 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); @@ -146,19 +153,21 @@ ReteNeurale inizializza_rete_neurale(int numero_layers, int numero_percettroni_i */ // Da eseguire a mano 2 -double **elabora_gradienti(ReteNeurale rete_neurale, double gradiente_errore, double **sigmoidi) +double **elabora_gradienti(ReteNeurale *rete_neurale, double gradiente_errore, double **sigmoidi) { - double **gradienti = (double **)malloc(sizeof(double *) * rete_neurale.size); + 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++) + 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); + gradienti[indice_layer] = (double *)malloc(sizeof(double) * rete_neurale->layers[indice_layer].size); } - // Gradiente del percettrone output - gradienti[rete_neurale.size - 1][0] = gradiente_errore * derivata_sigmoide(sigmoidi[rete_neurale.size - 1][0]); + // 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]); + //Dal gradiente trovato per l'output, mi discendo tutti gli altri discesa_gradiente(rete_neurale, sigmoidi, gradienti); return gradienti; @@ -210,11 +219,11 @@ int previsione(double valore) } // Invocata da elabora_gradienti() -void discesa_gradiente(ReteNeurale rete, double **sigmoidi, double **gradienti) +void discesa_gradiente(ReteNeurale *rete, double **sigmoidi, double **gradienti) { - for (int indice_layer = rete.size - 2; indice_layer >= 0; indice_layer--) + for (int indice_layer = rete->size - 2; indice_layer >= 0; indice_layer--) { - for (int indice_percettrone = 0; indice_percettrone < rete.layers[indice_layer].size; indice_percettrone++) + for (int indice_percettrone = 0; indice_percettrone < rete->layers[indice_layer].size; indice_percettrone++) { double derivata_attivazione = derivata_sigmoide(sigmoidi[indice_layer][indice_percettrone]); double gradiente_disceso = calcola_gradiente_disceso(rete, indice_layer + 1, indice_percettrone, gradienti); @@ -225,39 +234,39 @@ 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 calcola_gradiente_disceso(ReteNeurale *rete, int livello, int indice_peso, double **gradienti) { double sommatoria = 0.0; - for (int indice_percettrone = 0; indice_percettrone < rete.layers[livello].size; indice_percettrone++) + for (int indice_percettrone = 0; indice_percettrone < rete->layers[livello].size; indice_percettrone++) { - sommatoria += (gradienti[livello][indice_percettrone] * rete.layers[livello].percettroni[indice_percettrone].pesi[indice_peso]); + sommatoria += (gradienti[livello][indice_percettrone] * rete->layers[livello].percettroni[indice_percettrone].pesi[indice_peso]); } return sommatoria; } // Da eseguire a mano 1 -double **elabora_sigmoidi(ReteNeurale rete, Istanza istanza) +double **elabora_sigmoidi(ReteNeurale *rete, Istanza istanza) { - double **sigmoidi = (double **)malloc(sizeof(double *) * rete.size); - double *inputs = (double *)malloc(sizeof(double *) * N_INPUTS); + 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]; } - sigmoidi[0] = (double *)malloc(sizeof(double) * rete.layers[0].size); - for (int indice_percettrone = 0; indice_percettrone < rete.layers[0].size; indice_percettrone++) + sigmoidi[0] = (double *)malloc(sizeof(double) * rete->layers[0].size); + for (int indice_percettrone = 0; indice_percettrone < rete->layers[0].size; indice_percettrone++) { - sigmoidi[0][indice_percettrone] = sigmoide(rete.layers[0].percettroni[indice_percettrone], inputs); + sigmoidi[0][indice_percettrone] = sigmoide(rete->layers[0].percettroni[indice_percettrone], inputs); } - for (int indice_layer = 1; indice_layer < rete.size; indice_layer++) + for (int indice_layer = 1; indice_layer < rete->size; indice_layer++) { - sigmoidi[indice_layer] = (double *)malloc(sizeof(double) * rete.layers[indice_layer].size); - for (int indice_percettrone = 0; indice_percettrone < rete.layers[indice_layer].size; indice_percettrone++) + sigmoidi[indice_layer] = (double *)malloc(sizeof(double) * rete->layers[indice_layer].size); + for (int indice_percettrone = 0; indice_percettrone < rete->layers[indice_layer].size; indice_percettrone++) { - sigmoidi[indice_layer][indice_percettrone] = sigmoide(rete.layers[indice_layer].percettroni[indice_percettrone], sigmoidi[indice_layer - 1]); + sigmoidi[indice_layer][indice_percettrone] = sigmoide(rete->layers[indice_layer].percettroni[indice_percettrone], sigmoidi[indice_layer - 1]); } } @@ -338,11 +347,13 @@ byte addestra(ReteNeurale *rete_neurale, Dataset set) //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]); + 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); + + //printf("\tPrevisto: %d, corretto: %d\n", previsto, output_corretto); + if (previsto == output_corretto) { corrette++; } @@ -351,13 +362,20 @@ byte addestra(ReteNeurale *rete_neurale, Dataset set) 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); - + 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("Errore: %f, risposte corrette: %d%\n", errore_totale, (corrette * 100) / set.size); if(corrette == set.size) return 1; @@ -460,17 +478,17 @@ ReteNeurale *caricaReteNeurale(const char *filename) /* ################ STAMPE ############################ */ -void stampa_pesi_rete(ReteNeurale rete) +void stampa_pesi_rete(ReteNeurale *rete) { - for (int indice_layer = 0; indice_layer < rete.size; indice_layer++) + for (int indice_layer = 0; indice_layer < rete->size; indice_layer++) { printf("\nLivello %d", indice_layer); - for (int indice_percettrone = 0; indice_percettrone < rete.layers[indice_layer].size; indice_percettrone++) + for (int indice_percettrone = 0; indice_percettrone < rete->layers[indice_layer].size; indice_percettrone++) { printf("\n\tPercettrone %d", indice_percettrone); - for (int indice_peso = 0; indice_peso < rete.layers[indice_layer].percettroni[indice_percettrone].size; indice_peso++) + for (int indice_peso = 0; indice_peso < rete->layers[indice_layer].percettroni[indice_percettrone].size; indice_peso++) { - printf("\n\t\tPeso %d: %f", indice_peso, rete.layers[indice_layer].percettroni[indice_percettrone].pesi[indice_peso]); + printf("\n\t\tPeso %d: %f", indice_peso, rete->layers[indice_layer].percettroni[indice_percettrone].pesi[indice_peso]); } } }