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

configurato per mnist 1000 epoche pronto al test

Browse Source
This commit is contained in:
mirimatcode
2025-02-22 15:43:02 +01:00
parent e787843a67
commit 67dfb2fe92
5 changed files with 435 additions and 322 deletions
Download Patch File Download Diff File Expand all files Collapse all files

245
classificatore_singolo.c
View File

@@ -1,186 +1,197 @@
#include <time.h>
#include "percettroni.h"
//Scelgo quale categoria voglio identificare. nel caso dello xor -1
#define CATEGORIA -1
#define NUM_LAYERS 3
#define PERCETTRONI_LAYER_0 4
#define MAX_EPOCHE 1000000
// Scelgo quale categoria voglio identificare. nel caso dello xor -1
#define CATEGORIA 7
#define NUM_LAYERS 4
#define PERCETTRONI_LAYER_0 64
#define MAX_EPOCHE 1000
byte get_out_corretto(byte);
void stampa_layer_indirizzo(Layer*);
void stampa_layer_indirizzo(Layer *);
void stampa_tempo(time_t[], int);
void main() {
void main()
{
time_t tempo_epoche[MAX_EPOCHE];
srand(time(NULL));
Dataset *set_appoggio = crea_dataset_xor();//get_dataset(file_immagini, file_label);
Dataset *set_appoggio = get_dataset(file_immagini, file_label);
if(set_appoggio == NULL)
if (set_appoggio == NULL)
return;
Dataset set = *set_appoggio;
free(set_appoggio);
ReteNeurale rete_neurale;
ReteNeurale *puntatore_rete = caricaReteNeurale(file_pesi);
if(puntatore_rete == NULL) {
if (puntatore_rete == NULL)
{
rete_neurale = inizializza_rete_neurale(NUM_LAYERS, PERCETTRONI_LAYER_0, N_INPUTS);
} else {
}
else
{
rete_neurale = *puntatore_rete;
free(puntatore_rete);
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);
//ADDESTRAMENTO
for(int i = 0; i < MAX_EPOCHE; i++) {
//printf("Epoca %d\n", i);
//stampa_tempo(tempo_epoche, i);
int corrette = 0;
double errore_totale = 0.0;
// ADDESTRAMENTO
for (int i = 0; i < MAX_EPOCHE; i++)
{
/* if (corrette == 4)
{
printf("\nConvergo in epoche: %d\n", i);
for(int indice_set = 0; indice_set < set.size; indice_set++) {
// 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]);
//sigmoidi è un array bidimensionale, la prima dimensione identifica il layer, la seconda il percettrone nel layer
// sigmoidi[indice_layer][indice_percettrone]
double **sigmoidi = (double **)malloc(sizeof(double*) * NUM_LAYERS);
//Il layer di ingresso ha bisogno di una funzione a parte perchè prende byte come input
sigmoidi[0] = (double*)malloc(sizeof(double) * PERCETTRONI_LAYER_0);
sigmoidi[0] = funzioni_attivazione_layer_byte(rete_neurale.layers[0], set.istanze[indice_set].dati);
//Calcolo le sigmoidi in tutti gli altri layer
for(int j = 1; j < NUM_LAYERS; j++) {
sigmoidi[j] = (double*)malloc(sizeof(double) * rete_neurale.layers[j].size);
sigmoidi[j] = funzioni_attivazione_layer_double(rete_neurale.layers[j], sigmoidi[j-1]);
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);
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]);
/* 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]); */
byte output_corretto = get_out_corretto(set.istanze[indice_set].classificazione);
//Se prevede male
if(previsione(sigmoidi[NUM_LAYERS-1][0]) != output_corretto) {
double **gradienti = (double **)malloc(sizeof(double *) * NUM_LAYERS);
//gradienti è un array bidimensionale, la prima dimensione identifica il layer, la seconda il percettrone nel layer
//gradienti[indice_layer][indice_percettrone]
//Questo vettore identifica i gradienti dei percettroni
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);
}
//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);
}
/* Gestione dell'errore
Funzione di perdita -> errore quadratico medio: (risultato_esatto - previsione)^2
Gradiente dell'errore rispetto all'attivazione = derivata(funzione_perdita) * derivata(sigmoide_out)
= -(risultato_esatto - previsione) * (sigmoide_out * (1 - sigmoide_out))
//Per ogni percettrone sugli altri layer:
- calcolare derivata della propria sigmoide
- gradiente dell'errore retropropagato = peso del ne
*/
//Derivata funzione di perdita
double gradiente_errore = -(output_corretto - sigmoidi[NUM_LAYERS-1][0]);
//Derivata funzione attivazione
double derivata_sigmoide_out = sigmoidi[NUM_LAYERS-1][0] * (1 - sigmoidi[NUM_LAYERS-1][0]);
if (derivata_sigmoide_out == 0.0) derivata_sigmoide_out = 1;
//Gradiente del percettrone output
gradienti[NUM_LAYERS-1][0] = gradiente_errore * derivata_sigmoide_out;
// 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]);
//Ricorda di partire dal penultimo layer in quanto l'ultimo è già fatto
discesa_gradiente(rete_neurale, sigmoidi, gradienti);
errore_totale += pow(gradiente_errore, 2);
/* A questo punto ho tutti i gradienti dei percettroni, non mi resta che trovare i gradienti dei pesi e correggerli
*/
// 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;
//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;
// Gradiente del percettrone output
gradienti[NUM_LAYERS - 1][0] = gradiente_errore * derivata_sigmoide_out;
//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);
}
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);
}
}
//gradienti[NUM_LAYERS-1][0] = (output_corretto - sigmoidi[NUM_LAYERS-1][0]);
errore_totale += gradienti[NUM_LAYERS-1][0];
//correggi_layer_interni(&rete_neurale, gradienti, sigmoidi);
//correggi_layer_input(&rete_neurale.layers[0], gradienti, sigmoidi, set.istanze[indice_set].dati, NUM_LAYERS);
}
else
if (previsione(sigmoidi[NUM_LAYERS - 1][0]) == output_corretto)
{
corrette++;
}
}
if(corrette == 4) {
printf("\tConvergo all'epoca %d\n", i);
break;
printf("Errore: %f, risposte corrette: %d/%d\n", errore_totale / 10000, corrette, set.size);
// printf("\tRisposte corrette: %d\n", corrette);
/* 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_sigmoidi(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("Errore: %f\n", errore_totale / 4);
printf("\tRisposte corrette: %d\n", corrette);
if(corrette == set.size) {
break;
}
} */
}
//salvaReteNeurale(file_pesi, &rete_neurale);
salvaReteNeurale(file_pesi, &rete_neurale);
}
//Questa funzione ritorna 1 se la categoria è quella che voglio individuare, altrimenti 0
byte get_out_corretto(byte categoria) {
if(CATEGORIA != -1) {
if(categoria == CATEGORIA)
// Questa funzione ritorna 1 se la categoria è quella che voglio individuare, altrimenti 0
byte get_out_corretto(byte categoria)
{
if (CATEGORIA != -1)
{
if (categoria == CATEGORIA)
return 1;
else
return 0;
}
else return categoria;
else
return categoria;
}
void stampa_layer_indirizzo(Layer *layer) {
for(int i = 0; i < layer->size; i++) {
void stampa_layer_indirizzo(Layer *layer)
{
for (int i = 0; i < layer->size; i++)
{
printf("Percettrone %d ->", i);
for(int j = 0; j < layer->percettroni->size; j++) {
printf("\t peso %d, valore: %f",j, layer->percettroni[i].pesi[j]);
for (int j = 0; j < layer->percettroni->size; j++)
{
printf("\t peso %d, valore: %f", j, layer->percettroni[i].pesi[j]);
layer->percettroni[i].pesi[j] += 1;
}
printf("\n");
}
}
void stampa_tempo(time_t tempo_epoche[], int i) {
void stampa_tempo(time_t tempo_epoche[], int i)
{
time(&tempo_epoche[i]);
if(i > 0) {
double tempo_trascorso_epoca = difftime(tempo_epoche[i], tempo_epoche[i-1]);
if (i > 0)
{
double tempo_trascorso_epoca = difftime(tempo_epoche[i], tempo_epoche[i - 1]);
double tempo_trascorso_totale = difftime(tempo_epoche[i], tempo_epoche[0]);
int minuti_epoca = (int)tempo_trascorso_epoca / 60;
int secondi_epoca = (int)tempo_trascorso_epoca % 60;