神经网络BP网络的c++实现

神经网络算法BP网络的C++实现

头文件CBp.h

#ifndef BP_H
#define BP_H
//初始化相关变量
#define N 4    //学习样本个数
#define IN 2  //输入层神经元数目
#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 YU_HN[HN]; //隐层的阈值
double YU_ON[ON]; //输出层的阈值

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

double a; //输出层至隐层的学习效率
double b; //隐层至输入层学习效率
double alpha;//动量系数

//定义一个放学习样本的结构
struct {
	double input[IN]; //一个学习样本	
	double teach[ON]; //一个期望信号
}Study_Data[N];//学习样本的个数


#endif

实现文件CBp.cpp

#include <iostream>
#include <iomanip>
#include <cstdlib>
#include <cmath>
#include <cstdio>
#include <ctime>
#include <fstream>
#include "bp.h"
using namespace std;

//初始化-阈值
void initial();
//从文件中获取训练样本
void GetTrainingData();
//输入学习样本
void input_P(int);
//输入期望样本
void input_T(int);
//隐层的输出
void H_I_O();
//输出层的输出
void O_I_O();

//误差子程序
void Err_O_H(int);
//误差子程序

void Err_H_I();
//N个样本的全局误差计算子程序Batch Learning 批量学习法
double Err_Sum();
//输出层至隐层的权值调整程序
void Delta_O_H(int);
//隐层至输入层的权值调整、隐层阈值调整计算子程序
void Delta_H_I(int);

//最后的调整结果保存到文件中
void save();

int main()
{
	char c;
	double sum_err;//批量学习后的总误差
	int study=0; //学习训练的次数

	a = 0.7;//定义输出层至隐层的学习率
	b = 0.7;//定义隐层至输入层的学习率
	alpha=0.1;
	
	double 	Pre_error = 0.001; //预定误差 停止条件

	GetTrainingData();//从文件中获取输入的数据及期望的信号
	initial(); //隐层、输出层权、阈值初始化 (1) 
	do
	{
		++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;
		
	}while (sum_err > Pre_error); 

	cout<<"网络已经学习了"<<study<<"次,学习的均方误差为"<<sum_err<<endl;
	save();

	/* 以下为学习后的测试过程 */

    do{	   
	    cout<<"请输入想测试的样本: "<<endl;
	   for(int i=0;i<IN;i++)
	   { 
		  
		   cin>>P[i];
	   }

	   for(int j=0;j<IN;j++)
	   { 
		   
		   cout<<P[j]<<" ";
	   }
    	H_I_O();
    	O_I_O();

		for (int k=0;k<ON;k++)
		{
			cout<<O[k];
		//	if(key == 1)
		//	{
		//		cout<<"我猜你是女生..."<<"退出请输q"<<endl;
		//	}
		//	else
		//	{
		//	cout<<"我猜你是男生...."<<"退出请输q"<<endl;
		//	}
		}
}while( (c=getchar())!='q') ;

	return 0;
}

//初始化权、阈值函数/////
///////////////////////////
void initial()
{
//隐层权、阈值初始化//
	srand( (unsigned)time( NULL ) );//给随机函数一个随机种子

	for(int i=0;i<HN;i++)
	{
		for(int j=0;j<IN;j++)
			W[i][j]= (double)((rand()/32767.0)*2-1); //初始化输入层到隐层的权值，随机模拟-1到1之间的值	
	}

	for(int ii=0;ii<ON;ii++)
	{
		for(int jj=0;jj<HN;jj++)
			V[ii][jj]= (double)((rand()/32767.0)*2-1); //初始化隐层到输出层的权值，随机模拟-1到1之间的值
	}

	for(int k=0;k<HN;k++)
	{
		YU_HN[k] = (double)((rand()/32767.0)*2-1);  //隐层阈值初始化 
	}

	for(int kk=0;kk<ON;kk++)
	{
		YU_ON[kk] = (double)((rand()/32767.0)*2-1); //输出层阈值初始化 
	}
  
}

//从文件中读取训练样本数据到结构体中//
void GetTrainingData()
{
	ifstream GetTrainingData ( "sample.txt", ios::in );
	
	for(int m=0;m<N;m++)
	{
		for(int i=0;i<IN;i++)
		{
			GetTrainingData>>Study_Data[m].input[i];  //取得输入数据
		}
		for(int j=0;j<ON;j++)
		{
			GetTrainingData>>Study_Data[m].teach[j];  //取得输出数据
		}
	}
	
	GetTrainingData.close();
}

////////////////////////////////
////第m个学习样本输入子程序///
///////////////////////////////
void input_P(int m)
{
	for (int i=0;i<IN;i++)//有IN个输入层
	 P[i]=Study_Data[m].input[i];
	//获得第m个样本的数据
}//子程序input_P(m）结束

/////////////////////////////
////第m个样本期望信号子程序//
/////////////////////////////
void input_T(int m)
{
	for (int k=0;k<ON;k++)       //ON为修改过的(m)
	 T[k]=Study_Data[m].teach[k];
}//子程序input_T(m)结束


/////////////////////////////////
//隐层各单元输入、输出值子程序///
/////////////////////////////////
void H_I_O(){
	double sigma=0.0;
	int i,j;
	for (j=0;j<HN;j++)
	{
		for (i=0;i<IN;i++)
				sigma+=W[j][i]*P[i]; //求隐层内积/P[i]为样本输入的数据

			      X[j]=sigma;
				//暂不用阀值//X[j]=sigma - YU_HN[i];//求隐层净输入，为什么减隐层的阀值   X[HN]; //隐层的输入
					H[j]=1.0/(1.0+exp(-X[j]));//求隐层输出 siglon函数
	}
}//子程序H_I_O()结束


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


////////////////////////////////////
//反向传播--输出层至隐层的一般化误差子程序////
////////////////////////////////////
double d_err[ON];
void Err_O_H(int m)//第m个样本的误差程序
{
	double abs_err[ON];   //每个样本的绝对误差都是从0开始的
	double sqr_err=0;      //每个样本的平方误差计算都是从0开始的
	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)结束

////////////////////////////////////////////////////////
//输出层至隐层的权值调整、输出层阈值调整计算子程序//////
////////////////////////////////////////////////////////
void Delta_O_H(int m)
{
	
	for (int k=0;k<ON;k++){
		for (int j=0;j<HN;j++)
		{
			V[k][j]+=a*d_err[k]*H[j];//输出层至隐层的权值调整
		}
		//YU_ON[k]+=a*d_err[k];//输出层至隐层的阈值调整
	}
	
}//子程序Delta_O_H()结束


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

		e_err[j]=sigma*H[j]*(1-H[j]);//	e_err[j]为局部梯度  隐层各神经元的一般化误差
	}
}//子程序Err_H_I()结束




/////////////////////////////////////////////////////
//隐层至输入层的权值调整、隐层阈值调整计算子程序/////
/////////////////////////////////////////////////////
void Delta_H_I(int m)
{
for (int j=0;j<HN;j++){
	for (int i=0;i<IN;i++) 
	{
		W[j][i]+=b*e_err[j]*P[i];//隐层至输入层的权值调整P[i]为输入层数据
	}
//YU_HN[j]+=b*e_err[j];
}
}//子程序Delta_H_I()结束



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





///保存权值最后调整的结果///
//////////////////////////////////
void save()
{
	ofstream outQuanFile( "weight.txt", ios::out );
	ofstream outYuFile( "bias.txt", ios::out );
	outQuanFile<<"最后调整得到输入层至隐藏层的权值分别为：\n";
	for(int i=0;i<HN;i++)
	{
		for(int j=0;j<IN;j++)
		{
			outQuanFile<<"W["<<i<<"]["<<j<<"]="<<W[i][j]<<"   ";
		}
		outQuanFile<<"\n";
	}
	outQuanFile<<"最后调整得到隐藏层至输出层的权值分别为：\n";
	for(int ii=0;ii<ON;ii++)
	{
		for(int jj=0;jj<HN;jj++)
		{
			outQuanFile<<"V["<<ii<<"]["<<jj<<"]="<<V[ii][jj]<<"   ";
		}
		outQuanFile<<"\n";
	}
	outYuFile<<"输出层的阈值为:\n";
	for(int k=0;k<ON;k++)
	{
		outYuFile<<YU_ON[k]<<"  ";  //输出层阈值写入文本
	}
	outYuFile<<"\n隐层的阈值为:\n";
	for(int kk=0;kk<HN;kk++)
	{
		outYuFile<<YU_HN[kk]<<"  ";  //隐层阈值写入文本
	}
	outQuanFile.close();
}