classificatore_immagini/classificatore_singolo.c

#include <time.h>
#include "percettroni.h"

// Scelgo quale categoria voglio identificare. nel caso dello xor -1
#define CATEGORIA 7
#define NUM_LAYERS 4
#define PERCETTRONI_LAYER_0 32
#define MAX_EPOCHE 10

// 1 relu, 2 sigmoide
#define TIPO_FUNZIONE 2

byte get_out_corretto(byte);
void stampa_layer_indirizzo(Layer *);
void stampa_tempo(time_t[], int);
void debug(int);

void main()
{
    srand(time(NULL));
    time_t tempo_epoche[MAX_EPOCHE];

    /*
        ################# Inizializzazione rete e caricamento Dataset ################################
    */

    Dataset *set_appoggio = get_dataset(file_immagini, file_label);

    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)
    {
        rete_neurale = inizializza_rete_neurale_feed_forward(NUM_LAYERS, PERCETTRONI_LAYER_0, N_INPUTS);
    }
    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);

    printf("Numero elementi nel dataset: %d\n", set.size);

    /*
        ################# Addestramento ################################
    */

    int corrette = 0;

    for (int i = 0; i < MAX_EPOCHE; i++)
    {
        /*
            ################# inizializzazione variabili per l'epoca in corso ################################
        */

        printf("Epoca %d\n", i);
        stampa_tempo(tempo_epoche, i);

        corrette = 0;
        double errore_totale = 0.0;

        /* for (int xxx = 0; xxx < rete_neurale.size; xxx++)
            {
                for (int count = 0; count < rete_neurale.layers[xxx].size; count++)
                {
                    for (int count_2 = 0; count_2 < rete_neurale.layers[xxx].percettroni[count].size; count_2++)
                    {
                        printf("[%d][%d]: %f\t", count, count_2, rete_neurale.layers[xxx].percettroni[count].pesi[count_2]);
                    }
                    printf("\n");
                }
            } */

        for (int indice_set = 0; indice_set < set.size; indice_set++)
        {
            
            /*
                ################# Feed Forward ################################
            */
            // Elabora le funzioni di attivazione in base al tipo scelto. Ritorna un vettore bidimensionale dove la prima dimensione rappresenta l'indice del layer, la seconda quella del percettrone nel layer

            double **funzioni_attivazione = elabora_funzioni_attivazione(&rete_neurale, set.istanze[indice_set], TIPO_FUNZIONE);

            /*
                ################# Previsione ################################
            */
            // Siccome il dataset da il numero della categoria a cui appartiene l'immagine, se la categoria è quella che cerco io output_corretto varrà 1 altrimenti 0
            byte output_corretto = get_out_corretto(set.istanze[indice_set].classificazione);

            if (previsione(funzioni_attivazione[rete_neurale.size - 1][0]) == output_corretto)
                corrette++;

            /*
                ################# Funzione di perdita (errore) ################################
            */

            // printf("funzione_attivazione_out: %f", funzioni_attivazione[rete_neurale.size - 1][0]);

            // Derivata funzione di perdita
            double errore = (output_corretto - funzioni_attivazione[rete_neurale.size - 1][0]);

            // Sommo la funzione di perdita a errore_totale per stampare alla fine dell'epoca l'errore medio
            errore_totale += pow(errore, 2) * 0.5;

            /*
                ################# Retropropagazione ################################
            */
            /* 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 attivazione
            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] = errore * derivata_funzione_out;

            //Crasha nella discesa del gradiente all'immagine indice 16 quando metto troppi percettroni
            discesa_gradiente(rete_neurale, funzioni_attivazione, gradienti, TIPO_FUNZIONE); */

            double **gradienti = discesa_gradiente(rete_neurale, funzioni_attivazione, errore, TIPO_FUNZIONE);

            /*
                ################# Aggiornamento dei pesi ################################
            */

            /*

                **** SISTEMARE LA CORREZIONE IN VISTA DELLE ULTIME MODIFICHE PERCHÈ NON CORREGGE E MI SETTA TUTTI I PESI A NAN *****

            */


            aggiorna_pesi(rete_neurale, gradienti, funzioni_attivazione, set.istanze[indice_set]);

            // Correggo il livello output
            /* for (int indice_peso = 0; indice_peso < rete_neurale.layers[rete_neurale.size - 1].percettroni[0].size; indice_peso++)
            {
                // Determino gradiente del peso
                double gradiente_peso = gradienti[rete_neurale.size - 1][0] * funzioni_attivazione[rete_neurale.size - 2][indice_peso];
                rete_neurale.layers[rete_neurale.size - 1].percettroni[0].pesi[indice_peso] += gradiente_peso * LRE;
            }
            rete_neurale.layers[rete_neurale.size - 1].percettroni[0].bias += gradienti[rete_neurale.size - 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, 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);
                    }
                }
            } */
        }

        errore_totale /= set.size;
        double percentuale = (corrette * 100) / set.size;
        printf("Errore: %f, accuratezza: %.2f%, corrette: %d\n", errore_totale, percentuale, corrette);

        // For di debug
        /* for (int count = 0; count < rete_neurale.size; count++)
        {
            for (int count_2 = 0; count_2 < rete_neurale.layers[count].size; count_2++)
            {
                printf("[%d][%d]: %f\t", count, count_2, gradienti[count][count_2]);
            }
            printf("\n");
        } */
    }

    // 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)
            return 1;
        else
            return 0;
    }
    else
        return categoria;
}

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]);
            layer->percettroni[i].pesi[j] += 1;
        }
        printf("\n");
    }
}

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]);
        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;
        int minuti_totali = (int)tempo_trascorso_totale / 60;
        int secondi_totali = (int)tempo_trascorso_totale % 60;
        printf("Tempo dall'epoca precedente: %d:%d\n", minuti_epoca, secondi_epoca);
        printf("Tempo dall'inizio: %d:%d\n", minuti_totali, secondi_totali);
    }
}

void debug(int indice)
{
    printf("qui ci arrivo %d", indice);
}

/* 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_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++)
                        printf("sigmoide[%d][%d] = %f\n", k, j, risultato[k][j]);
            }
        } */