classificatore_immagini/percettroni.h

#include <math.h>
#include "dataset_manager.h"

double LRE = 0.2;
double soglia_sigmoide = 0.5;

typedef struct {
    double *pesi;
    double bias;
    int size;
} Percettrone;

typedef struct {
    Percettrone *percettroni;
    int size;
} Layer;

typedef struct {
    Layer *layers;
    int size;
} ReteNeurale;

double randomico();

Percettrone inzializza_percettrone(int);
ReteNeurale inizializza_rete_neurale(int);
Layer inizializza_layer(int, int);

double sigmoide_byte(Percettrone, byte*, int);
double sigmoide_double(Percettrone, double*, int);
double *funzioni_attivazione_layer_byte(Layer, byte*);
double *funzioni_attivazione_layer_double(Layer, double*);

void correggi_layer_interni(ReteNeurale*, double**, double**);
void correggi_layer_input(Layer*, double**, double**, byte*, int);

int previsione(double);

void salvaReteNeurale(const char*, ReteNeurale*);
ReteNeurale *caricaReteNeurale(const char*);

//Questa funzione genera un valore reale random compreso nell'intervallo [-1, 1]
double randomico() {
    // Genero numeri nell'intervallo [-1,1]
    return ((double)(rand() % 101 * 0.01 * 2 ) -1);
}

//Questa funzione inizializza il percettrone allocando la memoria in base al numero dei pesi che voglio ed inizializza il loro valore usando randomico()
Percettrone inizializza_percettrone(int n_pesi) {
    Percettrone p;
    p.pesi = (double*) malloc(sizeof(double) * n_pesi);
    for(int i = 0; i < n_pesi; i++)
        p.pesi[i] = randomico();

    p.bias = randomico();

    p.size = n_pesi;

    return p;
}

//Questa funzione inizializza una rete neurale. Diamo il numero di layer desiderato e restituisce un ReteNeurale
ReteNeurale inizializza_rete_neurale(int n_layers) {
    ReteNeurale r;
    r.layers = (Layer*)malloc(sizeof(Layer) * n_layers);
    r.size = n_layers;

    return r;
}

//Questa funzione serve ad inizializzare il singolo layer con il numero di percettroni che vogliamo
//Ogni percettrone a sua volta viene automaticamente inizializzato con il numero di pesi che vogliamo e coi valori di partenza
Layer inizializza_layer(int n_percettroni, int n_pesi) {
    Layer layer;
    layer.percettroni = (Percettrone *)malloc(sizeof(Percettrone) * n_percettroni);

    for(int i = 0; i < n_percettroni; i++) {
        layer.percettroni[i] = inizializza_percettrone(n_pesi);
    }

    layer.size = n_percettroni;

    return layer;
}

//Questa funzione viene usata per il primo livello perchè ha un vettore di byte (unsigned char) in input
double sigmoide_byte(Percettrone p, byte *valori, int n_input) {
    
    double sommatoria = 0.0;
    for(int i = 0; i < n_input; i++) {
        sommatoria += ((double)valori[i] * p.pesi[i]);
    }
    //printf("sommatoria= %f\n", sommatoria);
    double funzione = sommatoria + p.bias;
    double potenza_e = exp(-funzione);
    //printf("potenza_e= %f\n", potenza_e);
    //formula sigmoide
    double risultato = 1 / ( 1 + potenza_e);
    //printf("risultato= %f\n", risultato);
    return risultato;
}

//Questa funzione viene usata per gli altri livelli dove gli input sono double, ossia i valori della sigmoide dei livelli precedenti
double sigmoide_double(Percettrone p, double *valori, int n_input) {
    
    double sommatoria = 0.0;
    for(int i = 0; i < n_input; i++) {
        sommatoria += (valori[i] * p.pesi[i]);
    }

    double funzione = sommatoria + p.bias;
    //printf("sommatoria= %f\n", sommatoria);
    double potenza_e = exp(-funzione);
    //printf("potenza_e= %f\n", potenza_e);
    //formula sigmoide
    double risultato = 1 / ( 1 + potenza_e);
    //printf("risultato= %f\n", risultato);

    return risultato;
}

//Questa funzione calcola tutte le funzioni di attivazione dei percettroni del layer che prende dei byte come inputs
double *funzioni_attivazione_layer_byte(Layer layer, byte *inputs) {

    double *funzioni = (double*)malloc(sizeof(double) * layer.size);
    
    for(int i = 0; i < layer.size; i++) {
        funzioni[i] = sigmoide_byte(layer.percettroni[i], inputs, layer.percettroni[i].size);
    }

    return funzioni;
}

//Questa funzione calcola tutte le funzioni di attivazione dei percettroni del layer che prende dei double come inputs (le sigmoidi del livello precedente)
double *funzioni_attivazione_layer_double(Layer layer, double *inputs) {

    double *funzioni = (double*)malloc(sizeof(double) * layer.size);
    
    for(int i = 0; i < layer.size; i++) {
        funzioni[i] = sigmoide_double(layer.percettroni[i], inputs, layer.percettroni[i].size);
    }

    return funzioni;
}

//Questa funzione restituisce il valore 0,1 in base alla soglia di attivazione della funzione sigmoide
int previsione(double valore) {
    if(valore >= soglia_sigmoide)
        return 1;
    else
        return 0;
}

//Questa funzione prende la matrice dei gradienti e la matrice delle sigmoidi per correggere tutti i layer tranne quello di ingresso
void correggi_layer_interni(ReteNeurale *rete, double **gradienti, double **sigmoidi) {

    for(int indice_layer = rete->size-1; indice_layer > 0; indice_layer--) {
        for(int indice_percettrone = 0; indice_percettrone < rete->layers[indice_layer].size; indice_percettrone++) {//Numero percettroni

            for(int indice_peso = 0; indice_peso < rete->layers[indice_layer].percettroni[indice_percettrone].size; indice_peso++) {//Numero pesi
                gradienti[indice_layer][indice_percettrone] = gradienti[rete->size-1][0] * (sigmoidi[indice_layer][indice_percettrone] * (1 - sigmoidi[indice_layer][indice_percettrone]));

                rete->layers[indice_layer].percettroni[indice_percettrone].pesi[indice_peso] += (gradienti[indice_layer][indice_percettrone] * LRE * sigmoidi[indice_layer-1][indice_percettrone]);
                
                //if(indice_layer == 3)
                //    printf("qui ci arrivo layer: %d, percettrone: %d, input:%d, peso: %f\n", indice_layer, indice_percettrone, indice_peso, rete->layers[indice_layer].percettroni[indice_percettrone].pesi[indice_peso]);
                
                //printf("gradiente applicato %f, sigmoide %f\n", gradienti[indice_layer][indice_percettrone], sigmoidi[indice_layer][indice_percettrone]);
            }
            rete->layers[indice_layer].percettroni[indice_percettrone].bias += (gradienti[indice_layer][indice_percettrone] * LRE);
            //printf("bias: %f\n", rete->layers[indice_layer].percettroni[indice_percettrone].bias);
        }
    }
}

//Questa funzione prende tutti i parametri della precedente + gli input passati dal dataset per correggere il layer di ingresso
void correggi_layer_input(Layer *layer, double **gradienti, double **sigmoidi, byte *inputs, int n_layers) {
    //L'indice del layer d'ingresso che prende byte per input
    int indice_layer = 0;
    for(int indice_percettrone = 0; indice_percettrone < layer->size; indice_percettrone++) {//Numero percettroni
        for(int indice_peso = 0; indice_peso < layer->percettroni->size; indice_peso++) { //Numero pesi

            gradienti[indice_layer][indice_percettrone] = gradienti[n_layers-1][0] * (sigmoidi[indice_layer][indice_percettrone] * (1 - sigmoidi[indice_layer][indice_percettrone]));
            layer->percettroni[indice_percettrone].pesi[indice_peso] += (gradienti[indice_layer][indice_percettrone] * LRE * inputs[indice_peso]);
        }
        layer->percettroni[indice_percettrone].bias += (gradienti[indice_layer][indice_percettrone] * LRE);
    }
}

//Una volta finito il ciclo delle epoche viene salvato lo stato della rete neurale
void salvaReteNeurale(const char *filename, ReteNeurale *rete) {
    FILE *file = fopen(filename, "wb");
    if (!file) {
        perror("Errore nell'apertura del file");
        exit(EXIT_FAILURE);
    }

    // Scrivi il numero di layer
    fwrite(&rete->size, sizeof(int), 1, file);

    // Scrivi ogni layer
    for (int i = 0; i < rete->size; i++) {
        Layer *layer = &rete->layers[i];
        fwrite(&layer->size, sizeof(int), 1, file);

        // Scrivi ogni percettrone nel layer
        for (int j = 0; j < layer->size; j++) {
            Percettrone *perc = &layer->percettroni[j];
            fwrite(&perc->size, sizeof(int), 1, file);
            fwrite(perc->pesi, sizeof(double), perc->size, file);
            fwrite(&perc->bias, sizeof(double), 1, file);
        }
    }

    fclose(file);
}

//Quando parte il programma carica lo stato della rete neurale dal file oppure inizializza una rete neurale con pesi random se il file non esiste
ReteNeurale *caricaReteNeurale(const char *filename) {
    FILE *file = fopen(filename, "rb");

    if (!file) {
        perror("Errore nell'apertura del file");
        return NULL;
    }

    ReteNeurale *rete = malloc(sizeof(ReteNeurale));
    if (!rete) {
        perror("Errore nell'allocazione della memoria");
        return NULL;
    }

    // Leggi il numero di layer
    fread(&rete->size, sizeof(int), 1, file);
    rete->layers = malloc(rete->size * sizeof(Layer));
    if (!rete->layers) {
        perror("Errore nell'allocazione della memoria");
        return NULL;
    }

    // Leggi ogni layer
    for (int i = 0; i < rete->size; i++) {
        Layer *layer = &rete->layers[i];
        fread(&layer->size, sizeof(int), 1, file);
        layer->percettroni = malloc(layer->size * sizeof(Percettrone));
        if (!layer->percettroni) {
            perror("Errore nell'allocazione della memoria");
            return NULL;
        }

        // Leggi ogni percettrone nel layer
        for (int j = 0; j < layer->size; j++) {
            Percettrone *perc = &layer->percettroni[j];
            fread(&perc->size, sizeof(int), 1, file);
            perc->pesi = malloc(perc->size * sizeof(double));
            if (!perc->pesi) {
                perror("Errore nell'allocazione della memoria");
                return NULL;
            }
            fread(perc->pesi, sizeof(double), perc->size, file);
            fread(&perc->bias, sizeof(double), 1, file);
        }
    }

    fclose(file);
    return rete;
}