关于C++实现的BP神经网络（代码）

关于C++实现的BP神经网络（代码）

　　#pragma   hdrstop

　　#include   <stdio.h>

　　#include   <iostream.h>

　　const   A=30.0;

　　const   B=10.0;

　　const   MAX=500;               //最大训练次数

　　const   COEF=0.0035;   //网络的学习效率

　　const   BCOEF=0.001;//网络的阀值调整效率

　　const   ERROR=0.002     ;   //   网络训练中的允许误差

　　const   ACCURACY=0.0005;//网络要求精度

　　double   sample[41][4]={{0,0,0,0},{5,1,4,19.020},{5,3,3,14.150},

　　{5,5,2,14.360},{5,3,3,14.150},{5,3,2,15.390},

　　{5,3,2,15.390},{5,5,1,19.680},{5,1,2,21.060},

　　{5,3,3,14.150},{5,5,4,12.680},{5,5,2,14.360},

　　{5,1,3,19.610},{5,3,4,13.650},{5,5,5,12.430},

　　{5,1,4,19.020},{5,1,4,19.020},{5,3,5,13.390},

　　{5,5,4,12.680},{5,1,3,19.610},{5,3,2,15.390},

　　{1,3,1,11.110},{1,5,2,6.521},{1,1,3,10.190},

　　{1,3,4,6.043},{1,5,5,5.242},{1,5,3,5.724},

　　{1,1,4,9.766},{1,3,5,5.870},{1,5,4,5.406},

　　{1,1,3,10.190},{1,1,5,9.545},{1,3,4,6.043},

　　{1,5,3,5.724},{1,1,2,11.250},{1,3,1,11.110},

　　{1,3,3,6.380},{1,5,2,6.521},{1,1,1,16.000},

　　{1,3,2,7.219},{1,5,3,5.724}};

　　double   w[4][10][10],wc[4][10][10],b[4][10],bc[4][10];

　　double   o[4][10],netin[4][10],d[4][10],differ;//单个样本的误差

　　double   is;   //全体样本均方差

　　int   count,a;

　　void   netout(int   m,   int   n);//计算网络隐含层和输出层的输出

　　void   calculd(int   m,int   n);   //计算网络的反向传播误差

　　void   calcalwc(int   m,int   n);//计算网络权值的调整量

　　void   calcaulbc(int   m,int   n);   //计算网络阀值的调整量

　　void   changew(int   m,int   n);   //调整网络权值

　　void   changeb(int   m,int   n);//调整网络阀值

　　void   clearwc(int   m,int   n);//清除网络权值变化量wc

　　void   clearbc(int   m,int   n);//清除网络阀值变化量bc

　　void   initialw(void);//初始化NN网络权值W

　　void   initialb(void);   //初始化NN网络阀值

　　void   calculdiffer(void);//计算NN网络单个样本误差

　　void   calculis(void);//计算NN网络全体样本误差

　　void   trainNN(void);//训练NN网络

　　/*计算NN网络隐含层和输出层的输出   */

　　void   netout(int   m,int   n)

　　{

　　int   i,j,k;

　　//隐含层各节点的的输出

　　for   (j=1,i=2;j<=m;j++)   //m为隐含层节点个数

　　{

　　netin[i][j]=0.0;

　　for(k=1;k<=3;k++)//隐含层的每个节点均有三个输入变量

　　netin[i][j]=netin[i][j]+o[i-1][k]*w[i][k][j];

　　netin[i][j]=netin[i][j]-b[i][j];

　　o[i][j]=A/(1+exp(-netin[i][j]/B));

　　}

　　//输出层各节点的输出

　　for   (j=1,i=3;j<=n;j++)

　　{

　　netin[i][j]=0.0;

　　for   (k=1;k<=m;k++)

　　netin[i][j]=netin[i][j]+o[i-1][k]*w[i][k][j];

　　netin[i][j]=netin[i][j]-b[i][j];

　　o[i][j]=A/(1+exp(-netin[i][j]/B))   ;

　　}

　　}

　　/*计算NN网络的反向传播误差*/

　　void   calculd(int   m,int   n)

　　{

　　int   i,j,k;

　　double   t;

　　a=count-1;

　　d[3][1]=(o[3][1]-sample[a][3])*(A/B)*exp(-netin[3][1]/B)/pow(1+exp(-netin[3][1]/B),2);

　　//隐含层的误差

　　for   (j=1,i=2;j<=m;j++)

　　{

　　t=0.00;

　　for   (k=1;k<=n;k++)

　　t=t+w[i+1][j][k]*d[i+1][k];

　　d[i][j]=t*(A/B)*exp(-netin[i][j]/B)/pow(1+exp(-netin[i][j]/B),2);

　　}

　　}

　　/*计算网络权值W的调整量*/

　　void   calculwc(int   m,int   n)

　　{

　　int   i,j,k;

　　//   输出层（第三层）与隐含层（第二层）之间的连接权值的调整

　　for   (i=1,k=3;i<=m;i++)

　　{

　　for   (j=1;j<=n;j++)

　　{

　　wc[k][i][j]=-COEF*d[k][j]*o[k-1][i]+0.5*wc[k][i][j];

　　}

　　//   printf("\n");

　　}

　　//隐含层与输入层之间的连接权值的调整

　　for   (i=1,k=2;i<=m;i++)

　　{

　　for   (j=1;j<=m;j++)

　　{

　　wc[k][i][j]=-COEF*d[k][j]*o[k-1][i]+0.5*wc[k][i][j];

　　}

　　//     printf("\n");

　　}

　　}

　　/*计算网络阀值的调整量*/

　　void   calculbc(int   m,int   n)

　　{

　　int   j;

　　for   (j=1;j<=m;j++)

　　{

　　bc[2][j]=BCOEF*d[2][j];

　　}

　　for   (j=1;j<=n;j++)

　　{

　　bc[3][j]=BCOEF*d[3][j];

　　}

　　}

　　/*调整网络权值*/

　　void   changw(int   m,int   n)

　　{

　　int   i,j;

　　for   (i=1;i<=3;i++)

　　for   (j=1;j<=m;j++)

　　{

　　w[2][i][j]=0.9*w[2][i][j]+wc[2][i][j];

　　//为了保证系统有较好的鲁棒性，计算权值时乘惯性系数0.9

　　printf("w[2][%d][%d]=%f\n",i,j,w[2][i][j]);

　　}

　　for   (i=1;i<=m;i++)

　　for   (j=1;j<=n;j++)

　　{

　　w[3][i][j]=0.9*w[3][i][j]+wc[3][i][j];

　　printf("w[3][%d][%d]=%f\n",i,j,w[3][i][j]);

　　}

　　}

　　/*调整网络阀值*/

　　void   changb(int   m,int   n)

　　{

　　int   j;

　　for   (j=1;j<=m;j++)

　　b[2][j]=b[2][j]+bc[2][j];

　　for   (j=1;j<=n;j++)

　　b[3][j]=b[3][j]+bc[3][j];

　　}

　　/*清除网络权值变化量wc*/

　　void   clearwc(void)

　　{

　　for   (int   i=0;i<4;i++)

　　for   (int   j=0;j<10;j++)

　　for   (int   k=0;k<10;k++)

　　wc[i][j][k]=0.00;

　　}

　　/*清除网络阀值变化量*/

　　void   clearbc(void)

　　{

　　for   (int   i=0;i<4;i++)

　　for   (int   j=0;j<10;j++)

　　bc[i][j]=0.00;

　　}

　　/*初始化网络权值W*/

　　void   initialw(void)

　　{

　　int   i,j,k,x;

　　double   weight;

　　for   (i=0;i<4;i++)

　　for   (j=0;j<10;j++)

　　for   (k=0;k<10;k++)

　　{

　　randomize();

　　x=100+random(400);

　　weight=(double)x/5000.00;

　　w[i][j][k]=weight;

　　}

　　}

　　/*初始化网络阀值*/

　　void   initialb(void)

　　{

　　int   i,j,x;

　　double   fazhi;

　　for   (i=0;i<4;i++)

　　for   (j=0;j<10;j++)

　　{

　　randomize();

　　for   (int   k=0;k<12;k++)

　　{

　　x=100+random(400);

　　}

　　fazhi=(double)x/50000.00;

　　b[i][j]=fazhi;

　　}

　　}

　　/*计算网络单个样本误差*/

　　void   calculdiffer(void)

　　{

　　a=count-1;

　　differ=0.5*(o[3][1]-sample[a][3])*(o[3][1]-sample[a][3]);

　　}

　　void   calculis(void)

　　{

　　int   i;

　　is=0.0;

　　for   (i=0;i<=19;i++)

　　{

　　o[1][1]=sample[i][0];

　　o[1][2]=sample[i][1];

　　o[1][3]=sample[i][2];

　　netout(8,1);

　　is=is+(o[3][1]-sample[i][3])*(o[3][1]-sample[i][3]);

　　}

　　is=is/20;

　　}

　　/*训练网络*/

　　void   trainNN(void)

　　{

　　long   int   time;

　　int   i,x[4];

　　initialw();

　　initialb();

　　for   (time=1;time<=MAX;time++)

　　{

　　count=0;

　　while(count<=40)

　　{

　　o[1][1]=sample[count][0];

　　o[1][2]=sample[count][1];

　　o[1][3]=sample[count][2];

　　count=count+1;

　　clearwc();

　　clearbc();

　　netout(8,1);

　　calculdiffer();

　　while(differ>ERROR)

　　{

　　calculd(8,1);

　　calculwc(8,1);

　　calculbc(8,1);

　　changw(8,1);

　　changb(8,1);

　　netout(8,1);

　　calculdiffer();

　　}

　　}

　　printf("This   is   %d   times   training   NN...\n",time);

　　calculis();

　　printf("is==%f\n",is);

　　if   (is<ACCURACY)   break;

　　}

　　}

　　//---------------------------------------------------------------------------

　　#pragma   argsused

　　int   main(int   argc,   char*   argv[])

　　{

　　double   result;

　　int   m,test[4];

　　char   ch='y';

　　cout<<"Please   wait   for   the   train   of   NN:"<<endl;

　　trainNN();

　　cout<<"Now,this   modular   network   can   work   for   you."<<endl;

　　while(ch=='y'   ||   ch=='Y')

　　{

　　cout<<"Please   input   data   to   be   tested."<<endl;

　　for   (m=1;m<=3;m++)

　　cin>>test[m];

　　ch=getchar();

　　o[1][1]=test[1];

　　o[1][2]=test[2];

　　o[1][3]=test[3];

　　netout(8,1);

　　result=o[3][1];

　　printf("Final   result   is   %f.\n",result);

　　printf("Still   test?[Yes]   or   [No]\n");

　　ch=getchar();

　　}

　　return   0;

　　}

如果觉得 关于C++实现的BP神经网络（代码）这篇文章不错，可以推荐给朋友分享哦。