classificatore_immagini/classificatore_singolo.c

#include <time.h>
#include "percettroni.h"
//#include "mnist/mnist_manager.h"
//#include "cifar_10/cifar10_manager.h"
#include "xor_manager.h"

//Scelgo quale categoria voglio identificare. nel caso dello xor -1
#define CATEGORIA -1
#define NUM_LAYERS 2
#define PERCETTRONI_LAYER_0 2
#define MAX_EPOCHE 10000

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

void main() {
    time_t tempo_epoche[MAX_EPOCHE];

    srand(time(NULL));

    Dataset *set_appoggio = crea_dataset_xor();//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 = init_rete_neurale(NUM_LAYERS, PERCETTRONI_LAYER_0, N_INPUTS);
    } else {
        rete_neurale = *puntatore_rete;
        free(puntatore_rete);
        printf("Caricate impostazioni rete neurale da file\n");
    }

    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;

        for(int indice_set = 0; indice_set < set.size; indice_set++) {

            //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]);
            }

            
            byte output_corretto = get_out_corretto(set.istanze[indice_set].classificazione);


            //Se prevede male
            if(previsione(sigmoidi[NUM_LAYERS-1][0]) != output_corretto) {

                //gradienti è un array bidimensionale, la prima dimensione identifica il layer, la seconda il percettrone nel layer
                //gradienti[indice_layer][indice_percettrone]
                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);
                }

                /*  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
                    
                */
                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
            {
                corrette++;
            }

            if(corrette == 4) {
                printf("\tConvergo all'epoca %d\n", i);
                break;
            }
        }

        printf("Errore: %f\n", errore_totale);
        
        //printf("\tRisposte corrette: %d\n", corrette);

        if(corrette == set.size) {
            break;
        }
    }

    //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);
    }
}