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

ottimizzato il codice, messo relu(ma non attivato), pronto per prossima sessione di test

Browse Source
This commit is contained in:
mirimatcode
2025-02-22 18:48:02 +01:00
parent 67dfb2fe92
commit daa34cb8bc
9 changed files with 170 additions and 88 deletions
Download Patch File Download Diff File Expand all files Collapse all files

53
classificatore_singolo.c
View File

@@ -5,7 +5,10 @@
#define CATEGORIA 7
#define NUM_LAYERS 4
#define PERCETTRONI_LAYER_0 64
#define MAX_EPOCHE 1000
#define MAX_EPOCHE 10
//1 relu, 2 sigmoide
#define TIPO_FUNZIONE 2
byte get_out_corretto(byte);
void stampa_layer_indirizzo(Layer *);
@@ -45,34 +48,19 @@ void main()
// ADDESTRAMENTO
for (int i = 0; i < MAX_EPOCHE; i++)
{
/* if (corrette == 4)
{
printf("\nConvergo in epoche: %d\n", i);
// stampa_risultati_layer_multi(p_ext_1, p_ext_2, pout);
for (int j = 0; j < 4; j++)
{
double **risultato = elabora_sigmoidi(rete_neurale, set.istanze[j]);
printf("Input: [%d,%d] -> probabilità: %f -> risultato atteso: %d\n", set.istanze[j].dati[0], set.istanze[j].dati[1], risultato[NUM_LAYERS - 1][0], set.istanze[j].classificazione);
}
break;
} */
// printf("Epoca %d\n", i);
// stampa_tempo(tempo_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 -1; indice_set++)
{
//printf("Qui ci arrivo %d\n", indice_set);
double **sigmoidi = elabora_sigmoidi(rete_neurale, set.istanze[indice_set]);
double **funzioni_attivazione = elabora_funzioni_attivazione(rete_neurale, set.istanze[indice_set], TIPO_FUNZIONE);
/* 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, sigmoidi[k][j]); */
printf("sigmoide[%d][%d] = %f\n", k, j, funzioni_attivazione[k][j]); */
byte output_corretto = get_out_corretto(set.istanze[indice_set].classificazione);
@@ -87,19 +75,19 @@ void main()
// Derivata funzione di perdita
// printf("output_corretto = %d, previsione: %f\n", output_corretto, sigmoidi[NUM_LAYERS - 1][0]);
double gradiente_errore = (output_corretto - sigmoidi[NUM_LAYERS - 1][0]);
// 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);
errore_totale += pow(gradiente_errore, 2) * 0.5;
// Derivata funzione attivazione
double derivata_sigmoide_out = sigmoidi[NUM_LAYERS - 1][0] * (1.0 - sigmoidi[NUM_LAYERS - 1][0]);
// if (derivata_sigmoide_out == 0.0) derivata_sigmoide_out = 1;
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_sigmoide_out;
gradienti[NUM_LAYERS - 1][0] = gradiente_errore * derivata_funzione_out;
discesa_gradiente(rete_neurale, sigmoidi, gradienti);
discesa_gradiente(rete_neurale, funzioni_attivazione, gradienti, TIPO_FUNZIONE);
// A questo punto ho tutti i gradienti dei percettroni, non mi resta che trovare i gradienti dei pesi e correggerli
@@ -107,7 +95,7 @@ void main()
for (int indice_peso = 0; indice_peso < rete_neurale.layers[NUM_LAYERS - 1].percettroni[0].size; indice_peso++)
{
// Determino gradiente del peso
double gradiente_peso = gradienti[NUM_LAYERS - 1][0] * sigmoidi[NUM_LAYERS - 2][indice_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;
}
rete_neurale.layers[NUM_LAYERS - 1].percettroni[0].bias += gradienti[NUM_LAYERS - 1][0] * LRE;
@@ -121,7 +109,7 @@ void main()
// 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]);
correggi_pesi_percettrone_double(&rete_neurale.layers[indice_layer].percettroni[indice_percettrone], indice_layer, funzioni_attivazione, gradienti[indice_layer][indice_percettrone]);
}
else
{
@@ -130,13 +118,14 @@ void main()
}
}
if (previsione(sigmoidi[NUM_LAYERS - 1][0]) == output_corretto)
if (previsione(funzioni_attivazione[NUM_LAYERS - 1][0]) == output_corretto)
{
corrette++;
}
}
printf("Errore: %f, risposte corrette: %d/%d\n", errore_totale / 10000, corrette, set.size);
errore_totale /= 10000;
printf("Errore: %f, risposte corrette: %d/%d\n", errore_totale, corrette, set.size);
// printf("\tRisposte corrette: %d\n", corrette);
/* if (i == MAX_EPOCHE - 1)
@@ -145,7 +134,7 @@ void main()
double **risultato;
for (int j = 0; j < 4; j++)
{
risultato = elabora_sigmoidi(rete_neurale, set.istanze[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++)