223 lines
8.4 KiB
C
223 lines
8.4 KiB
C
/*
|
|
Definisco i percettroni della rete neurale per il dataset CIFAR10
|
|
Struttura della rete:
|
|
Livello 1: 256 percettroni con 3072 input ciascuno
|
|
Livello 2: 128 percettroni con 256 input ciascuno
|
|
Livello output: 10 percettroni con 128 input ciascuno
|
|
|
|
In output ci sono 10 percettroni, ognuno di essi è associato ad una categoria del CIFAR10. Alla fine dell'addestramento, la previsione sarà
|
|
data dal percettrone di output che avrà il valore 1 rispetto agli altri 9.
|
|
*/
|
|
|
|
#include <math.h>
|
|
#include "dataset_manager.h"
|
|
|
|
double LRE = 0.2;
|
|
double soglia_sigmoide = 0.5;
|
|
|
|
typedef struct {
|
|
double *pesi;
|
|
double bias;
|
|
int size;
|
|
} Percettrone;
|
|
|
|
typedef struct {
|
|
Percettrone *percettroni;
|
|
int size;
|
|
} Layer;
|
|
|
|
typedef struct {
|
|
Layer *layers;
|
|
int size;
|
|
} ReteNeurale;
|
|
|
|
double randomico();
|
|
|
|
Percettrone inzializza_percettrone(int);
|
|
ReteNeurale inizializza_rete_neurale(int);
|
|
Layer inizializza_layer(int, int);
|
|
|
|
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);
|
|
|
|
int previsione(double);
|
|
|
|
//Questa funzione genera un valore reale random compreso nell'intervallo [-1, 1]
|
|
double randomico() {
|
|
// Genero numeri nell'intervallo [-1,1]
|
|
return ((double)(rand() % 101 * 0.01 * 2 ) -1);
|
|
}
|
|
|
|
//Questa funzione inizializza il percettrone allocando la memoria in base al numero dei pesi che voglio ed inizializza il loro valore usando randomico()
|
|
Percettrone inizializza_percettrone(int n_pesi) {
|
|
Percettrone p;
|
|
p.pesi = (double*) malloc(sizeof(double) * n_pesi);
|
|
for(int i = 0; i < n_pesi; i++)
|
|
p.pesi[i] = randomico();
|
|
|
|
p.bias = randomico();
|
|
|
|
p.size = n_pesi;
|
|
|
|
return p;
|
|
}
|
|
|
|
//Questa funzione inizializza una rete neurale. Diamo il numero di layer desiderato e restituisce un ReteNeurale
|
|
ReteNeurale inizializza_rete_neurale(int n_layers) {
|
|
ReteNeurale r;
|
|
r.layers = (Layer*)malloc(sizeof(Layer) * n_layers);
|
|
r.size = n_layers;
|
|
|
|
return r;
|
|
}
|
|
|
|
//Questa funzione serve ad inizializzare il singolo layer con il numero di percettroni che vogliamo
|
|
//Ogni percettrone a sua volta viene automaticamente inizializzato con il numero di pesi che vogliamo e coi valori di partenza
|
|
Layer inizializza_layer(int n_percettroni, int n_pesi) {
|
|
Layer layer;
|
|
layer.percettroni = (Percettrone *)malloc(sizeof(Percettrone) * n_percettroni);
|
|
|
|
for(int i = 0; i < n_percettroni; i++) {
|
|
layer.percettroni[i] = inizializza_percettrone(n_pesi);
|
|
}
|
|
|
|
layer.size = n_percettroni;
|
|
|
|
return layer;
|
|
}
|
|
|
|
//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;
|
|
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 / ( 1 + 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 / ( 1 + potenza_e);
|
|
//printf("risultato= %f\n", risultato);
|
|
|
|
return risultato;
|
|
}
|
|
|
|
//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);
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
return funzioni;
|
|
}
|
|
|
|
//Questa funzione restituisce il valore 0,1 in base alla soglia di attivazione della funzione sigmoide
|
|
int previsione(double valore) {
|
|
if(valore >= soglia_sigmoide)
|
|
return 1;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
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]);
|
|
|
|
//if(indice_layer == 3)
|
|
// printf("qui ci arrivo layer: %d, percettrone: %d, input:%d, peso: %f\n", indice_layer, indice_percettrone, indice_peso, rete->layers[indice_layer].percettroni[indice_percettrone].pesi[indice_peso]);
|
|
|
|
//printf("gradiente applicato %f, sigmoide %f\n", gradienti[indice_layer][indice_percettrone], sigmoidi[indice_layer][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);
|
|
}
|
|
}
|
|
}
|
|
|
|
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].bias -= (gradienti[indice_layer][indice_percettrone] * LRE);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* void correggi_pesi_layer(Percettrone[], int, int, double**, double[], double[]);
|
|
void correggi_pesi_layer_uno(Percettrone[], int, int, double**, byte[], double[]);
|
|
|
|
void correggi_pesi_layer(Percettrone percettroni_layer[], int size_percettroni, int size_inputs, double **gradienti, double inputs[], double gradienti_bias[]) {
|
|
for(int i = 0; i < size_percettroni; i++) {
|
|
// Non termina questo for
|
|
for(int j = 0; j < size_inputs; j++) {
|
|
percettroni_layer[i].pesi[j] -= LRE * gradienti[i][j] * inputs[j];
|
|
}
|
|
percettroni_layer[i].bias -= LRE * gradienti_bias[i];
|
|
}
|
|
}
|
|
|
|
void correggi_pesi_layer_uno(Percettrone percettroni_layer[], int size_percettroni, int size_inputs, double **gradienti, byte inputs[], double gradienti_bias[]) {
|
|
|
|
for(int i = 0; i < size_percettroni; i++) {
|
|
for(int j = 0; j < size_inputs; j++) {
|
|
percettroni_layer[i].pesi[j] -= LRE * gradienti[i][j] * inputs[j];
|
|
}
|
|
percettroni_layer[i].bias -= LRE * gradienti_bias[i];
|
|
}
|
|
} */
|