zj_pb.cpp

bp反向传播算法,用c++编写,用于航空运输预测问题.

#include <iostream.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

class neuron
{
public:
	double in ;
	double out ;
	double delta ;
	double err ;
	double bias ;
	void setval(double i=0.0 , double o=0.0 ,double d=0.0)
	{
		in=i;
		out=o;
		delta=d ;
		err=0.0 ;
	};
	void clearval(double i=0.0 ,double o=0.0)
	{
		in=i ;
		out=o ;
		err=0.0 ;
	}
};


double sigmoid(double num) 
{
	return (double)(1/(1+exp(-num)));
}


main()
{
    //int input_row ,input_col,target_num, in_lay_num,out_lay_num , hide_lay_num,max_time ;
	int i,j,k;
	int max_time ;
	double learn_rate,expect_err,bias_factor ;
	const int input_row=28 ;
	const int input_col=4 ;
	const int target_num=1 ;
	const int out_lay_num=target_num ;
	const int in_lay_num=input_col ;
	
	
	const int hide_lay_num = 30 ;         //custom
	learn_rate = 0.05 ;           //custom 
    max_time = 10001 ;           //custom
	expect_err= 0.00001 ;     //custom
	bias_factor= 10 ;            //custom 


	// initialize input and target matrix *****************************************
	double input[input_row][input_col] ;
	double target[input_row] ;

	FILE *f ;
	
	f=fopen("input.txt","r");
	i=0;
	while (fscanf(f,"%lf %lf %lf %lf",&input[i][0] ,&input[i][1],&input[i][2],&input[i][3])!=-1)
	{
        i++;
	}
    fclose(f) ;

	f=fopen("target.txt","r");
	i=0 ;
	while(fscanf(f,"%lf",&target[i])!=-1)
	{
		i++;
	}
	fclose(f) ;
    
	//standarlize target matrix **********************************************
	for(i=0 ; i<input_row ; i++)
	{
		target[i]-=75 ;
		target[i]/=75 ;
	}
 
	//standarlize input matrix 
	for(i=0 ; i<input_row ; i++)
	{
		for(j=0 ; j<input_col-1 ;j++)
		{

			input[i][j]/=10 ;
		}
	}
	

	// initialize weight ******************************************************
	double w_1[in_lay_num][hide_lay_num] ;
	double w_2[hide_lay_num][out_lay_num] ;

	srand((unsigned)(time(NULL)));
	
	for(i=0 ; i<in_lay_num ; i++)
	{
		for(j=0 ; j<hide_lay_num ; j++)
		{
			w_1[i][j] = (double)(rand())/(32767/2) - 1 ;
		}
	}
	
	for(i=0 ; i<hide_lay_num ; i++)
	{
		for(j=0 ; j<out_lay_num ; j++)
		{
			w_2[i][j] = (double)(rand())/(32767/2) - 1 ;
		}
	}

    
	// initialize neuron **************************************************
	neuron in_n[in_lay_num] ;
	neuron hide_n[hide_lay_num] ;
	neuron out_n[out_lay_num] ;
   
	for (i=0 ; i<in_lay_num ; i++)
	{
		in_n[i].setval();
	}
	for (i=0 ; i<hide_lay_num ; i++)
	{
		hide_n[i].setval();
		hide_n[i].bias=((double)(rand())/(32767/2) - 1)*bias_factor ;
	}
	for (i=0 ; i<out_lay_num ; i++)
	{
		out_n[i].setval();
		out_n[i].bias=(double)(rand())/(32767/2) - 1 ;
	}
    
	


	// loop ********************************************************
	double sum_err=0.0 ;

	for (k=0 ; k<max_time || sum_err<expect_err ; k++)
	{
		
		sum_err=0.0 ;

		for(int row=0 ; row<input_row ; row++)
		{
			//initialize input to in_n
			for(i=0 ; i<in_lay_num ; i++)
			{
				in_n[i].out=input[row][i];
			}
			
			
			//layer1 to layer2 *************************************
			for( j=0 ; j<hide_lay_num ; j++)
			{
				for(i=0 ;i<in_lay_num ; i++)
				{
					hide_n[j].in+=w_1[i][j]*in_n[i].out  ;
				}
			}
           // if (row==0) cout<<hide_n[0].in<<"aaa "<<k<<endl ;
			//inspire function *************************************
			for (i=0 ; i<hide_lay_num ;i++)
			{
				hide_n[i].out=sigmoid(hide_n[i].in-hide_n[i].bias) ;
			}

			//layer2 to layer3 *************************************
			for (j=0 ; j<out_lay_num ; j++)
			{
				for(i=0 ; i<hide_lay_num ; i++)
				{
					out_n[j].in+=w_2[i][j]*hide_n[i].out ;
				}
			}

			//cout<<"out_n[0].in"<<out_n[0].in ;

			//inspire function and target ***************************
			for (i=0 ; i<out_lay_num ; i++)
			{
				out_n[i].out=sigmoid(out_n[i].in-out_n[i].bias) ;
				//if(k%100==0) 
				//cout<<" "<<out_n[i].in-out_n[i].bias ;
				//cout<<" (out_n[i].out*75+75)  "<<(out_n[i].out*75+75) ;

				out_n[i].err=out_n[i].out-target[row] ;
				sum_err+=(out_n[i].out-target[row])*(out_n[i].out-target[row]) ;
			}
			

			//compute out_lay delta *****************************************
			for (i=0 ; i<out_lay_num ; i++)
			{
				out_n[i].delta=(1.0-out_n[i].out)*out_n[i].out*out_n[i].err ;
			}

			//compute hide_lay delta ******************************************
			for (i=0 ; i<hide_lay_num ; i++)
			{
				for(j=0 ; j<out_lay_num ; j++)
				{
					hide_n[i].delta+=w_2[i][j]*out_n[j].delta ;
				}
				hide_n[i].delta*=hide_n[i].out*(1.0-hide_n[i].out) ;
			}

			//revise w_2 ******************************************************
			for (i=0 ; i<hide_lay_num ; i++)
			{
				for(j=0 ; j<out_lay_num ; j++)
				{
					w_2[i][j]-=learn_rate*out_n[j].delta*hide_n[i].out ;
				}
			}
            //revise out_lay bias
			for(i=0 ; i<out_lay_num ; i++)
			{
				out_n[i].bias-=learn_rate*out_n[i].delta ;
			}
			
			//revise w_1 *****************************************************
			for (i=0 ; i<in_lay_num ; i++)
			{
				for(j=0 ; j<hide_lay_num ; j++)
				{
					w_1[i][j]-=learn_rate*hide_n[j].delta*in_n[i].out ;
				}
			}

			//revise hide_lay bias 
			for(i=0 ; i<hide_lay_num ; i++)
			{
				hide_n[i].bias-=learn_rate*hide_n[i].delta;
			}
		
		    // clear **************************************************************
		    for (i=0 ; i<in_lay_num ; i++)
			{
		        in_n[i].setval();
			}
	        for (i=0 ; i<hide_lay_num ; i++)
			{
		        hide_n[i].setval();
			}
	        for (i=0 ; i<out_lay_num ; i++)
			{
		        out_n[i].setval();
			}
		

			//cout<<endl ;
		}
        sum_err/=2 ;
		if (k%200==0) cout<<sum_err<<endl ;

		
		
	}
	


	//simulate *******************************************************
    sum_err=0.0 ;

	for(int row=0 ; row<input_row ; row++)
		{
		
		//clear ********************************************
		for (i=0 ; i<in_lay_num ; i++)
		{
		    in_n[i].setval();
		}
	    for (i=0 ; i<hide_lay_num ; i++)
		{
		    hide_n[i].setval();
		}
	    for (i=0 ; i<out_lay_num ; i++)
		{
		    out_n[i].setval();
		}
		
		
		//initialize input to in_n *****************************
			for(i=0 ; i<in_lay_num ; i++)
			{
				in_n[i].out=input[row][i];
			}
			
			
			//layer1 to layer2 *************************************
			for( j=0 ; j<hide_lay_num ; j++)
			{
				for(i=0 ;i<in_lay_num ; i++)
				{
					hide_n[j].in+=w_1[i][j]*in_n[i].out  ;
				}
			}
			
			//cout<<"hide_n[1].in"<<hide_n[1].in ;
           
			// if (row==0) cout<<hide_n[0].in<<"aaa "<<k<<endl ;
			//inspire function *************************************
			for (i=0 ; i<hide_lay_num ;i++)
			{
				hide_n[i].out=sigmoid(hide_n[i].in-hide_n[i].bias) ;
			}
            //cout<<" "<<hide_n[1].in-hide_n[1].bias<<" "<<hide_n[1].bias ;
			//cout<<"hide_n[1].out" <<hide_n[1].out ;

			//layer2 to layer3 *************************************
			for (j=0 ; j<out_lay_num ; j++)
			{
				for(i=0 ; i<hide_lay_num ; i++)
				{
					out_n[j].in+=w_2[i][j]*hide_n[i].out ;
				}
			}
            
			//cout<<"out_n[0].in"<<out_n[0].in ;

			//inspire function and target ***************************
			for (i=0 ; i<out_lay_num ; i++)
			{
				out_n[i].out=sigmoid(out_n[i].in-out_n[i].bias) ;

				//cout<<"out_n[0].out"<<out_n[0].out ;

				out_n[i].err=out_n[i].out-target[row] ;

				//cout<<"out_n[0].err"<<out_n[0].err ;

				sum_err+=(out_n[i].out-target[row])*(out_n[i].out-target[row]) ;
				cout<<"index"<<row<<" "<<(out_n[i].out*75+75)<<endl ;
			}

	}
	cout<<sum_err/2 <<endl ;

}