bp.cpp

该程序是用C语言写的采用了动量方法的BP神经网络

#include <math.h>
#include <iostream.h>
#include "fstream.h"

#include <time.h>
#include <stdlib.h>

void main()
{
	int I,J,K;
	cout<<"输入层数目I，请输入并按enter,本实例设定为2，I＝";
	cin>>I;	cout<<endl;
	cout<<"中间层数目J，请输入并按enter,可自己设定，J＝";
	cin>>J;	cout<<endl;
	cout<<"输出层数目K，请输入并按enter,本实例设定为1，K＝";
	cin>>K;cout<<endl;
	int i,j,k;
	int n=0,N=10000;			//N为最大学习次数
	int M=21;					//M为输入样本的组数
	double e1=1.0;				//e1为均方误差

	//动态分配二维数组
	double **a0;				//a0[M][I]为初始输入
	a0=new double *[M];			//设置行
	for(i=0;i<M;i++)
		a0[i]=new double [I];	//设置列

	double **w1;				//w1[I][J]为第一层输入权值
	w1=new double *[I];			//设置行
	for(j=0;j<I;j++)
		w1[j]=new double [J];	//设置列

	double *add1=new double [J];
	double *b1=new double [J];	//b1[J]为第一层的输入阈值
	double *a1=new double [J];	//a1[J]第一层的输出

	double **w2;				//w2[J][K]为第二层输入权值
	w2=new double *[J];			//设置行
	for(k=0;k<J;k++)
		w2[k]=new double [K];	//设置列

	//动态分配一维数组
	double *add2=new double [K];
	double *b2=new double [K];	//b2[K]为第二层的输入阈值
	double *a2=new double [K];	//a2[K]第二层的输出
	double *e=new double [K];	//误差

	double **t;					//目标值t[M][K]
	t=new double *[M];			//设置行
	for(k=0;k<M;k++)
		t[k]=new double [K];	//设置列

	double *s2=new double [K];	//第二层反向传播
	double *s1=new double [J];	//第一层反向传播

	double **temp;
	temp=new double *[J];		//设置行
	for(k=0;k<J;k++)
		temp[k]=new double [K];	//设置列

	double arph=0.001;			//学习速度

/////////////////////////////////////////////////////////////////////////////
	double r=0.1;				//r为动量系数
	double **dw1;
	dw1=new double *[I];		//设置行
	for(j=0;j<I;j++)
		dw1[j]=new double [J];	//设置列

	double *db1=new double [J];

	double **dw2;
	dw2=new double *[J];		//设置行
	for(k=0;k<J;k++)
		dw2[k]=new double [K];	//设置列
	double *db2=new double [K];
/////////////////////////////////////////////////////////////////////////////

	//产生0-1均匀分布的随机数
	srand( (unsigned)time( NULL ) );

	for(j=0;j<J;j++) 
	{
		for(i=0;i<I;i++)
			w1[i][j]=(double)((rand()/32767.0)*2-1);
	}
	for(j=0;j<J;j++)
		b1[j]=(double)((rand()/32767.0)*2-1);

	for(j=0;j<J;j++)
	{
		for(k=0;k<K;k++)
			w2[j][k]=(double)((rand()/32767.0)*2-1);
	}
	for(k=0;k<K;k++)
		b2[k]=(double)((rand()/32767.0)*2-1);

	ifstream fin("data.dat");
	for(j=0;j<M;j++){
	for(i=0;i<I;i++)
		fin>>a0[j][i];
	for(k=0;k<K;k++)
		fin>>t[j][k];
	}
	fin.close();

	ofstream out1("error.txt",ios::out);

	while(e1>0.01){///////////////////训练循环//////////////////////////////////

	if(n>=N)
		goto label;

	int m=0;
	e1=0;				//e1清零

	for(m=0;m<M;m++){//////////////////////////样本组循环////////////////////////////////

	for(j=0;j<J;j++)	//add1清零
		add1[j]=0;
	for(k=0;k<K;k++)	//add2清零
		add2[k]=0;

	for(j=0;j<J;j++)	//s1清零
		s1[j]=0;

	for(j=0;j<J;j++)
	{
		for(i=0;i<I;i++)
			add1[j]+=w1[i][j]*a0[m][i];
	}

	for(j=0;j<J;j++)
	{
		a1[j]=1.0/(1.0+exp(-add1[j]-b1[j]));//1:logsig计算隐层输出结果
	}
	
	for(k=0;k<K;k++)
	{
		for(j=0;j<J;j++)
			add2[k]+=w2[j][k]*a1[j];
	}

	for(k=0;k<K;k++)
		a2[k]=add2[k]+b2[k];//2:purelin计算输出层输出结果

	for(k=0;k<K;k++)
	{
		e[k]=t[m][k]-a2[k];//3
		e1+=e[k]*e[k];//求输出层的平方误差
	}

	for(k=0;k<K;k++)
		s2[k]=-2*e[k];//4

	for(j=0;j<J;j++)
	{
		for(k=0;k<K;k++)
			temp[j][k]=(1-a1[j])*a1[j]*w2[j][k];
	}

	for(j=0;j<J;j++)
	{	
		for(k=0;k<K;k++)
			s1[j]+=temp[j][k]*s2[k];//5
	}
/////////////////////////////////////////////////////未采用动量方法ddd
/*	for(k=0;k<K;k++)//
	{
		for(j=0;j<J;j++)
			w2[j][k]+=-arph*s2[k]*a1[j];//6
	}

	for(k=0;k<K;k++)
		b2[k]+=-arph*s2[k];//7

	for(j=0;j<J;j++)
	{
		for(i=0;i<I;i++)
			w1[i][j]+=-arph*s1[j]*a0[m][i];//8
	}
	
	for(j=0;j<J;j++)
		b1[j]+=-arph*s1[j];//9  ddd//*/

/////////////////////////////////////////////////////动量方法,把上段用如下的程序代替
	if(0==n)///*
	{
		for(k=0;k<K;k++)
		{
			for(j=0;j<J;j++)
			{
				dw2[j][k]=-arph*s2[k]*a1[j];
				w2[j][k]+=dw2[j][k];//(初始训练调整)输出层至隐层的权值调整
			}
		}

		for(k=0;k<K;k++)
		{
			db2[k]=-arph*s2[k];
			b2[k]+=db2[k];//(初始训练调整)输出层至隐层的阈值调整
		}

		for(j=0;j<J;j++)
		{
			for(i=0;i<I;i++)
			{	
				dw1[i][j]=-arph*s1[j]*a0[m][i];//8
				w1[i][j]+=dw1[i][j];//(初始训练调整)隐层至输入层的权值调整
			}
		}
	
		for(j=0;j<J;j++)
		{
			db1[j]=-arph*s1[j];
			b1[j]+=db1[j];//(初始训练调整)隐层至输入层的阈值调整
		}
	}
	else
	{
		for(k=0;k<K;k++)
		{
			for(j=0;j<J;j++)
			{
				dw2[j][k]=r*dw2[j][k]-(1-r)*arph*s2[k]*a1[j];
				w2[j][k]+=dw2[j][k];//输出层至隐层的权值调整
			}
		}

		for(k=0;k<K;k++)
		{	
			db2[k]=r*db2[k]-(1-r)*arph*s2[k];
			b2[k]+=db2[k];//输出层至隐层的阈值调整
		}

		for(j=0;j<J;j++)
		{
			for(i=0;i<I;i++)
			{	
				dw1[i][j]=r*dw1[i][j]-(1-r)*arph*s1[j]*a0[m][i];
				w1[i][j]+=dw1[i][j];//隐层至输入层的权值调整
			}
		}
	
		for(j=0;j<J;j++)
		{	
			db1[j]=r*db1[j]-(1-r)*arph*s1[j];
			b1[j]+=db1[j];//隐层至输入层的阈值调整
		}
	}
	
	}///////////////////////////***样本组循环结束***/////////////////////////

	out1<<e1<<" ";//保存误差值
	e1=e1/2.0;//输出层的平方误差/2=均方误差
	cout<<"e1="<<e1<<endl;
	n++;//一组样本训练结束学习次数加1

	}////////////////////////////***样本训练结束***//////////////////////////

label:
	cout<<"n="<<n<<endl;

	for(j=0;j<J;j++)
	{
		for(i=0;i<I;i++)
			cout<<"w1["<<i<<"]["<<j<<"]="<<w1[i][j]<<endl;
	}

	for(j=0;j<J;j++)
		cout<<"b1["<<j<<"]="<<b1[j]<<endl;

	for(k=0;k<K;k++)
	{
		for(j=0;j<J;j++)
			cout<<"w2["<<j<<"]["<<k<<"]="<<w2[j][k]<<endl;
	}

	for(k=0;k<K;k++)
		cout<<"b2["<<k<<"]="<<b2[k]<<endl;

	out1.close();
/////////////////////////////////////////////////////////////////////////////
/*/测试结果
	double *a=new double [I];
	/*a[0]=8.14545;a[1]=16.2127;
	a[2]=21.8783;a[3]=21.8579;
	a[4]=43.0344;a[5]=29.9642;
	a[6]=31.4639;*///1-0
 /*	a[0]=8.06259;a[1]=13.2972;
	a[2]=18.4765;a[3]=17.8098;
	a[4]=35.6393;a[5]=24.3921;
	a[6]=33.6257;*///0-1

/*	for(j=0;j<J;j++)
		add1[j]=0;
	for(k=0;k<K;k++)
		add2[k]=0;

	for(j=0;j<J;j++)
	{
		for(i=0;i<I;i++)
			add1[j]+=w1[i][j]*a[i];
	}

	for(j=0;j<J;j++)
	{
		a1[j]=1.0/(1.0+exp(-add1[j]-b1[j]));//1:logsig
	}
	
	for(k=0;k<K;k++)
	{
		for(j=0;j<J;j++)
			add2[k]+=w2[j][k]*a1[j];
	}

	for(k=0;k<K;k++)
		a2[k]=add2[k]+b2[k];//2:purelin

	for(k=0;k<K;k++)
		cout<<"t="<<a2[k]<<endl;

	delete [] a;*/

	delete [] db2;

	for(j=0;j<J;j++)
		delete [] dw2[j];
	delete [] dw2;

	delete [] db1;

	for(i=0;i<I;i++)
		delete [] dw1[i];
	delete [] dw1;
/////////////////////////////////////////////////////////////////////////////

	//堆内存的释放(二维)(后创建的先释放)(先释放列后释放行)
	for(j=0;j<J;j++)
		delete [] temp[j];
	delete [] temp;

	//堆内存的释放(一维)(后创建的先释放)
	delete [] s1;
	delete [] s2;

	for(j=0;j<M;j++)
		delete [] t[j];
	delete [] t;

	delete [] e;
	delete [] a2;
	delete [] b2;
	delete [] add2;

	//堆内存的释放(二维)(后创建的先释放)(先释放列后释放行)
	for(j=0;j<J;j++)
		delete [] w2[j];
	delete [] w2;

	delete [] a1;
	delete [] b1;
	delete [] add1;
	
	for(i=0;i<I;i++)
		delete [] w1[i];
	delete [] w1;

	for(j=0;j<M;j++)
		delete [] a0[j];
	delete [] a0;
}