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

messo due codici da deepseek, per classificare il singolo e il multi classe

Browse Source
This commit is contained in:
mirimatcode
2025-02-25 12:03:21 +01:00
parent 077952260a
commit 3876c7c5b5
9 changed files with 619 additions and 216 deletions
Download Patch File Download Diff File Expand all files Collapse all files

55
classificatore_singolo.c
View File

@@ -3,8 +3,8 @@
// Scelgo quale categoria voglio identificare. nel caso dello xor -1
#define CATEGORIA 7
#define NUM_LAYERS 4
#define PERCETTRONI_LAYER_0 32
#define NUM_LAYERS 7
#define PERCETTRONI_LAYER_0 128
#define MAX_EPOCHE 10
byte get_out_corretto(byte);
@@ -37,7 +37,6 @@ 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;
printf("Numero elementi nel dataset: %d\n", set.size);
@@ -45,7 +44,6 @@ void main()
// ADDESTRAMENTO
for (int i = 0; i < MAX_EPOCHE; i++)
{
printf("Epoca %d\n", i);
stampa_tempo(tempo_epoche, i);
corrette = 0;
@@ -53,61 +51,20 @@ void main()
for (int indice_set = 0; indice_set < set.size; indice_set++)
{
//printf("Qui ci arrivo %d\n", 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[NUM_LAYERS - 1][0]) == output_corretto)
if (previsione(sigmoidi[rete_neurale.size - 1][0]) == output_corretto)
corrette++;
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++)
{
gradienti[indice_layer] = (double *)malloc(sizeof(double) * rete_neurale.layers[indice_layer].size);
}
// Derivata funzione di perdita
double gradiente_errore = (output_corretto - sigmoidi[NUM_LAYERS - 1][0]);
double gradiente_errore = (output_corretto - sigmoidi[rete_neurale.size - 1][0]);
errore_totale += pow(gradiente_errore, 2);
// Derivata funzione attivazione
double derivata_sigmoide_out = sigmoidi[NUM_LAYERS - 1][0] * (1.0 - sigmoidi[NUM_LAYERS - 1][0]);
double **gradienti = elabora_gradienti(rete_neurale, gradiente_errore, sigmoidi);
// Gradiente del percettrone output
gradienti[NUM_LAYERS - 1][0] = gradiente_errore * derivata_sigmoide_out;
aggiorna_pesi(&rete_neurale, sigmoidi, gradienti, set.istanze[indice_set]);
discesa_gradiente(rete_neurale, sigmoidi, gradienti);
// 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++)
{
// Determino gradiente del peso
double gradiente_peso = gradienti[NUM_LAYERS - 1][0] * sigmoidi[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;
// 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
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]);
}
else
{
correggi_pesi_percettrone_byte(&rete_neurale.layers[0].percettroni[indice_percettrone], set.istanze[indice_set], gradienti[0][indice_percettrone], indice_percettrone);
}
}
}
}
printf("Errore: %f, risposte corrette: %d%\n", errore_totale / set.size, (corrette * 100) / set.size);