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

correggere aggiornamento dei pesi

Browse Source
This commit is contained in:
mirimatcode
2025-02-24 01:10:20 +01:00
parent 7ba92b7a6d
commit a215e4785a
10 changed files with 366 additions and 131 deletions
Download Patch File Download Diff File Expand all files Collapse all files

172
classificatore_singolo.c
View File

@@ -5,25 +5,30 @@
#define CATEGORIA 7
#define NUM_LAYERS 4
#define PERCETTRONI_LAYER_0 32
#define MAX_EPOCHE 100
#define MAX_EPOCHE 10
//1 relu, 2 sigmoide
// 1 relu, 2 sigmoide
#define TIPO_FUNZIONE 2
byte get_out_corretto(byte);
void stampa_layer_indirizzo(Layer *);
void stampa_tempo(time_t[], int);
void debug(int);
void main()
{
srand(time(NULL));
time_t tempo_epoche[MAX_EPOCHE];
srand(time(NULL));
/*
################# Inizializzazione rete e caricamento Dataset ################################
*/
Dataset *set_appoggio = get_dataset(file_immagini, file_label);
if (set_appoggio == NULL)
return;
Dataset set = *set_appoggio;
free(set_appoggio);
@@ -31,7 +36,7 @@ void main()
ReteNeurale *puntatore_rete = caricaReteNeurale(file_pesi);
if (puntatore_rete == NULL)
{
rete_neurale = inizializza_rete_neurale(NUM_LAYERS, PERCETTRONI_LAYER_0, N_INPUTS);
rete_neurale = inizializza_rete_neurale_feed_forward(NUM_LAYERS, PERCETTRONI_LAYER_0, N_INPUTS);
}
else
{
@@ -40,31 +45,75 @@ void main()
printf("Caricate impostazioni rete neurale da file\n");
}
//rete_neurale = inizializza_rete_neurale(NUM_LAYERS, PERCETTRONI_LAYER_0, N_INPUTS);
int corrette = 0;
// rete_neurale = inizializza_rete_neurale(NUM_LAYERS, PERCETTRONI_LAYER_0, N_INPUTS);
printf("Numero elementi nel dataset: %d\n", set.size);
// ADDESTRAMENTO
/*
################# Addestramento ################################
*/
int corrette = 0;
for (int i = 0; i < MAX_EPOCHE; i++)
{
/*
################# inizializzazione variabili per l'epoca in corso ################################
*/
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 -1; indice_set++)
/* for (int xxx = 0; xxx < rete_neurale.size; xxx++)
{
for (int count = 0; count < rete_neurale.layers[xxx].size; count++)
{
for (int count_2 = 0; count_2 < rete_neurale.layers[xxx].percettroni[count].size; count_2++)
{
printf("[%d][%d]: %f\t", count, count_2, rete_neurale.layers[xxx].percettroni[count].pesi[count_2]);
}
printf("\n");
}
} */
for (int indice_set = 0; indice_set < set.size; indice_set++)
{
//printf("Qui ci arrivo %d\n", indice_set);
double **funzioni_attivazione = elabora_funzioni_attivazione(rete_neurale, set.istanze[indice_set], TIPO_FUNZIONE);
/*
################# Feed Forward ################################
*/
// Elabora le funzioni di attivazione in base al tipo scelto. Ritorna un vettore bidimensionale dove la prima dimensione rappresenta l'indice del layer, la seconda quella del percettrone nel layer
/* for(int k = 0; k < rete_neurale.size; k++)
for(int j = 0; j < rete_neurale.layers[k].size; j++)
printf("sigmoide[%d][%d] = %f\n", k, j, funzioni_attivazione[k][j]); */
double **funzioni_attivazione = elabora_funzioni_attivazione(&rete_neurale, set.istanze[indice_set], TIPO_FUNZIONE);
/*
################# Previsione ################################
*/
// Siccome il dataset da il numero della categoria a cui appartiene l'immagine, se la categoria è quella che cerco io output_corretto varrà 1 altrimenti 0
byte output_corretto = get_out_corretto(set.istanze[indice_set].classificazione);
double **gradienti = (double **)malloc(sizeof(double *) * NUM_LAYERS);
if (previsione(funzioni_attivazione[rete_neurale.size - 1][0]) == output_corretto)
corrette++;
/*
################# Funzione di perdita (errore) ################################
*/
// printf("funzione_attivazione_out: %f", funzioni_attivazione[rete_neurale.size - 1][0]);
// Derivata funzione di perdita
double errore = (output_corretto - funzioni_attivazione[rete_neurale.size - 1][0]);
// Sommo la funzione di perdita a errore_totale per stampare alla fine dell'epoca l'errore medio
errore_totale += pow(errore, 2) * 0.5;
/*
################# Retropropagazione ################################
*/
/* double **gradienti = (double **)malloc(sizeof(double *) * NUM_LAYERS);
// Alloco la dimensione per ogni layer
for (int indice_layer = 0; indice_layer < NUM_LAYERS; indice_layer++)
@@ -72,40 +121,43 @@ void main()
gradienti[indice_layer] = (double *)malloc(sizeof(double) * rete_neurale.layers[indice_layer].size);
}
// Derivata funzione di perdita
// printf("output_corretto = %d, previsione: %f\n", output_corretto, funzioni_attivazione[NUM_LAYERS - 1][0]);
double gradiente_errore = (output_corretto - funzioni_attivazione[NUM_LAYERS - 1][0]);
errore_totale += pow(gradiente_errore, 2) * 0.5;
// Derivata funzione attivazione
double derivata_funzione_out = derivata_sigmoide(funzioni_attivazione[NUM_LAYERS - 1][0]);
// if (derivata_funzione_out == 0.0) derivata_funzione_out = 1;
// Gradiente del percettrone output
gradienti[NUM_LAYERS - 1][0] = gradiente_errore * derivata_funzione_out;
gradienti[NUM_LAYERS - 1][0] = errore * derivata_funzione_out;
//Crasha nella discesa del gradiente all'immagine indice 16 quando metto troppi percettroni
discesa_gradiente(rete_neurale, funzioni_attivazione, gradienti, TIPO_FUNZIONE);
discesa_gradiente(rete_neurale, funzioni_attivazione, gradienti, TIPO_FUNZIONE); */
double **gradienti = discesa_gradiente(rete_neurale, funzioni_attivazione, errore, TIPO_FUNZIONE);
/*
################# Aggiornamento dei pesi ################################
*/
/*
**** SISTEMARE LA CORREZIONE IN VISTA DELLE ULTIME MODIFICHE PERCHÈ NON CORREGGE E MI SETTA TUTTI I PESI A NAN *****
*/
// A questo punto ho tutti i gradienti dei percettroni, non mi resta che trovare i gradienti dei pesi e correggerli
// Correggo il livello output
for (int indice_peso = 0; indice_peso < rete_neurale.layers[NUM_LAYERS - 1].percettroni[0].size; indice_peso++)
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[NUM_LAYERS - 1][0] * funzioni_attivazione[NUM_LAYERS - 2][indice_peso];
rete_neurale.layers[NUM_LAYERS - 1].percettroni[0].pesi[indice_peso] += gradiente_peso * LRE;
double gradiente_peso = gradienti[rete_neurale.size - 1][0] * funzioni_attivazione[rete_neurale.size - 2][indice_peso];
rete_neurale.layers[rete_neurale.size - 1].percettroni[0].pesi[indice_peso] += gradiente_peso * LRE;
}
rete_neurale.layers[NUM_LAYERS - 1].percettroni[0].bias += gradienti[NUM_LAYERS - 1][0] * 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)
/* // Applico la correzione dal penultimo layer andando indietro fino al secondo (il primo si fa diverso)
for (int indice_layer = NUM_LAYERS - 2; indice_layer >= 0; indice_layer--)
{
// Applico la correzione a tutti i percettroni del layer dal primo a seguire
@@ -121,35 +173,25 @@ void main()
correggi_pesi_percettrone_byte(&rete_neurale.layers[0].percettroni[indice_percettrone], set.istanze[indice_set], gradienti[0][indice_percettrone], indice_percettrone);
}
}
}
if (previsione(funzioni_attivazione[NUM_LAYERS - 1][0]) == output_corretto)
{
corrette++;
}
} */
}
errore_totale /= 10000;
errore_totale /= set.size;
double percentuale = (corrette * 100) / set.size;
printf("Errore: %f, accuratezza: %.2f%\n", errore_totale, percentuale);
// printf("\tRisposte corrette: %d\n", corrette);
printf("Errore: %f, accuratezza: %.2f%, corrette: %d\n", errore_totale, percentuale, corrette);
/* if (i == MAX_EPOCHE - 1)
// For di debug
/* for (int count = 0; count < rete_neurale.size; count++)
{
printf("\nUltima epoca (%d), stato della rete:\n", i);
double **risultato;
for (int j = 0; j < 4; j++)
for (int count_2 = 0; count_2 < rete_neurale.layers[count].size; count_2++)
{
risultato = elabora_funzioni_attivazione(rete_neurale, set.istanze[j]);
printf("Input: [%d,%d] -> probabilità: %f -> previsione: %d -> risultato attesto: %d\n", set.istanze[j].dati[0], set.istanze[j].dati[1], risultato[NUM_LAYERS - 1][0], previsione(risultato[NUM_LAYERS - 1][0]), set.istanze[j].classificazione);
for (int k = 0; k < rete_neurale.size; k++)
for (int j = 0; j < rete_neurale.layers[k].size; j++)
printf("sigmoide[%d][%d] = %f\n", k, j, risultato[k][j]);
printf("[%d][%d]: %f\t", count, count_2, gradienti[count][count_2]);
}
printf("\n");
} */
}
salvaReteNeurale(file_pesi, &rete_neurale);
// salvaReteNeurale(file_pesi, &rete_neurale);
}
// Questa funzione ritorna 1 se la categoria è quella che voglio individuare, altrimenti 0
@@ -181,6 +223,7 @@ void stampa_layer_indirizzo(Layer *layer)
}
void stampa_tempo(time_t tempo_epoche[], int i)
{
time(&tempo_epoche[i]);
@@ -195,4 +238,23 @@ void stampa_tempo(time_t tempo_epoche[], int i)
printf("Tempo dall'epoca precedente: %d:%d\n", minuti_epoca, secondi_epoca);
printf("Tempo dall'inizio: %d:%d\n", minuti_totali, secondi_totali);
}
}
}
void debug(int indice)
{
printf("qui ci arrivo %d", indice);
}
/* if (i == MAX_EPOCHE - 1)
{
printf("\nUltima epoca (%d), stato della rete:\n", i);
double **risultato;
for (int j = 0; j < 4; j++)
{
risultato = elabora_funzioni_attivazione(rete_neurale, set.istanze[j]);
printf("Input: [%d,%d] -> probabilità: %f -> previsione: %d -> risultato attesto: %d\n", set.istanze[j].dati[0], set.istanze[j].dati[1], risultato[NUM_LAYERS - 1][0], previsione(risultato[NUM_LAYERS - 1][0]), set.istanze[j].classificazione);
for (int k = 0; k < rete_neurale.size; k++)
for (int j = 0; j < rete_neurale.layers[k].size; j++)
printf("sigmoide[%d][%d] = %f\n", k, j, risultato[k][j]);
}
} */