24小时热门版块排行榜    

查看: 498  |  回复: 1
当前主题已经存档。

changfeng_1994

铁虫 (初入文坛)

[交流] 【转载】BP算法例子:用一个五层的神经网络去逼近函数【已搜无重复】

【转载】 +BP算法例子:用一个五层的神经网络去逼近函数 + 【已搜无重复】。

BP算法例子:用一个五层的神经网络去逼近函数

//---------------------------------------------------------------------------------------//
//           BP算法例子:用一个五层的神经网络去逼近函数            //
//           f(x1,x2)=pow(x1-1,4)+2*pow(x2,2)                                       //
//                                   2004.5.9调通 运行于VC++6.0                     //
//--------------------------------------------------------------------------------------//

#i nclude
#i nclude
#i nclude
#i nclude
#i nclude
//---------------------------------------------------------------------
#define RANDOM rand()/32767.0  //0~1随机数生成函数
  
const int Layer_Max=5;//神经网络的层数

const double PI=3.1415927;//圆周率

const int Layer_number[Layer_Max]={2,4,4,2,1};//神经网络各层的神经元个数

const int Neural_Max=4;//神经网络各层最大神经元个数

const int InMax=21;//样本输入的个数

ofstream Out_W_File("All_W.txt",ios::out) ;
ofstream Out_Error("Error.txt",ios::out) ;

//定义类 BP
class BP
{
public:
BP(); //BP类的构造函数

void BP_Print();//打印权系数

double F(double x);//神经元的激发函数

double Y(double x1,double x2);//要逼近的函数
                              //
double NetWorkOut(int x1 , int x2);//网络输出,他的输入为
                             //第input个样本
void AllLayer_D(int x1 , int x2);//求所有神经元的输出误差微分

void Change_W();   //改变权系数
   
void Train();     //训练函数

void After_Train_Out(); //经过训练后,21样本的神经网络输出

double Cost(double out,double Exp);//代价函数

private:
double W[Layer_Max][Neural_Max][Neural_Max];//保存权系数
       //规定W[j][k]表示网络第i层的第j个神经元连接到
       //第i-1层第k个神经元的权系数
double Input_Net[2][InMax];//21个样本输入,约定Input_Net[0]
                           //表示第i个样本的输入x1
                           //而 Input_Net[1]表示第i个样本的输入x2
double Out_Exp[InMax][InMax];//期望输出

double Layer_Node[Layer_Max][Neural_Max];//保存各神经元的输出
    //规定Layer_Node[j]表示第i层的第j个神经元的输出

double D[Layer_Max][Neural_Max];//保存各神经元的误差微分
    //规定D[j]表示第i层第j个神经元的误差微分

double Study_Speed;//学习速度

double e;//误差
};

//构造函数,用来初始化权系数,输入,期望输出和学习速度
BP::BP()
{
srand(time(NULL));//播种,以便产生随即数
for(int i=1 ; i {
for(int j=0 ; j ; j++)
{
     for(int k=0 ; k   {
   W[j][k] = RANDOM;//随机初始化权系数
   
  }
//     Q[j] = RANDOM ;//初始化各神经元的阀值
}
}
//输入归和输出归一化
for(int l=0 ; l {
Input_Net[0][l] = l * 0.05 ;//把0~1分成20等分,表示x1
Input_Net[1][l] = 1 - l * 0.05 ;//表示x2
}
for(i=0 ; i {
for(int j=0 ; j {
  Out_Exp[j] = Y(Input_Net[0],Input_Net[1][j]) ;//期望输出
     Out_Exp[j] = Out_Exp[j]/3.000000;//期望输出归一化
}
}

Study_Speed=0.5;//初始化学习速度

e=0.0001;//误差精度


}//end
//激发函数F()
double BP::F(double x)
{
return(1.0/(1+exp(-x)));
}//end

//要逼近的函数Y()
//输入:两个浮点数
//输出:一个浮点数
double BP::Y(double x1,double x2)
{
double temp;
temp = pow(x1-1,4) + 2 * pow(x2,2);
return temp;
}//end
//--------------------------------------------------------
//代价函数
double BP::Cost(double Out,double Exp)
{
return(pow(Out-Exp,2));
}//end

//网络输出函数
//输入为:第input个样本
double BP::NetWorkOut(int x1 , int x2)
{
int i,j,k;
double N_node[Layer_Max][Neural_Max];
   //约定N_node[j]表示网络第i层的第j个神经元的总输入
//第0层的神经元为输入,不用权系数和阀值,即输进什么即输出什么
N_node[0][0] = Input_Net[0][x1] ;
Layer_Node[0][0] = Input_Net[0][x1] ;
N_node[0][1] = Input_Net[1][x2] ;
Layer_Node[0][1] = Input_Net[1][x2] ;

for(i=1 ; i {
for(j=0 ; j ; j++)//Layer_number为第i层的
{                             //神经元个数
           N_node[j] = 0.0;
  for(k=0 ; k   {            //表示与第i层第j个神经元连接的上一层的
            //神经元个数
   
   //求上一层神经元对第i层第j个神经元的输入之和
   N_node[j]+=Layer_Node[i-1][k] * W[j][k];
   
  }
  N_node[j] = N_node[j]-W[j][k];//减去阀值

  //求Layer_Node[j],即第i层第j个神经元的输出
  Layer_Node[j] = F(N_node[j]);
}
}
return Layer_Node[Layer_Max-1][0];//最后一层的输出
}//end

//求所有神经元的输出误差微分函数
//输入为:第input个样本
//计算误差微分并保存在D[][]数组中
void BP::AllLayer_D(int x1 , int x2)
{
int i,j,k;
double temp;
D[Layer_Max-1][0] = Layer_Node[Layer_Max-1][0] *
                 (1-Layer_Node[Layer_Max-1][0])*
                 (Layer_Node[Layer_Max-1][0]-Out_Exp[x1][x2]);
for(i=Layer_Max-1 ; i>0 ; i--)
{
for(j=0 ; j {
  temp = 0 ;
  for(k=0 ; k ; k++)
  {
   temp = temp+W[k][j]*D[k] ;
  }
  D[i-1][j] = Layer_Node[i-1][j] * (1-Layer_Node[i-1][j])
           *temp ;
}
}
}//end
//修改权系数和阀值
void BP::Change_W()
{
int i,j,k;
for(i=1 ; i {
for(j=0;j;j++)
{
  for(k=0;k   {
   //修改权系数
   W[j][k]=W[j][k]-Study_Speed*
           D[j]*Layer_Node[i-1][k];
               
  }
  W[j][k]=W[j][k]+Study_Speed*D[j];//修改阀值
}
}
}//end
//训练函数
void BP::Train()
{
int i,j;
int ok=0;
double Out;
long int count=0;
double err;
   ofstream Out_count("Out_count.txt",ios::out) ;
//把其中的5个权系数的变化保存到文件里
ofstream outWFile1("W[2][0][0].txt",ios::out) ;
ofstream outWFile2("W[2][1][1].txt",ios::out) ;
ofstream outWFile3("W[1][0][0].txt",ios::out) ;
ofstream outWFile4("W[1][1][0].txt",ios::out) ;
ofstream outWFile5("W[3][0][1].txt",ios::out) ;

while(ok<441)
{
count++;
//20个样本输入
for(i=0,ok=0 ; i {
  for(j=0 ; j   {
     Out = NetWorkOut(i,j);

     AllLayer_D(i,j);
  
     err = Cost(Out,Out_Exp[j]);//计算误差
           
     if(err
     else Change_W();//否修改权系数和阀值
  }
      
}
if((count%1000)==0)//每1000次,保存权系数
{
  cout<   Out_count<   Out_Error<   outWFile1<   outWFile2<   outWFile3<   outWFile4<   outWFile5<   for(int p=1 ; p   {
   for(int j=0 ; j    {
    for(int k=0 ; k     {
     Out_W_File<<'W'<<'['<                  <<'['<            <<'['<            <<'='<     }
   }
  }
  Out_W_File<<'\n'<<'\n' ;
}

}
cout< }//end

//打印权系数
void BP::BP_Print()
{
//打印权系数
cout<<"训练后的权系数"< for(int i=1 ; i {
for(int j=0 ; j ; j++)
{
     for(int k=0 ; k   {
   cout<[j][k]<<"         ";
  }
  cout< }
}
cout< }//end

//把结果保存到文件
void BP::After_Train_Out()
{
int i,j ;
ofstream Out_x1("Out_x1.txt",ios::out) ;

ofstream Out_x2("Out_x2.txt",ios::out) ;

ofstream Out_Net("Out_Net.txt",ios::out) ;

ofstream Out_Exp("Out_Exp.txt",ios::out) ;

ofstream W_End("W_End.txt",ios::out) ;

ofstream Q_End("Q_End.txt",ios::out) ;

ofstream Array("Array.txt",ios::out) ;

ofstream Out_x11("x1.txt",ios::out) ;

ofstream Out_x22("x2.txt",ios::out) ;

ofstream Result1("result1.txt",ios::out) ;

ofstream Out_x111("x11.txt",ios::out) ;

ofstream Out_x222("x22.txt",ios::out) ;

ofstream Result2("result2.txt",ios::out) ;


for( i=0 ; i {
for(j=0 ; j {
  Out_x11<<<',';
  Out_x22<   Result1<<3*NetWorkOut(i,j)<<"," ;
  Out_x1<<<"," ;

  Array<<<"        " ;

     Out_x2<
  Array<
     Out_Net<<3*NetWorkOut(i,j)<<"," ;

  Array<,Input_Net[1][j])<<"        " ;

     Out_Exp<,Input_Net[1][j])<<"," ;

  Array<<3*NetWorkOut(i,j)<<"        " ;

  Array<<'\n' ;
}
Out_x1<<'\n' ;
Out_x2<<'\n' ;
Out_x11<<'\n';
Out_x22<<'\n';
Result1<<'\n' ;

}
for(j=0 ; j {
for(i=0 ; i {
  Out_x111<<<',';
  Out_x222<   Result2<<3*NetWorkOut(i,j)<<"," ;
}
Out_x111<<'\n';
Out_x222<<'\n' ;
Result2<<'\n' ;
}


   //把经过训练后的权系数和阀值保存到文件里
   for(i=1 ; i {
for(int j=0 ; j ; j++)
{
     for(int k=0 ; k   {
  
   W_End<[j][k]<<"," ;//保存权系数
  }
}
}//end for
   
}//end

void main(void)
{   
BP B;//生成一个BP类对象B
B.Train();//开始训练
B.BP_Print();//把结果打印出来
B.After_Train_Out();//把结果保存到文件

}//end

[ Last edited by signal023 on 2008-4-14 at 10:32 ]
回复此楼

» 收录本帖的淘帖专辑推荐

source

» 猜你喜欢

已阅   回复此楼   关注TA 给TA发消息 送TA红花 TA的回帖

zqbxfev

金虫 (正式写手)

谢谢了,前一段时间学了一点神经算法!
欢迎访问我的博客! http://www.blog.163.com/zqbxfev/
2楼2008-04-13 23:24:08
已阅   回复此楼   关注TA 给TA发消息 送TA红花 TA的回帖
相关版块跳转 我要订阅楼主 changfeng_1994 的主题更新
普通表情 高级回复(可上传附件)
信息提示
请填处理意见