Ragazzi, sinceramente non so quanti di voi ne capiscano su questo argomento e meglio ancora quanti hanno esperienza nella progettazione e nell'applicazione di una rete di questo tipo. Sto sbattendo la testa sul monitor ormai da più di un mese ma non riesco a far funzionare questo benedetto programma. Usa una rete neurale con 2 neuroni in input, 3-4 nello strato nascosto e 1 in output. Lo sto facendo per esercitarmi quindi per ora il suo compito è soltanto quello di fare le somme. Posto qui il codice. Ho seguito decine(e se dico decine sono veramente decine) di guide, ma i risultati sono lo stesso negativi. Non capisco quale possa essere il problema. Vi prego di aiutarmi e, se non ci fosse nessuno in grado di farlo, mi potreste dire il nome di qualche forum dedicato a questo argomento, magari via messaggio personale... Grazie in anticipo.
codice:
#include <stdio.h>
#include <math.h>
#define n_es 20
#define n_h 4
#define n_b 4
float input[2];
float w_x_h[2][n_h];
float bias[n_b];
float delta_h[n_h];
float neur_h[n_h];
float w_h_y[n_h];
float bias_y=1;
float delta_y;
float output=0;
float err_y, err_h[n_h];
float epsi=0.2;
float global_err=0;
float sig(float x){ //funzione sigmoidale
return 1/(1+pow(M_E, -x));
}
float neural_net(float *input1){ //rete neurale
float rit=0;
int i, j;
for(i=0;i<n_h;i++){ //somma pesata neuroni strato nascosto
for(j=0;j<2;j++){
neur_h[i]=neur_h[i]+input1[j]*w_x_h[j][i];
}
}
for(i=0;i<n_b;i++){ //+bias
neur_h[i]=neur_h[i]+bias[i];
}
for(i=0;i<n_h;i++){ //valore di attivazonie neuroni strato nascosto
neur_h[i]=sig(neur_h[i]);
}
for(j=0;j<n_h;j++){ //somma pesata neurone di output
rit=rit+neur_h[j]*w_h_y[j];
}
rit=rit+bias_y;
rit=sig(rit); //valore di attivazione neurone di output
return rit;
}
float delta_fun(float error, float neur){ //funzione delta
return error*neur*(1-neur);
}
float mod_pesi(float w, float epsi, float delta, float neur){
return w+(epsi*delta*neur);
}
int main(){
float es_x[n_es][2];
float es_y[n_es];
float max=0;
int i, j, y, count_es=0;
for(i=0;i<n_es;i++){
es_x[i][0]=rand() % 100;
es_x[i][1]=rand() % 100;
es_y[i]=es_x[i][0]+es_x[i][1];
printf("\n%f + %f = %f", es_x[i][0], es_x[i][1], es_y[i]);
}
for(i=0;i<n_es;i++){
if(max<es_y[i]){
max=es_y[i];
}
}
for(i=0;i<n_es;i++){
es_x[i][0]=es_x[i][0]/max;
es_x[i][1]=es_x[i][1]/max;
es_y[i]=es_y[i]/max;
}
printf("\n");
for(i=0;i<2;i++){
w_x_h[i][0]=1;
w_x_h[i][1]=1;
w_x_h[i][2]=1;
w_x_h[i][3]=1;
w_h_y[0]=1;
w_h_y[1]=1;
w_h_y[2]=1;
w_h_y[3]=1;
}
bias[0]=1;
bias[1]=1;
bias[2]=1;
bias[3]=1;
for(i=0;i<n_h;i++){
neur_h[i]=0;
}
for(;;){
printf("\n");
count_es=0;
printf("\nErrore globale: %f\n", global_err);
if(global_err==n_es){
break;
}else{
global_err=0;
}
while(count_es!=n_es){
input[0]=es_x[count_es][0];
input[1]=es_x[count_es][1];
output=neural_net(input);
err_y=es_y[count_es]-output; //calcolo errore strato di output
if(err_y<0.1&&err_y>-0.1){
global_err++;
}
delta_y=delta_fun(err_y, output); //calcolo delta neurone di output
for(i=0;i<n_h;i++){ //calcolo errore strato nascosto
err_h[i]=delta_y*w_h_y[i];
}
for(i=0;i<n_h;i++){ //calcolo delta strato nascosto
delta_h[i]=err_h[i]*neur_h[i]*(1-neur_h[i]);
}
for(i=0;i<n_h;i++){ //modifica pesi strato di output
w_h_y[i]=mod_pesi(w_h_y[i], epsi, delta_y, output);
}
bias_y=bias_y+(epsi*delta_y); //modifica bias
for(i=0;i<2;i++){ //modifica pesi strato nascosto
for(j=0;j<n_h;j++){
w_x_h[i][j]=mod_pesi(w_x_h[i][j], epsi, delta_h[j], input[i]);
}
}
for(i=0;i<n_b;i++){ //modifica bias
bias[i]=bias[i]+(epsi*delta_h[i]);
}
printf("\n%f + %f = %f", input[0]*max, input[1]*max, output*max);
count_es++;
}
}
input[0]=0.75;
input[1]=1;
printf("\nSomma tra %f e %f = %f", input[0]*4, input[1]*4, neural_net(input)*4);
return 0;
}