diff --git a/classificatore_singolo b/classificatore_singolo index f809243..a3507af 100755 Binary files a/classificatore_singolo and b/classificatore_singolo differ diff --git a/classificatore_singolo.c b/classificatore_singolo.c index c85c9c2..90bdbf8 100644 --- a/classificatore_singolo.c +++ b/classificatore_singolo.c @@ -3,9 +3,9 @@ // 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 +#define NUM_LAYERS 2 +#define PERCETTRONI_LAYER_0 2 +#define MAX_EPOCHE 1 // 1 relu, 2 sigmoide #define TIPO_FUNZIONE 2 @@ -13,7 +13,6 @@ byte get_out_corretto(byte); void stampa_layer_indirizzo(Layer *); void stampa_tempo(time_t[], int); -void debug(int); void main() { @@ -34,8 +33,7 @@ void main() ReteNeurale rete_neurale; ReteNeurale *puntatore_rete = caricaReteNeurale(file_pesi); - if (puntatore_rete == NULL) - { + if (puntatore_rete == NULL) { rete_neurale = inizializza_rete_neurale_feed_forward(NUM_LAYERS, PERCETTRONI_LAYER_0, N_INPUTS); } else @@ -52,143 +50,39 @@ void main() /* ################# 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++) + + for (int indice_set = 0; indice_set < 1/* 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); - 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); - } - } - } */ + //debug_matrice(&rete_neurale, funzioni_attivazione); } 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); @@ -240,11 +134,6 @@ void stampa_tempo(time_t tempo_epoche[], int i) } } -void debug(int indice) -{ - printf("qui ci arrivo %d", indice); -} - /* if (i == MAX_EPOCHE - 1) { printf("\nUltima epoca (%d), stato della rete:\n", i); diff --git a/percettroni.h b/percettroni.h index 219fd53..c8197ba 100644 --- a/percettroni.h +++ b/percettroni.h @@ -49,13 +49,13 @@ ReteNeurale inizializza_rete_neurale_feed_forward(int, int, int); double funzione_attivazione_percettrone(Percettrone p, double*, int); -double **elabora_funzioni_attivazione(ReteNeurale*, Istanza, int); +double **elabora_funzioni_attivazione(ReteNeurale, Istanza, int); double *elabora_funzioni_attivazione_layer(Layer, double*, int); double **discesa_gradiente(ReteNeurale, double **, double, int); double *calcola_gradiente_output(Layer layer, double*, double, int); double calcola_gradiente_disceso(ReteNeurale, int, int, double**, double); void aggiorna_pesi(ReteNeurale, double**, double**, Istanza); -void correggi_pesi_percettrone(Percettrone, double*, double); +void correggi_pesi_percettrone(Percettrone*, double*, double); //void correggi_pesi_percettrone_byte(Percettrone*, Istanza, double, int); int previsione(double); @@ -67,6 +67,10 @@ double derivata_relu(double); void salvaReteNeurale(const char *, ReteNeurale *); ReteNeurale *caricaReteNeurale(const char *); +void debug(double); +void debug_matrice(ReteNeurale*, double**); +void debug_vettore(double*, int); + /* ################# INIZIALIZZAZIONI E METODI UTILI ################################ */ @@ -171,26 +175,6 @@ double *get_double_from_bytes(Istanza istanza) { ################# FUNZIONI ATTIVAZIONE ################################ */ -//******************* I PESI SONO TUTTI NAN ******************************** - -//Tipo 1 = relu, tipo 2 = sigmoide -double funzione_attivazione_percettrone(Percettrone p, double *valori, int tipo) -{ - double sommatoria = 0.0; - for (int i = 0; i < p.size; i++) { - sommatoria += (valori[i] * p.pesi[i]); - //printf("valore [%f] peso[%f] ", valori[i], p.pesi[i]); - } - - sommatoria += p.bias; - //printf(" sommatoria %f\n",sommatoria); - - if(tipo == 1) - return relu(sommatoria); - - return sigmoide(sommatoria); -} - double sigmoide(double valore) { return 1.0 / (1.0 + exp(-valore)); } @@ -215,51 +199,64 @@ double derivata_relu(double valore) { //tipo_funzione 1: relu, 2:sigmoide -double **elabora_funzioni_attivazione(ReteNeurale *rete, Istanza istanza, int tipo_funzione) -{ - /* for(int xxx = 0; xxx < rete->size; xxx++) { - for (int count = 0; count < rete->layers[xxx].size; count++) - { - for (int count_2 = 0; count_2 < rete->layers[xxx].percettroni[count].size; count_2++) - { - printf("[%d][%d]: %f\t", count, count_2, rete->layers[xxx].percettroni[count].pesi[count_2]); - } - printf("\n"); - } - } */ +double **elabora_funzioni_attivazione(ReteNeurale rete, Istanza istanza, int tipo_funzione) +{ //Inizializzo il vettore bidimensionale che dovrò ritornare - double **funzioni = (double **)malloc(sizeof(double *) * rete->size); + double **funzioni = (double **)malloc(sizeof(double *) * rete.size); //Il primo layer devo farlo a parte perchè prende gli input dal dataset e non dal layer precedente - funzioni[0] = elabora_funzioni_attivazione_layer(rete->layers[0], get_double_from_bytes(istanza), tipo_funzione); + funzioni[0] = elabora_funzioni_attivazione_layer(rete.layers[0], get_double_from_bytes(istanza), tipo_funzione); - for(int indice_layer = 1; indice_layer < rete->size - 1; indice_layer ++) { - funzioni[indice_layer] = elabora_funzioni_attivazione_layer(rete->layers[indice_layer], funzioni[indice_layer-1], tipo_funzione); + for(int indice_layer = 1; indice_layer < rete.size - 1; indice_layer ++) { + funzioni[indice_layer] = elabora_funzioni_attivazione_layer(rete.layers[indice_layer], funzioni[indice_layer-1], tipo_funzione); } - funzioni[rete->size-1] = elabora_funzioni_attivazione_layer(rete->layers[rete->size-1], funzioni[rete->size-2], 2); + funzioni[rete.size-1] = elabora_funzioni_attivazione_layer(rete.layers[rete.size-1], funzioni[rete.size-2], 2); return funzioni; } + + //DA NAN double *elabora_funzioni_attivazione_layer(Layer layer, double *inputs, int tipo_funzione) { double *funzioni = (double *)malloc(sizeof(double) * layer.size); - for(int indice_percettrone = 0; indice_percettrone < layer.size; indice_percettrone ++) { + /* for(int indice_percettrone = 0; indice_percettrone < layer.size; indice_percettrone ++) { funzioni[indice_percettrone] = funzione_attivazione_percettrone(layer.percettroni[indice_percettrone], inputs, tipo_funzione); + } */ + + debug_vettore(funzioni, layer.percettroni->size); + return funzioni; +} + +//Tipo 1 = relu, tipo 2 = sigmoide +double funzione_attivazione_percettrone(Percettrone p, double *valori, int tipo) +{ + double sommatoria = 0.0; + for (int i = 0; i < p.size; i++) { + sommatoria += (valori[i] * p.pesi[i]); + //printf("valore [%f] peso[%f] ", valori[i], p.pesi[i]); } - return funzioni; + sommatoria += p.bias; + //printf(" sommatoria %f\n",sommatoria); + + if(tipo == 1) + //funzione = relu(sommatoria); + return relu(sommatoria); + else + //funzione = sigmoide(sommatoria); + return sigmoide(sommatoria); } /* ################# RETROPROPAGAZIONE ################################ */ -NON CALCOLA I GRADIENTI, PARTE DIRETTAMENTE NAN, VERIFICARE LA PRESENZA DI DATI IN FUNZIONI E LE FUNZIONI DI CALCOLO +//NON CALCOLA I GRADIENTI, PARTE DIRETTAMENTE NAN, VERIFICARE LA PRESENZA DI DATI IN FUNZIONI E LE FUNZIONI DI CALCOLO double **discesa_gradiente(ReteNeurale rete, double **funzioni, double errore, int tipo_derivata) { @@ -268,8 +265,6 @@ double **discesa_gradiente(ReteNeurale rete, double **funzioni, double errore, i //Determino il gradiente di output a parte perchè non prende gradienti discesi dal livello superiore gradienti[rete.size-1] = calcola_gradiente_output(rete.layers[rete.size-1], funzioni[rete.size-1], errore, tipo_derivata); - //printf("grad di testa %f, size %d\n", gradienti[rete.size-1][0], rete.size); - //Determino gli altri livelli for (int indice_layer = rete.size - 2; indice_layer >= 0; indice_layer--) { @@ -285,20 +280,11 @@ double **discesa_gradiente(ReteNeurale rete, double **funzioni, double errore, i else derivata_attivazione = derivata_sigmoide(funzioni[indice_layer][indice_percettrone]); - // printf("derivata: %f, gradiente_disceso %f\n", derivata_attivazione, calcola_gradiente_disceso(rete, indice_layer + 1, indice_percettrone, gradienti, derivata_attivazione)); - gradienti[indice_layer][indice_percettrone] = calcola_gradiente_disceso(rete, indice_layer + 1, indice_percettrone, gradienti, derivata_attivazione); } } - /* for (int count = 0; count < rete.size; count++) - { - for (int count_2 = 0; count_2 < rete.layers[count].size; count_2++) - { - printf("[%d][%d]: %f\t", count, count_2, gradienti[count][count_2]); - } - printf("\n"); - } */ + //debug_matrice(&rete, gradienti); return gradienti; } @@ -318,6 +304,8 @@ double **discesa_gradiente(ReteNeurale rete, double **funzioni, double errore, i gradienti[0] = errore * derivata_funzione; + //debug_vettore(gradienti, layer.size); + return gradienti; } @@ -335,24 +323,13 @@ double calcola_gradiente_disceso(ReteNeurale rete, int livello, int indice_peso, return sommatoria * derivata_attivazione; } - /* ################# PREVISIONE E CORREZIONI ################################ */ void aggiorna_pesi(ReteNeurale rete_neurale, double **gradienti, double **funzioni_attivazione, Istanza istanza) { - /* 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"); - } - } */ + //debug_matrice(&rete_neurale, gradienti); // Applico la correzione dal penultimo layer andando indietro fino al secondo (il primo si fa diverso) for (int indice_layer = rete_neurale.size - 1; indice_layer >= 0; indice_layer--) @@ -363,15 +340,13 @@ void aggiorna_pesi(ReteNeurale rete_neurale, double **gradienti, double **funzio // Devo prendere il gradiente del percettrone e moltiplicarlo con gli input associati ai pesi if (indice_layer > 0) { - //printf(" [%d][%d]: %f ", indice_layer, indice_percettrone, gradienti[indice_layer][indice_percettrone]); - correggi_pesi_percettrone(rete_neurale.layers[indice_layer].percettroni[indice_percettrone], funzioni_attivazione[indice_layer-1], gradienti[indice_layer][indice_percettrone]); + correggi_pesi_percettrone(&rete_neurale.layers[indice_layer].percettroni[indice_percettrone], funzioni_attivazione[indice_layer-1], gradienti[indice_layer][indice_percettrone]); } else { - correggi_pesi_percettrone(rete_neurale.layers[indice_layer].percettroni[indice_percettrone], get_double_from_bytes(istanza), gradienti[indice_layer][indice_percettrone]); + correggi_pesi_percettrone(&rete_neurale.layers[indice_layer].percettroni[indice_percettrone], get_double_from_bytes(istanza), gradienti[indice_layer][indice_percettrone]); } } - //printf("\n"); } } @@ -387,42 +362,20 @@ int previsione(double valore) Al secondo giro diventa NAN */ -void correggi_pesi_percettrone(Percettrone p, double *input, double gradiente_percettrone) -{ - //printf("grad_perc: %f", gradiente_percettrone); - for (int indice_peso = 0; indice_peso < p.size; indice_peso++) - { - - // Determino il gradiente del peso - double gradiente_peso = gradiente_percettrone * input[indice_peso]; - - //printf("indice[%d], gradiente percettrone %f, gradiente peso %f ", indice_peso, gradiente_percettrone, gradiente_peso); - - // Modifico il peso - p.pesi[indice_peso] += (gradiente_peso * LRE); - - } - - p.bias += (gradiente_percettrone * LRE); - //printf("\n"); -} - -/* void correggi_pesi_percettrone_byte(Percettrone *p, Istanza input, double gradiente_percettrone, int indice_percettrone) +void correggi_pesi_percettrone(Percettrone *p, double *input, double gradiente_percettrone) { for (int indice_peso = 0; indice_peso < p->size; indice_peso++) { // Determino il gradiente del peso - double gradiente_peso = gradiente_percettrone * (double)input.dati[indice_peso]; + double gradiente_peso = gradiente_percettrone * input[indice_peso]; - // Modifico il peso Qui si impalla perchè per qualche ragione arriva size elevatissimo - p->pesi[indice_peso] += (gradiente_peso * LRE); + // Modifico il peso + p->pesi[indice_peso] = p->pesi[indice_peso] + (gradiente_peso * LRE); } - p->bias += (gradiente_percettrone * LRE); -} */ - - - + p->bias = p->bias + (gradiente_percettrone * LRE); + //printf("\n"); +} /* ################# IMPORT EXPORT ################################ @@ -520,156 +473,28 @@ ReteNeurale *caricaReteNeurale(const char *filename) - - - - -/* funzioni[indice_layer] = (double *)malloc(sizeof(double) * rete.layers[indice_layer].size); - for(int indice_percettrone = 0; indice_percettrone < rete.layers[indice_layer].size; indice_percettrone ++) { - //Se è il livello output in ogni caso deve fare sigmoide - if(indice_layer == rete.size-1) - funzioni[indice_layer][indice_percettrone] = funzione_attivazione(rete.layers[indice_layer].percettroni[indice_percettrone], funzioni[indice_layer-1], 2); - else - funzioni[indice_layer][indice_percettrone] = funzione_attivazione(rete.layers[indice_layer].percettroni[indice_percettrone], funzioni[indice_layer-1], tipo_funzione); - } */ - -/* 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); */ -/* // 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) +void debug(double valore) { - - 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); - // printf("\tsigmoide layer input %f\n", funzioni[i]); - } - - return funzioni; + printf("valore: %f\n", valore); } -// 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) +void debug_matrice(ReteNeurale *rete_neurale, double **matrice) { - - double *funzioni = (double *)malloc(sizeof(double) * layer.size); - - for (int i = 0; i < layer.size; i++) + for (int count = 0; count < rete_neurale->size; count++) { - funzioni[i] = sigmoide_double(layer.percettroni[i], inputs, layer.percettroni[i].size); - // printf("\tsigmoide layer %d: %f\n", i, funzioni[i]); - } - - return funzioni; -} - */ -/* // 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]); - // rete->layers[indice_layer].percettroni[indice_percettrone].pesi[indice_peso] += (gradienti[rete->size-1][0] * LRE * sigmoidi[indice_layer-1][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].pesi[indice_peso] += (gradienti[n_layers-1][0] * LRE * inputs[indice_peso]); - } - layer->percettroni[indice_percettrone].bias += (gradienti[n_layers - 1][0] * LRE); - } -} - */ -/* -// 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; - // printf("valori: [%d][%d]", valori[0], valori[1]); - // printf("pesi: [%f][%f]", p.pesi[0], p.pesi[1]); - - 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.0 / (1.0 + 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.0 / (1.0 + potenza_e); - // printf("risultato= %f\n", risultato); - - return risultato; -} - */ - - -//void discesa_gradiente(ReteNeurale, double **, double **, int); -/* void discesa_gradiente(ReteNeurale rete, double **funzioni, double **gradienti, int tipo_derivata) -{ - for (int indice_layer = rete.size - 2; indice_layer >= 0; indice_layer--) - { - for (int indice_percettrone = 0; indice_percettrone < rete.layers[indice_layer].size; indice_percettrone++) + for (int count_2 = 0; count_2 < rete_neurale->layers[count].size; count_2++) { - //In base al tipo di funzione scelto, avvio relu o sigmoidi - - double derivata_attivazione; - - if(tipo_derivata == 1) - derivata_attivazione = derivata_relu(funzioni[indice_layer][indice_percettrone]); - else - derivata_attivazione = derivata_sigmoide(funzioni[indice_layer][indice_percettrone]); - - // Passo anche l'indice del percettrone perchè corrisponde all'indice del peso del livello sopra - gradienti[indice_layer][indice_percettrone] = calcola_gradiente_disceso(rete, indice_layer + 1, indice_percettrone, gradienti, derivata_attivazione); + printf("[%d][%d]: %f\t", count, count_2, matrice[count][count_2]); } + printf("\n"); } -} */ \ No newline at end of file +} + +void debug_vettore(double *vettore, int size) +{ + for (int count_2 = 0; count_2 < size; count_2++) + { + printf("[%d]: %f\t", count_2, vettore[count_2]); + } + printf("\n"); +} diff --git a/prova_passaggio_parametri b/prova_passaggio_parametri new file mode 100755 index 0000000..e10872c Binary files /dev/null and b/prova_passaggio_parametri differ diff --git a/prova_passaggio_parametri.c b/prova_passaggio_parametri.c index 7128446..3299fb1 100644 --- a/prova_passaggio_parametri.c +++ b/prova_passaggio_parametri.c @@ -3,21 +3,20 @@ void stampa(int**); void cambia(int**); +int **crea(); +void cambia_riga(int*); void main() { - int **matrice = (int**)malloc(sizeof(int*) * 10); + int **matrice = crea(); - for(int i = 0; i < 10; i++) { - matrice[i] = (int*)malloc(sizeof(int) * 10); - for(int j = 0; j < 10; j++) { - matrice[i][j] = i * j; - } - } + stampa(matrice); cambia(matrice); + cambia_riga(matrice[4]); + stampa(matrice); } @@ -37,4 +36,21 @@ void cambia(int **matrix) { matrix[i][j] = 0; } } +} + +int **crea() { + int **matrice = (int**)malloc(sizeof(int*) * 10); + for(int i = 0; i < 10; i++) { + matrice[i] = (int*)malloc(sizeof(int) * 10); + for(int j = 0; j < 10; j++) { + matrice[i][j] = i * j; + } + } + return matrice; +} + +void cambia_riga(int * vettore) { + for(int j = 0; j < 10; j++) { + vettore[j] = 8; + } } \ No newline at end of file diff --git a/rete_pesi_deep_feed_forward_93-100.bin b/rete_pesi_deep_feed_forward.bin similarity index 100% rename from rete_pesi_deep_feed_forward_93-100.bin rename to rete_pesi_deep_feed_forward.bin