IA/classificatore_immagini
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

passare al calcolo delle funzioni di attivazione di prima perchè mi sono rotto

Browse Source
This commit is contained in:
mirimatcode
2025-02-24 14:03:56 +01:00
parent b8c5b82f72
commit faebcf7c59
6 changed files with 100 additions and 370 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
classificatore_singolo
View File

Binary file not shown.

125
classificatore_singolo.c
View File

@@ -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 indice_set = 0; indice_set < 1/* set.size */; indice_set++)
{
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");
}
} */
double **funzioni_attivazione = elabora_funzioni_attivazione(rete_neurale, set.istanze[indice_set], TIPO_FUNZIONE);
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 *****
*/
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);

305
percettroni.h
View File

@@ -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 count_2 = 0; count_2 < rete_neurale->layers[count].size; count_2++)
{
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);
printf("[%d][%d]: %f\t", count, count_2, matrice[count][count_2]);
}
printf("\n");
}
}
// 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);
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");
}
*/
/*
// 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++)
{
//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);
}
}
} */

BIN
prova_passaggio_parametri Executable file
View File

Binary file not shown.

30
prova_passaggio_parametri.c
View File

@@ -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);
}
@@ -38,3 +37,20 @@ void cambia(int **matrix) {
}
}
}
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;
}
}

0
rete_pesi_deep_feed_forward_93-100.bin → rete_pesi_deep_feed_forward.bin
View File