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