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;
}