新建 文本文档.txt

EBP反向传播算法对应的源程序

#include<iostream>       //三层网络
#include<iomanip>
#include<cmath>
using namespace std;

#define  N 20		//学习样本个数
#define  IN 1		//输入层神经元数目
#define  HN 8		//隐层神经元数目
#define  ON 1		//输出层神经元数目

double  P[IN];		//单个样本输入数据
double  T[ON];		//单个样本教师数据

double  W[HN][IN];	//输入层至隐层权值
double	V[ON][HN];	//隐层至输出层权值
double	X[HN];		//隐层的输入
double	Y[ON];		//输出层的输入
double	H[HN];		//隐层的输出
double	O[ON];		//输出层的输出
double	sita[HN];	//隐层的阈值
double	gama[ON];	//输出层的阈值

double	err_m[N];	//第m个样本的总误差
double	alpha,beta;		

struct {double input[IN],teach[ON];}Study_Data[N];//定义一个放学习样本的结构
 
void initial()			//初始化权、阈值子程序
{
	float sgn,rnd;int i,j;
	
	sgn=rand();				//隐层权、阈值初始化//sgn=pow((-1),random(100));
	rnd=sgn*(rand()%100);
	W[j][i]=rnd/100;		//隐层权值初始化。
  
	sgn=rand();				//randomize()//sgn=pow((-1),random(1000))
	rnd=sgn*(rand()%1000);
	sita[j]= rnd/1000;		//中间层阈值初始化
	cout<<"sita"<<sita[j]<<endl;
  
	for(int k=0;k<ON;k++)	//输出层权、阈值初始化//randomize();
		for(int j=0;j<HN;j++) 
		{
			sgn=rand();				//sgn=pow((-1),random(1000));
			rnd=sgn*(rand()%1000);
			V[k][j]=rnd/1000;		//第m个样本输出层权值初始化
		}
			
	sgn=rand();					//randomize();//sgn=pow((-1),random(10));
	rnd=sgn*(rand()%10);
	gama[k]=rnd/10;				//输出层阈值初始化
	cout<<"gama[k]"<<endl;
}
								
void input_P(int m){for(int i=0;i<IN;i++)P[i]=Study_Data[m].input[i];}//第m个学习样本输入子程序
void input_T(int m){for(int i=0;i<ON;i++)T[i]=Study_Data[m].teach[i];}//第m个样本教师信号子程序								

void H_I_O()							//隐层各单元输入、输出值子程序
{
	double sigma;int i,j;
	for(j=0;j<HN;j++)
	{
		sigma=0.0;for(i=0;i<IN;i++)sigma+=W[j][i]*P[i];			//求隐层内积
		X[j]=sigma-sita[i];									//求隐层净输入
		H[j]=1.0/(1.0+exp(-X[j]));								//求隐层输出
	}
}																

void O_I_O()//输出层各单元输入、输出值子程序
{
	double sigma;
	for(int k=0;k<ON;k++)
	{
		sigma=0.0;for(int j=0;j<HN;j++)sigma+=V[k][j]*H[k];		//求输出层内积
		Y[k]=sigma-gama[k];										//求输出层净输入
		O[k]=1.0/(1.0+exp(-Y[k]));								//求输出层输出
	}
}															

double d_err[ON];
void Err_O_H(int m)						//输出层至隐层的一般化误差子程序,第m个样本
{
	double abs_err[ON];					//每个样本的绝对误差都是从0开始的
	double sqr_err=0;					//每个样本的平方误差计算都是从0开始的//for (int output=0;output<ON;output++)  //output???
									
	for(int k=0;k<ON;k++)abs_err[k]=T[k]-O[k];		//求第m个样本下的第k个神经元的绝对误差
	sqr_err+=(abs_err[k])*(abs_err[k]);				//求第m个样本下输出层的平方误差

	d_err[k]=abs_err[k]*O[k]*(1.0-O[k]);			//d_err[k]输出层各神经元的一般化误差
	
	err_m[m]=sqr_err/2;								//第m个样本下输出层的平方误差/2=第m个样本的均方误差
}													//子程序Err_O_H(m)结束

double e_err[HN];
void Err_H_I()					//隐层至输入层的一般化误差子程序
{
	double sigma;
	for(int j=0;j<HN;j++) //for (int hidden=0;hidden
	{
		sigma=0.0;for(int k=0;k<ON;k++)sigma=d_err[k]*V[k][j];
		e_err[j]=sigma*H[j]*(1-H[j]);//隐层各神经元的一般化误差
	}
}

void Delta_O_H(int m)//输出层至隐层的权值调整、输出层阈值调整计算子程序
{
	for(int k=0;k<ON;k++)
	{
		for(int j=0;j<HN;j++)
			V[k][j]+=alpha*d_err[k]*H[j];	//输出层至隐层的权值调整//cout<<"第"< fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,W[k][j]);
		gama[k]+=beta*d_err[k];					//输出层至隐层的阈值调整
	}
}

void Delta_H_I(int m)//隐层至输入层的权值调整、隐层阈值调整计算子程序
{
	for (int j=0;j<HN;j++)
	{
		for(int i=0;i<IN;i++)//cout<<"第"< fprintf(fp,"第%d个样本时的输出层至隐层的权值为：%f\n",m,V[j][i]);
			W[j][i]+=beta*e_err[j]*P[i];   //隐层至输入层的权值调整
		sita[j]+=beta*e_err[j];
	}
}

double Err_Sum()						//N个样本的全局误差计算子程序
{
	double total_err=0;for(int m=0;m<N;m++)total_err+=err_m[m];//每个样本的均方误差加起来就成了全局误差
	return total_err;
}

int main()
{
	double sum_err;int study=0;					//训练次数
	cin>>alpha;cin>>beta;

	double Pre_error; cout<<"请输入预定误差: Pre_error= \n";        cin>>Pre_error;            
	int Pre_times;    cout<<"请输入预定最大学习次数:Pre_times=\n";  cin>>Pre_times;

	int m,i;cout<<"请输入学习样本数据\n";			//有N组
	for(m=0;m<N;m++)for(i=0;i<IN;i++)cin>>Study_Data[m]->input[i];
	for(m=0;m<N;m++)for(i=0;i<ON;i++)cin>>Study_Data[m]->teach[i];

	initial(); //隐层、输出层权、阈值初始化 (1) 

	while(sum_err>Pre_error)//N个样本全局误差小于预定误差否
	{
		++study; 
		for(int m=0;m<N;m++) 
		{
			input_P(m);			//输入第m个学习样本 (2)
			input_T(m);			//输入第m个样本的教师信号 (3)
			H_I_O();			//第m个学习样本隐层各单元输入、输出值 (4)
			O_I_O();			//第m个学习样本输出层各单元输入、输出值 (5)
			Err_O_H(m);			//第m个学习样本输出层至隐层一般化误差 (6) 
			Err_H_I();			//第m个学习样本隐层至输入层一般化误差 (7)
			Delta_O_H(m);		//第m个学习样本输出层至隐层权阈值调整、修改 (8)
			Delta_H_I(m);		//第m个学习样本隐层至输入层权阈值调整、修改 (9)
		}						//全部样本训练完毕

		sum_err=Err_Sum(); //全部样本全局误差计算 (10)
		cout<<"第"<<study<<"次学习的均方误差为"<<sum_err<<endl;
	}

	return 0;
}