diff --git a/classificatore_singolo b/classificatore_singolo index f4d4e21..d10d990 100755 Binary files a/classificatore_singolo and b/classificatore_singolo differ diff --git a/classificatore_singolo.c b/classificatore_singolo.c index 96f719b..4a16460 100644 --- a/classificatore_singolo.c +++ b/classificatore_singolo.c @@ -3,8 +3,8 @@ // Scelgo quale categoria voglio identificare. nel caso dello xor -1 #define CATEGORIA 7 -#define NUM_LAYERS 4 -#define PERCETTRONI_LAYER_0 32 +#define NUM_LAYERS 7 +#define PERCETTRONI_LAYER_0 128 #define MAX_EPOCHE 10 byte get_out_corretto(byte); @@ -37,7 +37,6 @@ void main() printf("Caricate impostazioni rete neurale da file\n"); } - //rete_neurale = inizializza_rete_neurale(NUM_LAYERS, PERCETTRONI_LAYER_0, N_INPUTS); int corrette = 0; printf("Numero elementi nel dataset: %d\n", set.size); @@ -45,7 +44,6 @@ void main() // ADDESTRAMENTO for (int i = 0; i < MAX_EPOCHE; i++) { - printf("Epoca %d\n", i); stampa_tempo(tempo_epoche, i); corrette = 0; @@ -53,61 +51,20 @@ void main() for (int indice_set = 0; indice_set < set.size; indice_set++) { - //printf("Qui ci arrivo %d\n", indice_set); double **sigmoidi = elabora_sigmoidi(rete_neurale, set.istanze[indice_set]); byte output_corretto = get_out_corretto(set.istanze[indice_set].classificazione); - if (previsione(sigmoidi[NUM_LAYERS - 1][0]) == output_corretto) + if (previsione(sigmoidi[rete_neurale.size - 1][0]) == output_corretto) corrette++; - 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 di perdita - double gradiente_errore = (output_corretto - sigmoidi[NUM_LAYERS - 1][0]); + double gradiente_errore = (output_corretto - sigmoidi[rete_neurale.size - 1][0]); errore_totale += pow(gradiente_errore, 2); - // Derivata funzione attivazione - double derivata_sigmoide_out = sigmoidi[NUM_LAYERS - 1][0] * (1.0 - sigmoidi[NUM_LAYERS - 1][0]); + double **gradienti = elabora_gradienti(rete_neurale, gradiente_errore, sigmoidi); - // Gradiente del percettrone output - gradienti[NUM_LAYERS - 1][0] = gradiente_errore * derivata_sigmoide_out; + aggiorna_pesi(&rete_neurale, sigmoidi, gradienti, set.istanze[indice_set]); - 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); - } - } - } } printf("Errore: %f, risposte corrette: %d%\n", errore_totale / set.size, (corrette * 100) / set.size); diff --git a/deep_seek b/deep_seek new file mode 100755 index 0000000..a167f8a Binary files /dev/null and b/deep_seek differ diff --git a/deep_seek.c b/deep_seek.c new file mode 100644 index 0000000..c22f2dc --- /dev/null +++ b/deep_seek.c @@ -0,0 +1,304 @@ +#include +#include +#include +#include +#include "cifar-10/cifar10_manager.h" + +// Costanti configurabili +#define N_LAYERS 3 // Numero di layer (input, hidden, output) +#define N_NEURONI_HIDDEN 128 // Numero di neuroni nei layer nascosti +#define N_NEURONI_OUTPUT 10 // Numero di neuroni nel layer di output (10 classi) +#define N_EPOCHE 10 // Numero di epoche di addestramento +#define LEARNING_RATE 0.01 // Tasso di apprendimento +#define N_INPUTS 3072 // Dimensioni di un'immagine CIFAR-10 (32x32x3) + +// Strutture dati +/* typedef unsigned char byte; + +typedef struct { + byte classificazione; + byte dati[N_INPUTS]; +} Istanza; + +typedef struct { + int size; + Istanza *istanze; +} Dataset; */ + +typedef struct { + double *pesi; + double bias; + int size; +} Percettrone; + +typedef struct { + Percettrone *percettroni; + int size; +} Layer; + +typedef struct { + Layer *layers; + int size; +} ReteNeurale; + +double sigmoide(double); +double relu(double); +double relu_derivata(double); +double softmax(double*, int, int); +ReteNeurale crea_rete(); +double *prevedi(ReteNeurale*, byte*); +void allena(ReteNeurale*, Dataset*); +void salva_rete(ReteNeurale*, const char*); +ReteNeurale carica_rete(const char*); +void carica_immagini_casuali(Dataset*, byte[][N_INPUTS], byte*); +void fai_previsioni(ReteNeurale*, byte[][N_INPUTS], byte*); +void backpropagation(ReteNeurale*, byte*, byte, double*); +double *forward_pass(ReteNeurale*, byte*); + +// Funzioni di utilità +double sigmoide(double x) { + return 1.0 / (1.0 + exp(-x)); +} + +double relu(double x) { + return x > 0 ? x : 0; +} + +double relu_derivata(double x) { + return x > 0 ? 1 : 0; +} + +double softmax(double *x, int index, int size) { + double max = x[0]; + for (int i = 1; i < size; i++) { + if (x[i] > max) max = x[i]; + } + double sum = 0.0; + for (int i = 0; i < size; i++) { + sum += exp(x[i] - max); + } + return exp(x[index] - max) / sum; +} + +// Inizializzazione della rete +ReteNeurale crea_rete() { + ReteNeurale rete; + rete.size = N_LAYERS; + rete.layers = (Layer *)malloc(N_LAYERS * sizeof(Layer)); + + // Layer di input (non ha pesi, solo pass-through) + rete.layers[0].size = N_INPUTS; + rete.layers[0].percettroni = NULL; + + // Layer nascosto + rete.layers[1].size = N_NEURONI_HIDDEN; + rete.layers[1].percettroni = (Percettrone *)malloc(N_NEURONI_HIDDEN * sizeof(Percettrone)); + for (int i = 0; i < N_NEURONI_HIDDEN; i++) { + rete.layers[1].percettroni[i].size = N_INPUTS; + rete.layers[1].percettroni[i].pesi = (double *)malloc(N_INPUTS * sizeof(double)); + for (int j = 0; j < N_INPUTS; j++) { + rete.layers[1].percettroni[i].pesi[j] = ((double)rand() / RAND_MAX) * 2 - 1; // Pesi casuali tra -1 e 1 + } + rete.layers[1].percettroni[i].bias = ((double)rand() / RAND_MAX) * 2 - 1; // Bias casuale tra -1 e 1 + } + + // Layer di output + rete.layers[2].size = N_NEURONI_OUTPUT; + rete.layers[2].percettroni = (Percettrone *)malloc(N_NEURONI_OUTPUT * sizeof(Percettrone)); + for (int i = 0; i < N_NEURONI_OUTPUT; i++) { + rete.layers[2].percettroni[i].size = N_NEURONI_HIDDEN; + rete.layers[2].percettroni[i].pesi = (double *)malloc(N_NEURONI_HIDDEN * sizeof(double)); + for (int j = 0; j < N_NEURONI_HIDDEN; j++) { + rete.layers[2].percettroni[i].pesi[j] = ((double)rand() / RAND_MAX) * 2 - 1; // Pesi casuali tra -1 e 1 + } + rete.layers[2].percettroni[i].bias = ((double)rand() / RAND_MAX) * 2 - 1; // Bias casuale tra -1 e 1 + } + + return rete; +} + +// Funzione per la previsione +double *prevedi(ReteNeurale *rete, byte *input) { + double *output = (double *)malloc(N_NEURONI_OUTPUT * sizeof(double)); + // Implementazione del forward pass + // (Da completare) + return output; +} + +// Funzione per l'addestramento +void allena(ReteNeurale *rete, Dataset *dataset) { + printf("Sono dentro l'allenamento\n"); + for (int epoca = 0; epoca < N_EPOCHE; epoca++) { + printf("Epoca %d\n", epoca); + for (int i = 0; i < dataset->size; i++) { + byte *input = dataset->istanze[i].dati; + byte target = dataset->istanze[i].classificazione; + + // Forward pass + double *output_final = forward_pass(rete, input); + + // Backpropagation + backpropagation(rete, input, target, output_final); + + free(output_final); + } + } +} + +// Forward pass +double *forward_pass(ReteNeurale *rete, byte *input) { + double *output_hidden = (double *)malloc(N_NEURONI_HIDDEN * sizeof(double)); + double *output_final = (double *)malloc(N_NEURONI_OUTPUT * sizeof(double)); + + // Layer nascosto + for (int i = 0; i < N_NEURONI_HIDDEN; i++) { + double somma = 0.0; + for (int j = 0; j < N_INPUTS; j++) { + somma += input[j] * rete->layers[1].percettroni[i].pesi[j]; + } + somma += rete->layers[1].percettroni[i].bias; + output_hidden[i] = relu(somma); // Applica ReLU + } + + // Layer di output + for (int i = 0; i < N_NEURONI_OUTPUT; i++) { + double somma = 0.0; + for (int j = 0; j < N_NEURONI_HIDDEN; j++) { + somma += output_hidden[j] * rete->layers[2].percettroni[i].pesi[j]; + } + somma += rete->layers[2].percettroni[i].bias; + output_final[i] = somma; // Non applica softmax qui, verrà fatto durante la loss + } + + free(output_hidden); + return output_final; +} + +// Backpropagation +void backpropagation(ReteNeurale *rete, byte *input, byte target, double *output_final) { + // Calcola la softmax e la loss (cross-entropy) + double softmax_output[N_NEURONI_OUTPUT]; + double sum_exp = 0.0; + for (int i = 0; i < N_NEURONI_OUTPUT; i++) { + sum_exp += exp(output_final[i]); + } + for (int i = 0; i < N_NEURONI_OUTPUT; i++) { + softmax_output[i] = exp(output_final[i]) / sum_exp; + } + + // Gradiente della loss rispetto all'output + double grad_output[N_NEURONI_OUTPUT]; + for (int i = 0; i < N_NEURONI_OUTPUT; i++) { + grad_output[i] = softmax_output[i] - (i == target ? 1 : 0); + } + + // Gradiente rispetto ai pesi e bias del layer di output + for (int i = 0; i < N_NEURONI_OUTPUT; i++) { + for (int j = 0; j < N_NEURONI_HIDDEN; j++) { + rete->layers[2].percettroni[i].pesi[j] -= LEARNING_RATE * grad_output[i] * output_final[j]; + } + rete->layers[2].percettroni[i].bias -= LEARNING_RATE * grad_output[i]; + } + + // Gradiente rispetto ai pesi e bias del layer nascosto + double grad_hidden[N_NEURONI_HIDDEN]; + for (int j = 0; j < N_NEURONI_HIDDEN; j++) { + grad_hidden[j] = 0.0; + for (int i = 0; i < N_NEURONI_OUTPUT; i++) { + grad_hidden[j] += grad_output[i] * rete->layers[2].percettroni[i].pesi[j]; + } + grad_hidden[j] *= relu_derivata(output_final[j]); // Derivata di ReLU + } + + for (int j = 0; j < N_NEURONI_HIDDEN; j++) { + for (int k = 0; k < N_INPUTS; k++) { + rete->layers[1].percettroni[j].pesi[k] -= LEARNING_RATE * grad_hidden[j] * input[k]; + } + rete->layers[1].percettroni[j].bias -= LEARNING_RATE * grad_hidden[j]; + } +} + +// Serializzazione della rete +void salva_rete(ReteNeurale *rete, const char *filename) { + FILE *file = fopen(filename, "wb"); + if (file == NULL) { + perror("Errore nell'apertura del file"); + return; + } + fwrite(rete, sizeof(ReteNeurale), 1, file); + fclose(file); +} + +// Deserializzazione della rete +ReteNeurale carica_rete(const char *filename) { + FILE *file = fopen(filename, "rb"); + if (file == NULL) { + perror("Errore nell'apertura del file"); + exit(1); + } + ReteNeurale rete; + fread(&rete, sizeof(ReteNeurale), 1, file); + fclose(file); + return rete; +} + +// Funzione per caricare 4 immagini casuali dal dataset +void carica_immagini_casuali(Dataset *dataset, byte immagini[4][N_INPUTS], byte *etichette) { + for (int i = 0; i < 4; i++) { + int indice_casuale = rand() % dataset->size; // Sceglie un'immagine casuale + for (int j = 0; j < N_INPUTS; j++) { + immagini[i][j] = dataset->istanze[indice_casuale].dati[j]; // Copia i dati dell'immagine + } + etichette[i] = dataset->istanze[indice_casuale].classificazione; // Copia l'etichetta + } +} + +// Funzione per fare previsioni su 4 immagini +void fai_previsioni(ReteNeurale *rete, byte immagini[4][N_INPUTS], byte *etichette) { + for (int i = 0; i < 4; i++) { + double *output = prevedi(rete, immagini[i]); // Passa l'immagine attraverso la rete + int previsione = 0; + double max_prob = output[0]; + for (int j = 1; j < N_NEURONI_OUTPUT; j++) { + if (output[j] > max_prob) { + max_prob = output[j]; + previsione = j; + } + } + printf("Immagine %d: Etichetta vera = %d, Previsione = %d\n", i + 1, etichette[i], previsione); + free(output); // Libera la memoria allocata per l'output + } +} + +int main() { + srand(time(NULL)); + + printf("Mi appresto a caricare la rete\n"); + // Creazione della rete + ReteNeurale rete = crea_rete(); + + printf("Mi appresto a caricare il dataset\n"); + // Caricamento del dataset (da implementare) + Dataset *dataset; + dataset = get_dataset("cifar-10/data_batch_1.bin"); + + printf("Mi appresto ad allenare\n"); + // Addestramento della rete + allena(&rete, dataset); + + // Salvataggio della rete + salva_rete(&rete, "rete_neurale.bin"); + + // Caricamento di 4 immagini casuali + byte immagini[4][N_INPUTS]; + byte etichette[4]; + carica_immagini_casuali(dataset, immagini, etichette); + + // Previsioni sulle immagini + fai_previsioni(&rete, immagini, etichette); + + // Liberazione della memoria + // (Da implementare) + + return 0; +} \ No newline at end of file diff --git a/deep_seek_singolo b/deep_seek_singolo new file mode 100755 index 0000000..1dda9d6 Binary files /dev/null and b/deep_seek_singolo differ diff --git a/deep_seek_singolo.c b/deep_seek_singolo.c new file mode 100644 index 0000000..1081d21 --- /dev/null +++ b/deep_seek_singolo.c @@ -0,0 +1,228 @@ +#include +#include +#include +#include +#include + +#include "cifar-10/cifar10_manager.h" + +// Costanti configurabili +#define N_LAYERS 3 // Numero di layer (input, hidden, output) +#define N_NEURONI_HIDDEN 128 // Numero di neuroni nei layer nascosti +#define N_NEURONI_OUTPUT 1 // Un solo neurone di output (binario) +#define N_EPOCHE 10 // Numero di epoche di addestramento +#define LEARNING_RATE 0.01 // Tasso di apprendimento +#define N_INPUTS 3072 // Dimensioni di un'immagine CIFAR-10 (32x32x3) + +typedef struct { + double *pesi; + double bias; + int size; +} Percettrone; + +typedef struct { + Percettrone *percettroni; + int size; +} Layer; + +typedef struct { + Layer *layers; + int size; +} ReteNeurale; + + +double sigmoide(double); +double relu(double); +double relu_derivata(double); +double softmax(double*, int, int); +ReteNeurale crea_rete(); +int prevedi(ReteNeurale*, byte*); +void allena(ReteNeurale*, Dataset*); +void salva_rete(ReteNeurale*, const char*); +ReteNeurale carica_rete(const char*); +void carica_immagini_casuali(Dataset*, byte[][N_INPUTS], byte*); +void fai_previsioni(ReteNeurale*, byte[][N_INPUTS], byte*); +void backpropagation(ReteNeurale*, byte*, byte, double); +double forward_pass(ReteNeurale*, byte*); + + +// Funzioni di utilità +double sigmoide(double x) { + return 1.0 / (1.0 + exp(-x)); +} + +double sigmoide_derivata(double x) { + return sigmoide(x) * (1 - sigmoide(x)); +} + +double relu(double x) { + return x > 0 ? x : 0; +} + +double relu_derivata(double x) { + return x > 0 ? 1 : 0; +} + +// Inizializzazione della rete +ReteNeurale crea_rete() { + ReteNeurale rete; + rete.size = N_LAYERS; + rete.layers = (Layer *)malloc(N_LAYERS * sizeof(Layer)); + + // Layer di input (non ha pesi, solo pass-through) + rete.layers[0].size = N_INPUTS; + rete.layers[0].percettroni = NULL; + + // Layer nascosto + rete.layers[1].size = N_NEURONI_HIDDEN; + rete.layers[1].percettroni = (Percettrone *)malloc(N_NEURONI_HIDDEN * sizeof(Percettrone)); + for (int i = 0; i < N_NEURONI_HIDDEN; i++) { + rete.layers[1].percettroni[i].size = N_INPUTS; + rete.layers[1].percettroni[i].pesi = (double *)malloc(N_INPUTS * sizeof(double)); + for (int j = 0; j < N_INPUTS; j++) { + rete.layers[1].percettroni[i].pesi[j] = ((double)rand() / RAND_MAX) * 2 - 1; // Pesi casuali tra -1 e 1 + } + rete.layers[1].percettroni[i].bias = ((double)rand() / RAND_MAX) * 2 - 1; // Bias casuale tra -1 e 1 + } + + // Layer di output + rete.layers[2].size = N_NEURONI_OUTPUT; + rete.layers[2].percettroni = (Percettrone *)malloc(N_NEURONI_OUTPUT * sizeof(Percettrone)); + for (int i = 0; i < N_NEURONI_OUTPUT; i++) { + rete.layers[2].percettroni[i].size = N_NEURONI_HIDDEN; + rete.layers[2].percettroni[i].pesi = (double *)malloc(N_NEURONI_HIDDEN * sizeof(double)); + for (int j = 0; j < N_NEURONI_HIDDEN; j++) { + rete.layers[2].percettroni[i].pesi[j] = ((double)rand() / RAND_MAX) * 2 - 1; // Pesi casuali tra -1 e 1 + } + rete.layers[2].percettroni[i].bias = ((double)rand() / RAND_MAX) * 2 - 1; // Bias casuale tra -1 e 1 + } + + return rete; +} + +// Forward pass +double forward_pass(ReteNeurale *rete, byte *input) { + double *output_hidden = (double *)malloc(N_NEURONI_HIDDEN * sizeof(double)); + double output_final; + + // Layer nascosto + for (int i = 0; i < N_NEURONI_HIDDEN; i++) { + double somma = 0.0; + for (int j = 0; j < N_INPUTS; j++) { + somma += input[j] * rete->layers[1].percettroni[i].pesi[j]; + } + somma += rete->layers[1].percettroni[i].bias; + output_hidden[i] = relu(somma); // Applica ReLU + } + + // Layer di output + double somma = 0.0; + for (int j = 0; j < N_NEURONI_HIDDEN; j++) { + somma += output_hidden[j] * rete->layers[2].percettroni[0].pesi[j]; + } + somma += rete->layers[2].percettroni[0].bias; + output_final = sigmoide(somma); // Applica sigmoide + + free(output_hidden); + return output_final; +} + +// Backpropagation +void backpropagation(ReteNeurale *rete, byte *input, byte target, double output_final) { + // Gradiente della loss (binary cross-entropy) + double grad_output = output_final - target; + + // Gradiente rispetto ai pesi e bias del layer di output + for (int j = 0; j < N_NEURONI_HIDDEN; j++) { + rete->layers[2].percettroni[0].pesi[j] -= LEARNING_RATE * grad_output * output_final * (1 - output_final) * input[j]; + } + rete->layers[2].percettroni[0].bias -= LEARNING_RATE * grad_output * output_final * (1 - output_final); + + // Gradiente rispetto ai pesi e bias del layer nascosto + double grad_hidden[N_NEURONI_HIDDEN]; + for (int j = 0; j < N_NEURONI_HIDDEN; j++) { + grad_hidden[j] = grad_output * output_final * (1 - output_final) * rete->layers[2].percettroni[0].pesi[j]; + grad_hidden[j] *= relu_derivata(output_final); // Derivata di ReLU + } + + for (int j = 0; j < N_NEURONI_HIDDEN; j++) { + for (int k = 0; k < N_INPUTS; k++) { + rete->layers[1].percettroni[j].pesi[k] -= LEARNING_RATE * grad_hidden[j] * input[k]; + } + rete->layers[1].percettroni[j].bias -= LEARNING_RATE * grad_hidden[j]; + } +} + +// Addestramento +void allena(ReteNeurale *rete, Dataset *dataset) { + for (int epoca = 0; epoca < N_EPOCHE; epoca++) { + printf("Epoca %d\n", epoca+1); + for (int i = 0; i < dataset->size; i++) { + byte *input = dataset->istanze[i].dati; + byte target = (dataset->istanze[i].classificazione == 7) ? 1 : 0; // 1 per cavalli, 0 per il resto + + // Forward pass + double output_final = forward_pass(rete, input); + + // Backpropagation + backpropagation(rete, input, target, output_final); + } + printf("Epoca %d completata\n", epoca + 1); + } +} + +// Funzione per fare previsioni +int prevedi(ReteNeurale *rete, byte *input) { + double output_final = forward_pass(rete, input); + return (output_final >= 0.5) ? 2 : 0; // 2 per cavalli, 0 per il resto +} + +// Funzione per caricare 4 immagini casuali dal dataset +void carica_immagini_casuali(Dataset *dataset, byte immagini[4][N_INPUTS], byte *etichette) { + for (int i = 0; i < 4; i++) { + int indice_casuale = rand() % dataset->size; // Sceglie un'immagine casuale + for (int j = 0; j < N_INPUTS; j++) { + immagini[i][j] = dataset->istanze[indice_casuale].dati[j]; // Copia i dati dell'immagine + } + etichette[i] = dataset->istanze[indice_casuale].classificazione; // Copia l'etichetta + } +} + +// Funzione per fare previsioni su 4 immagini +void fai_previsioni(ReteNeurale *rete, byte immagini[4][N_INPUTS], byte *etichette) { + for (int i = 0; i < 4; i++) { + int previsione = prevedi(rete, immagini[i]); + printf("Immagine %d: Etichetta vera = %d, Previsione = %d\n", i + 1, etichette[i], previsione); + } +} + +int main() { + srand(time(NULL)); + + // Creazione della rete + ReteNeurale rete = crea_rete(); + + // Caricamento del dataset (da implementare) + Dataset *dataset; + dataset = get_dataset("cifar-10/data_batch_1.bin"); + // dataset = carica_dataset("cifar10.bin"); + + // Addestramento della rete + allena(&rete, dataset); + + // Salvataggio della rete + // salva_rete(&rete, "rete_neurale.bin"); + + // Caricamento di 4 immagini casuali + byte immagini[4][N_INPUTS]; + byte etichette[4]; + carica_immagini_casuali(dataset, immagini, etichette); + + // Previsioni sulle immagini + fai_previsioni(&rete, immagini, etichette); + + // Liberazione della memoria + // (Da implementare) + + return 0; +} \ No newline at end of file diff --git a/percettroni.h b/percettroni.h index 69dfad0..6950d6e 100644 --- a/percettroni.h +++ b/percettroni.h @@ -8,16 +8,16 @@ char *file_label = "mnist/t10k-labels.idx1-ubyte"; */ /* char *file_immagini = "mnist/train-images.idx3-ubyte"; char *file_label = "mnist/train-labels.idx1-ubyte"; */ -//#include "mnist/mnist_manager.h" +// #include "mnist/mnist_manager.h" #include "cifar-10/cifar10_manager.h"; -//char *file_immagini = "cifar-10/data_batch_1.bin"; -//char *file_immagini = "cifar-10/data_batch_2.bin"; -//char *file_immagini = "cifar-10/data_batch_3.bin"; -//char *file_immagini = "cifar-10/data_batch_4.bin"; -//char *file_immagini = "cifar-10/data_batch_5.bin"; -char *file_immagini = "cifar-10/test_batch.bin"; +char *file_immagini = "cifar-10/data_batch_1.bin"; +// char *file_immagini = "cifar-10/data_batch_2.bin"; +// char *file_immagini = "cifar-10/data_batch_3.bin"; +// char *file_immagini = "cifar-10/data_batch_4.bin"; +// char *file_immagini = "cifar-10/data_batch_5.bin"; +//char *file_immagini = "cifar-10/test_batch.bin"; -//#include "xor_manager.h" +// #include "xor_manager.h" // Siccome il char è un byte che rappresenta il valore tra 0 e 255. Per evitare confusioni definisco il tipo "byte" come in Java typedef unsigned char byte; @@ -50,10 +50,15 @@ Percettrone inzializza_percettrone(int); ReteNeurale inizializza_rete_neurale(int, int, int); Layer inizializza_layer(int, int); -double sigmoide(Percettrone p, double*); +double sigmoide(Percettrone p, double *); +double derivata_sigmoide(double); double **elabora_sigmoidi(ReteNeurale, Istanza); + +double **elabora_gradienti(ReteNeurale, double, double **); void discesa_gradiente(ReteNeurale, double **, double **); double calcola_gradiente_disceso(ReteNeurale, int, int, double **); + +void aggiorna_pesi(ReteNeurale*, double**, double**, Istanza); void correggi_pesi_percettrone_double(Percettrone *, int, double **, double); void correggi_pesi_percettrone_byte(Percettrone *, Istanza, double, int); @@ -69,14 +74,15 @@ ReteNeurale *caricaReteNeurale(const char *); double randomico() { // Genero numeri nell'intervallo [-1,1] - return ((double)(rand() % 101 * 0.01 * 2.0) -1.0); + return ((double)(rand() % 101 * 0.01 * 2.0) - 1.0); } Percettrone inizializza_percettrone(int n_pesi) { Percettrone p; p.pesi = (double *)malloc(sizeof(double) * n_pesi); - for (int i = 0; i < n_pesi; i++) { + for (int i = 0; i < n_pesi; i++) + { p.pesi[i] = randomico(); } @@ -130,27 +136,49 @@ ReteNeurale inizializza_rete_neurale(int numero_layers, int numero_percettroni_i return r; } - /* ################# PREVISIONI ################################ */ +double **elabora_gradienti(ReteNeurale rete_neurale, double gradiente_errore, double **sigmoidi) +{ + double **gradienti = (double **)malloc(sizeof(double *) * rete_neurale.size); + + // Alloco la dimensione per ogni layer + for (int indice_layer = 0; indice_layer < rete_neurale.size; indice_layer++) + { + gradienti[indice_layer] = (double *)malloc(sizeof(double) * rete_neurale.layers[indice_layer].size); + } + + // Gradiente del percettrone output + gradienti[rete_neurale.size - 1][0] = gradiente_errore * derivata_sigmoide(sigmoidi[rete_neurale.size - 1][0]); + + discesa_gradiente(rete_neurale, sigmoidi, gradienti); + + return gradienti; +} double sigmoide(Percettrone p, double *valori) { double sommatoria = 0.0; - for (int i = 0; i < p.size; i++) { + for (int i = 0; i < p.size; i++) + { sommatoria += (valori[i] * p.pesi[i]); - //printf("valore [%f] peso[%f] ", valori[i], p.pesi[i]); + // printf("valore [%f] peso[%f] ", valori[i], p.pesi[i]); } sommatoria += p.bias; double risultato = 1.0 / (1.0 + exp(-sommatoria)); - //printf(" sommatoria %f -> %f\n",sommatoria, risultato); + // printf(" sommatoria %f -> %f\n",sommatoria, risultato); return risultato; } +double derivata_sigmoide(double valore) +{ + return (valore * (1.0 - valore)); +} + int previsione(double valore) { if (valore >= soglia_sigmoide) @@ -158,39 +186,24 @@ int previsione(double valore) else return 0; } - + void discesa_gradiente(ReteNeurale rete, double **sigmoidi, double **gradienti) { - //printf("Qui?\n"); - // For che scorre i layer dal penultimo al primo QUINI SIZE -2 for (int indice_layer = rete.size - 2; indice_layer >= 0; indice_layer--) { - //printf("layer: %d ", indice_layer); - // printf("Mi trovo nel layer %d, ho %d percettroni\n", indice_layer, rete.layers[indice_layer].size); - - // For che scorre i percettroni del layer partendo dal primo - // Per ogni percettrone mi devo prendere il gradiente disceso dal livello sopra e moltiplicarlo per la derivata di attivazione for (int indice_percettrone = 0; indice_percettrone < rete.layers[indice_layer].size; indice_percettrone++) { - //printf("percettrone: %d ", indice_percettrone); double derivata_attivazione = sigmoidi[indice_layer][indice_percettrone] * (1.0 - sigmoidi[indice_layer][indice_percettrone]); - - // Passo anche l'indice del percettrone perchè corrisponde all'indice del peso del livello sopra double gradiente_disceso = calcola_gradiente_disceso(rete, indice_layer + 1, indice_percettrone, gradienti); gradienti[indice_layer][indice_percettrone] = gradiente_disceso * derivata_attivazione; } - //printf("\n"); } - //printf("Qui ?\n"); } double calcola_gradiente_disceso(ReteNeurale rete, int livello, int indice_peso, double **gradienti) { - // printf("Qui ci arrivo\n"); double sommatoria = 0.0; - // printf("Layer %d: N_percettroni: %d\n", livello, rete.layers[livello].size); - // Calcolo la sommatoria dei gradienti dei percettroni per i pesi for (int indice_percettrone = 0; indice_percettrone < rete.layers[livello].size; indice_percettrone++) { sommatoria += (gradienti[livello][indice_peso] * rete.layers[livello].percettroni[indice_percettrone].pesi[indice_peso]); @@ -201,34 +214,63 @@ double calcola_gradiente_disceso(ReteNeurale rete, int livello, int indice_peso, double **elabora_sigmoidi(ReteNeurale rete, Istanza istanza) { - // 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 *) * rete.size); double *inputs = (double *)malloc(sizeof(double *) * N_INPUTS); - for(int i = 0; i < N_INPUTS; i++) { + for (int i = 0; i < N_INPUTS; i++) + { inputs[i] = (double)istanza.dati[i]; } sigmoidi[0] = (double *)malloc(sizeof(double) * rete.layers[0].size); - for(int indice_percettrone = 0; indice_percettrone < rete.layers[0].size; indice_percettrone ++) { + for (int indice_percettrone = 0; indice_percettrone < rete.layers[0].size; indice_percettrone++) + { sigmoidi[0][indice_percettrone] = sigmoide(rete.layers[0].percettroni[indice_percettrone], inputs); } - for(int indice_layer = 1; indice_layer < rete.size; indice_layer ++) { + for (int indice_layer = 1; indice_layer < rete.size; indice_layer++) + { sigmoidi[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 ++) { - sigmoidi[indice_layer][indice_percettrone] = sigmoide(rete.layers[indice_layer].percettroni[indice_percettrone], sigmoidi[indice_layer-1]); + for (int indice_percettrone = 0; indice_percettrone < rete.layers[indice_layer].size; indice_percettrone++) + { + sigmoidi[indice_layer][indice_percettrone] = sigmoide(rete.layers[indice_layer].percettroni[indice_percettrone], sigmoidi[indice_layer - 1]); } } return sigmoidi; } - /* ################# CORREZIONI ################################ */ +void aggiorna_pesi(ReteNeurale *rete_neurale, double **sigmoidi, double **gradienti, Istanza istanza) +{ + 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] * sigmoidi[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 = rete_neurale->size - 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], istanza, gradienti[0][indice_percettrone], indice_percettrone); + } + } + } +} void correggi_pesi_percettrone_double(Percettrone *p, int layer, double **input, double gradiente_percettrone) { @@ -259,8 +301,6 @@ void correggi_pesi_percettrone_byte(Percettrone *p, Istanza input, double gradie p->bias += (gradiente_percettrone * LRE); } - - /* ################# IMPORT EXPORT ################################ */ @@ -352,129 +392,3 @@ ReteNeurale *caricaReteNeurale(const char *filename) fclose(file); return rete; } - - - - - - - - - -/* 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) -{ - - 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; -} - -// 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) -{ - - double *funzioni = (double *)malloc(sizeof(double) * layer.size); - - for (int i = 0; i < layer.size; i++) - { - 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; -} - */ \ No newline at end of file diff --git a/rete_neurale.bin b/rete_neurale.bin new file mode 100644 index 0000000..297b9fe Binary files /dev/null and b/rete_neurale.bin differ diff --git a/rete_pesi.bin b/rete_pesi.bin deleted file mode 100644 index 9310801..0000000 Binary files a/rete_pesi.bin and /dev/null differ