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

243
percettroni.h
View File

@@ -40,15 +40,20 @@ typedef struct
} ReteNeurale;
double randomico();
double *get_double_from_bytes(Istanza);
Percettrone inzializza_percettrone(int);
ReteNeurale inizializza_rete_neurale(int, int, int);
Layer inizializza_layer(int, int);
ReteNeurale inizializza_rete_neurale_deep_feed_forward(int, int, int);
ReteNeurale inizializza_rete_neurale_feed_forward(int, int, int);
double funzione_attivazione(Percettrone p, double*, int);
double **elabora_funzioni_attivazione(ReteNeurale, Istanza, int);
void discesa_gradiente(ReteNeurale, double **, double **, int);
double calcola_gradiente_disceso(ReteNeurale, int, int, double **);
double funzione_attivazione_percettrone(Percettrone p, double*, int);
double **elabora_funzioni_attivazione(ReteNeurale*, Istanza, int);
double *elabora_funzioni_attivazione_layer(Layer, double*, int);
double **discesa_gradiente(ReteNeurale, double **, double, int);
double *calcola_gradiente_output(Layer layer, double*, double, int);
double calcola_gradiente_disceso(ReteNeurale, int, int, double **, double);
void correggi_pesi_percettrone_double(Percettrone *, int, double **, double);
void correggi_pesi_percettrone_byte(Percettrone *, Istanza, double, int);
@@ -62,7 +67,7 @@ void salvaReteNeurale(const char *, ReteNeurale *);
ReteNeurale *caricaReteNeurale(const char *);
/*
################# INIZIALIZZAZIONI ################################
################# INIZIALIZZAZIONI E METODI UTILI ################################
*/
// Questa funzione genera un valore reale random compreso nell'intervallo [-1, 1]
double randomico()
@@ -101,14 +106,13 @@ 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_feed_forward(int numero_layers, int numero_percettroni_iniziali, int numero_input) {
ReteNeurale r;
r.layers = (Layer *)malloc(sizeof(Layer) * numero_layers);
r.size = numero_layers;
// Funzione esponenziale inversa layer 5
/* for (int livello = 0; livello < numero_layers; livello++)
for (int livello = 0; livello < numero_layers; livello++)
{
double esponente = (double)livello / (double)numero_layers;
double frazione = (double)1 / (double)numero_percettroni_iniziali;
@@ -124,7 +128,16 @@ ReteNeurale inizializza_rete_neurale(int numero_layers, int numero_percettroni_i
r.layers[livello] = inizializza_layer(numero_percettroni_livello, numero_input);
else
r.layers[livello] = inizializza_layer(numero_percettroni_livello, r.layers[livello - 1].size);
} */
}
return r;
}
ReteNeurale inizializza_rete_neurale_deep_feed_forward(int numero_layers, int numero_percettroni_iniziali, int numero_input)
{
ReteNeurale r;
r.layers = (Layer *)malloc(sizeof(Layer) * numero_layers);
r.size = numero_layers;
for (int livello = 0; livello < numero_layers; livello++)
{
@@ -132,28 +145,35 @@ ReteNeurale inizializza_rete_neurale(int numero_layers, int numero_percettroni_i
printf("Layer %d -> percettroni: %d\n", livello, numero_percettroni_iniziali);
r.layers[livello] = inizializza_layer(numero_percettroni_iniziali, numero_input);
}
else if(livello < numero_layers -1) {
printf("Layer %d -> percettroni: %d\n", livello, numero_percettroni_iniziali*2);
r.layers[livello] = inizializza_layer(numero_percettroni_iniziali * 2, r.layers[livello - 1].size);
}
else {
printf("Layer %d -> percettroni: %d\n", livello, 1);
r.layers[livello] = inizializza_layer(1, r.layers[livello - 1].size);
}
}
}
return r;
}
double *get_double_from_bytes(Istanza istanza) {
double *inputs = (double *)malloc(sizeof(double *) * istanza.size);
for(int i = 0; i < istanza.size; i++) {
inputs[i] = (double)istanza.dati[i];
}
return inputs;
}
/*
################# PREVISIONI ################################
################# FUNZIONI ATTIVAZIONE ################################
*/
//******************* I PESI SONO TUTTI NAN ********************************
//Tipo 1 = relu, tipo 2 = sigmoide
double funzione_attivazione(Percettrone p, double *valori, int tipo)
double funzione_attivazione_percettrone(Percettrone p, double *valori, int tipo)
{
double sommatoria = 0.0;
for (int i = 0; i < p.size; i++) {
@@ -162,7 +182,7 @@ double funzione_attivazione(Percettrone p, double *valori, int tipo)
}
sommatoria += p.bias;
//printf(" sommatoria %f -> %f\n",sommatoria, risultato);
//printf(" sommatoria %f\n",sommatoria);
if(tipo == 1)
return relu(sommatoria);
@@ -178,14 +198,6 @@ double derivata_sigmoide(double valore) {
return valore * (1.0 - valore);
}
int previsione(double valore)
{
if (valore >= soglia_sigmoide)
return 1;
else
return 0;
}
double relu(double valore) {
if(valore > 0)
return valore;
@@ -200,14 +212,67 @@ double derivata_relu(double valore) {
return 0;
}
void discesa_gradiente(ReteNeurale rete, double **funzioni, double **gradienti, int tipo_derivata)
//tipo_funzione 1: relu, 2:sigmoide
double **elabora_funzioni_attivazione(ReteNeurale *rete, Istanza istanza, int tipo_funzione)
{
/* for(int xxx = 0; xxx < rete->size; xxx++) {
for (int count = 0; count < rete->layers[xxx].size; count++)
{
for (int count_2 = 0; count_2 < rete->layers[xxx].percettroni[count].size; count_2++)
{
printf("[%d][%d]: %f\t", count, count_2, rete->layers[xxx].percettroni[count].pesi[count_2]);
}
printf("\n");
}
} */
//Inizializzo il vettore bidimensionale che dovrò ritornare
double **funzioni = (double **)malloc(sizeof(double *) * rete->size);
//Il primo layer devo farlo a parte perchè prende gli input dal dataset e non dal layer precedente
funzioni[0] = elabora_funzioni_attivazione_layer(rete->layers[0], get_double_from_bytes(istanza), tipo_funzione);
for(int indice_layer = 1; indice_layer < rete->size - 1; indice_layer ++) {
funzioni[indice_layer] = elabora_funzioni_attivazione_layer(rete->layers[indice_layer], funzioni[indice_layer-1], tipo_funzione);
}
funzioni[rete->size-1] = elabora_funzioni_attivazione_layer(rete->layers[rete->size-1], funzioni[rete->size-2], 2);
return funzioni;
}
//DA NAN
double *elabora_funzioni_attivazione_layer(Layer layer, double *inputs, int tipo_funzione) {
double *funzioni = (double *)malloc(sizeof(double) * layer.size);
for(int indice_percettrone = 0; indice_percettrone < layer.size; indice_percettrone ++) {
funzioni[indice_percettrone] = funzione_attivazione_percettrone(layer.percettroni[indice_percettrone], inputs, tipo_funzione);
}
return funzioni;
}
/*
################# RETROPROPAGAZIONE ################################
*/
double **discesa_gradiente(ReteNeurale rete, double **funzioni, double errore, int tipo_derivata) {
double **gradienti = (double**)malloc(sizeof(double*) * rete.size);
//Determino il gradiente di output a parte perchè non prende gradienti discesi dal livello superiore
gradienti[rete.size-1] = calcola_gradiente_output(rete.layers[rete.size-1], funzioni[rete.size-1], errore, tipo_derivata);
//Determino gli altri livelli
for (int indice_layer = rete.size - 2; indice_layer >= 0; indice_layer--)
{
gradienti[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++)
{
//In base al tipo di funzione scelto, avvio relu o sigmoidi
double derivata_attivazione;
if(tipo_derivata == 1)
@@ -215,15 +280,32 @@ void discesa_gradiente(ReteNeurale rete, double **funzioni, double **gradienti,
else
derivata_attivazione = derivata_sigmoide(funzioni[indice_layer][indice_percettrone]);
// Passo anche l'indice del percettrone perchè corrisponde all'indice del peso del livello sopra
double gradiente_disceso = calcola_gradiente_disceso(rete, indice_layer + 1, indice_percettrone, gradienti);
gradienti[indice_layer][indice_percettrone] = gradiente_disceso * derivata_attivazione;
gradienti[indice_layer][indice_percettrone] = calcola_gradiente_disceso(rete, indice_layer + 1, indice_percettrone, gradienti, derivata_attivazione);
}
}
return gradienti;
}
double calcola_gradiente_disceso(ReteNeurale rete, int livello, int indice_peso, double **gradienti)
double *calcola_gradiente_output(Layer layer, double *funzioni, double errore, int tipo_derivata) {
double *gradienti = (double*)malloc(sizeof(double) * layer.size);
//Qui darò per scontato che ci sia un singolo percettrone in uscita, da aggiornare in caso di multipercettrone
double derivata_funzione;
if(tipo_derivata == 1)
derivata_funzione = derivata_relu(funzioni[0]);
else
derivata_funzione = derivata_sigmoide(funzioni[0]);
gradienti[0] = errore * derivata_funzione;
return gradienti;
}
double calcola_gradiente_disceso(ReteNeurale rete, int livello, int indice_peso, double **gradienti, double derivata_attivazione)
{
// printf("Qui ci arrivo\n");
double sommatoria = 0.0;
@@ -234,44 +316,42 @@ double calcola_gradiente_disceso(ReteNeurale rete, int livello, int indice_peso,
sommatoria += (gradienti[livello][indice_peso] * rete.layers[livello].percettroni[indice_percettrone].pesi[indice_peso]);
}
return sommatoria;
}
//tipo_funzione 1: relu, 2:sigmoide
double **elabora_funzioni_attivazione(ReteNeurale rete, Istanza istanza, int tipo_funzione)
{
double **funzioni = (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];
}
funzioni[0] = (double *)malloc(sizeof(double) * rete.layers[0].size);
for(int indice_percettrone = 0; indice_percettrone < rete.layers[0].size; indice_percettrone ++) {
funzioni[0][indice_percettrone] = funzione_attivazione(rete.layers[0].percettroni[indice_percettrone], inputs, tipo_funzione);
}
//Taglio fuori l'ultimo layer perchè in ogni caso sarà sigmoide
for(int indice_layer = 1; indice_layer < rete.size; indice_layer ++) {
funzioni[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 ++) {
//Se è il livello output in ogni caso deve fare sigmoide
if(indice_layer == rete.size-1)
funzioni[indice_layer][indice_percettrone] = funzione_attivazione(rete.layers[indice_layer].percettroni[indice_percettrone], funzioni[indice_layer-1], 2);
else
funzioni[indice_layer][indice_percettrone] = funzione_attivazione(rete.layers[indice_layer].percettroni[indice_percettrone], funzioni[indice_layer-1], tipo_funzione);
}
}
return funzioni;
return sommatoria * derivata_attivazione;
}
/*
################# CORREZIONI ################################
################# PREVISIONE E CORREZIONI ################################
*/
void aggiorna_pesi(ReteNeurale *rete_neurale, double **gradienti, double **funzioni_attivazione, Istanza istanza) {
// Applico la correzione dal penultimo layer andando indietro fino al secondo (il primo si fa diverso)
for (int indice_layer = rete_neurale->size - 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, funzioni_attivazione, 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);
}
}
}
}
int previsione(double valore)
{
if (valore >= soglia_sigmoide)
return 1;
else
return 0;
}
void correggi_pesi_percettrone_double(Percettrone *p, int layer, double **input, double gradiente_percettrone)
{
@@ -304,9 +384,12 @@ void correggi_pesi_percettrone_byte(Percettrone *p, Istanza input, double gradie
/*
################# IMPORT EXPORT ################################
*/
void salvaReteNeurale(const char *filename, ReteNeurale *rete)
{
FILE *file = fopen(filename, "wb");
@@ -402,7 +485,14 @@ ReteNeurale *caricaReteNeurale(const char *filename)
/* funzioni[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 ++) {
//Se è il livello output in ogni caso deve fare sigmoide
if(indice_layer == rete.size-1)
funzioni[indice_layer][indice_percettrone] = funzione_attivazione(rete.layers[indice_layer].percettroni[indice_percettrone], funzioni[indice_layer-1], 2);
else
funzioni[indice_layer][indice_percettrone] = funzione_attivazione(rete.layers[indice_layer].percettroni[indice_percettrone], funzioni[indice_layer-1], tipo_funzione);
} */
/* double sigmoide_byte(Percettrone, byte *, int);
double sigmoide_double(Percettrone, double *, int);
@@ -520,4 +610,27 @@ double sigmoide_double(Percettrone p, double *valori, int n_input)
return risultato;
}
*/
*/
//void discesa_gradiente(ReteNeurale, double **, double **, int);
/* void discesa_gradiente(ReteNeurale rete, double **funzioni, double **gradienti, int tipo_derivata)
{
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++)
{
//In base al tipo di funzione scelto, avvio relu o sigmoidi
double derivata_attivazione;
if(tipo_derivata == 1)
derivata_attivazione = derivata_relu(funzioni[indice_layer][indice_percettrone]);
else
derivata_attivazione = derivata_sigmoide(funzioni[indice_layer][indice_percettrone]);
// Passo anche l'indice del percettrone perchè corrisponde all'indice del peso del livello sopra
gradienti[indice_layer][indice_percettrone] = calcola_gradiente_disceso(rete, indice_layer + 1, indice_percettrone, gradienti, derivata_attivazione);
}
}
} */