#include #include "percettroni.h" //Scelgo quale categoria voglio identificare. nel caso dello xor -1 #define CATEGORIA -1 #define NUM_LAYERS 3 #define PERCETTRONI_LAYER_0 4 #define MAX_EPOCHE 1000000 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 = inizializza_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] //Questo vettore identifica i gradienti dei percettroni 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 */ //Derivata funzione di perdita double gradiente_errore = -(output_corretto - sigmoidi[NUM_LAYERS-1][0]); //Derivata funzione attivazione double derivata_sigmoide_out = sigmoidi[NUM_LAYERS-1][0] * (1 - sigmoidi[NUM_LAYERS-1][0]); if (derivata_sigmoide_out == 0.0) derivata_sigmoide_out = 1; //Gradiente del percettrone output gradienti[NUM_LAYERS-1][0] = gradiente_errore * derivata_sigmoide_out; //Ricorda di partire dal penultimo layer in quanto l'ultimo è già fatto discesa_gradiente(rete_neurale, sigmoidi, gradienti); /* A questo punto ho tutti i gradienti dei percettroni, non mi resta che trovare i gradienti dei pesi e correggerli */ //Correggo il livello output for(int indice_peso = 0; indice_peso < rete_neurale.layers[NUM_LAYERS-1].percettroni[0].size; indice_peso ++) { //Determino gradiente del peso double gradiente_peso = gradienti[NUM_LAYERS-1][0] * sigmoidi[NUM_LAYERS-2][indice_peso]; rete_neurale.layers[NUM_LAYERS-1].percettroni[0].pesi[indice_peso] -= gradiente_peso * LRE; } rete_neurale.layers[NUM_LAYERS-1].percettroni[0].bias -= gradienti[NUM_LAYERS-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, sigmoidi, 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); } } } //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 / 4); 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); } }