mybp.cpp

利用C＋＋语言开发的BP算法

// mybp.cpp : Defines the entry point for the console application.//
#include "stdafx.h"
#include <iostream.h>
#include <iomanip.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <time.h>
#define N 5//样本的训练个数
#define IN 4//输入层神经元数目
#define HN 1//隐层神经元数目
#define ON 5//输出层神经元数目
class bpnet 
{
public:
    bpnet();
	virtual ~bpnet();
	Setbp();
    bp_learning(int m);
	bp_testing();
private:
    double P[N][IN];//单个样本输入数据
    double T[N][ON];//单个样本输出数据
    double W[IN][HN];//输入层至隐层权值
    double V[HN][ON];//隐层至输出层权值
	double X[HN];//隐层的输入
    double Y[ON];//输出层的输入
    double H[HN];//隐层的输出
    double O[ON];//输出层的输出
    double sita[HN];//隐层的阈值
    double gama[ON];//输出层的阈值
    double err_m[N];//第m个样本的总误差
    double d_err[ON];//输出层神经元的一般化误差
	double e_err[HN];//隐层各神经元的一般化误差
	double alpha;//输出层至隐层的学习效率
    double beta;//隐层至输入层学习效率
    double Pre_error;//预定误差
	double inputp[N][IN];
	double inputt[N][ON];
	double alphaset;
	double betaset;
	double Testing[IN];
};
bpnet::bpnet()
{
  int i,j;
//隐层权、阈值初始化//
  cout<<"隐层初始化权值是:"<<endl;
  srand((unsigned)(time(NULL)));
  for (i=0;i<IN;i++)
  {
	  for (j=0;j<HN;j++)
	  {
		  W[i][j]=(float)(rand())/(32767);//隐层权值初始化
		  printf("W[%d][%d]=%f\n",i,j,W[i][j]);
	  } 
  }
  cout<<"隐层的初始化阈值是:"<<endl;
  for (j=0;j<HN;j++)
  {
	  sita[j]=(float)(rand())/RAND_MAX;//隐层阈值初始化
      printf("sita[%d]=%f\n",j,sita[j]);
  }
//输出层权、阈值初始化//
  cout<<"输出层的初始化权值是:"<<endl;
  for (int k=0;k<HN;k++)
  {
	  for (int m=0;m<ON;m++)
	  {
		V[k][m]=(float)(rand())/(32767);//输出层权值初始化
	    printf("V[%d][%d]=%f\n",k,m,V[k][m]);
	  }
  }
  cout<<"输出层的初始化阈值是:"<<endl;
  for (int m=0;m<ON;m++)
  {
	  gama[m]=(float)(rand())/RAND_MAX;//输出层阈值初始化
	  printf("gama[%d]=%f\n",m,gama[m]);
  }
}
bpnet::Setbp()
{	
	cout<<"请输入训练神经网络的输入样本:"<<endl;
	for (int i=0;i<N;i++)
	{
		printf("第%d组输入样本是:\n",i+1);

		{
			for(int j=0;j<IN;j++)
				cin>>inputp[i][j];
		}
	}
	cout<<"请输入训练神经网络的输出样本:"<<endl;
	for (i=0;i<N;i++)
	{
		printf("第%d组输出样本是:\n",i+1);
		{
			for(int k=0;k<ON;k++)
			cin>>inputt[i][k];
		}
	}
	for (i=0;i<N;i++)
	{
		for(int j=0;j<IN;j++)
			P[i][j]=inputp[i][j];
		for (int k=0;k<ON;k++)
		    T[i][k]=inputt[i][k];
	}
	cout<<"请输入输出层到隐含层学习效率: "<<endl<<"alpha=";
	cin>>alphaset;
	if(alphaset>1)
	{
		cout<<"请输入0-1之间的数!"<<endl;
		cin>>alphaset;
	}
	alpha=alphaset;
	cout<<"请输入隐含层到输入层学习效率:"<<endl<<"beta=";
	cin>>betaset;
	if(betaset>1)
	{
		cout<<"请输入0-1之间的数!"<<endl;
	    cin>>betaset;
	}
    beta=betaset;
}

//////////////////
//bp网络训练//////
//////////////////
bpnet::bp_learning(int m)
{
	double sigma=0.0;
	printf("隐层的输入X[HN]和输出H[HN]分别为:\n");
   	for(m=0;m<N;m++)
	{
		for(int i=0;i<IN;i++)
			for(int j=0;j<HN;j++)
			{
				sigma+=P[m][i]*W[i][j];//求隐层内积
                X[j]=sigma-sita[j];//求隐层输入
                H[j]=1.0/(1.0+exp(-X[j]));//求隐层输出
				cout<<"X["<<j<<"]="<<setw(10)<<X[j]<<" ";
	            //printf("X[%d]=%f ",j,X[j]);
				cout<<"H["<<j<<"]="<<setw(10)<<H[j]<<endl;
				//printf("H[%d]=%f\n",j,H[j]);
			}
		
	}
	printf("输出层的输入Y[ON]和输出O[ON]分别为:\n");
    for (int k=0;k<ON;k++)
	{
		for (int j=0;j<HN;j++)
		{
			sigma+=H[j]*V[j][k];//求输出层内积
		    Y[k]=sigma-gama[k];//求输出层净输入
            O[k]=1.0/(1.0+exp(-Y[k]));//求输出层输出
            cout<<"Y["<<k<<"]="<<setw(10)<<Y[k]<<" ";
			//printf("Y[%d]=%f ",k,Y[k]);
            cout<<"O["<<k<<"]="<<setw(10)<<O[k]<<endl;
			//printf("O[%d]=%f\n",k,O[k]);
		}
	}
	double abs_err[ON];//每个样本的绝对误差都是从0开始的
    double sqr_err=0;//每个样本的平方误差计算都是从0开始的
	for (k=0;k<ON;k++)
	{
		abs_err[k]=T[m][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]);//输出层各神经元的一般化误差
	}
	err_m[m]=sqr_err/2;//第m个样本下输出层的误差/2=第m个样本的误差
    cout<<"第m个样本的误差为:"<<err_m[m]<<endl;
    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]);//隐层各神经元的一般化误差
	}
	cout<<"调整后输出层的阈值gama[ON]和权值V[HN][ON]分别是:"<<endl;
	for (k=0;k<ON;k++)
	{
		gama[k]+=alpha*d_err[k];//输出层至隐层的权值调整
        printf("gama[%d]=%f\n",k,gama[k]);
	}
	for(k=0;k<ON;k++)
		for (int j=0;j<HN;j++)
		{
			V[j][k]+=alpha*d_err[k]*H[j];//输出层至隐层的阈值调整
            printf("V[%d][%d]=%f\n",j,k,V[j][k]);
		}
	
	cout<<"调整后隐层的阈值sita[HN]和权值W[IN][HN]分别是:"<<endl;
	for(j=0;j<HN;j++)
	{
		sita[j]+=beta*e_err[j];//隐层至输入层的阈值调整
        printf("sita[%d]=%f\n",j,sita[j]);
	}
	for(j=0;j<HN;j++)
        for (int i=0;i<IN;i++)
		{
			for(m=0;m<N;m++)
			W[i][j]+=beta*e_err[j]*P[m][i];//隐层至输入层的权值调整
			printf("W[%d][%d]=%f\n",i,j,W[i][j]);
		}
	
	double total_err=0;
    for (m=0;m<N;m++)
		total_err+=err_m[m];//每个样本的均方误差加起来就成了全局误差
	    cout<<"全局误差是:"<<total_err<<endl;
}
////////////////////////
///bp网络性能验证///////
////////////////////////
bpnet::bp_testing() 
{
	cout<<"下面进行神经网络性能的验证!"<<endl;
	cout<<"请输入验证神经网络的样本:"<<endl;
	for (int i=0;i<IN;i++)
	{
		cin>>Testing[i];
	}
	double sigma=0.0;
    for(i=0;i<IN;i++)
		for(int j=0;j<HN;j++)
			{
				sigma+=Testing[i]*W[i][j];//求隐层内积
                X[j]=sigma-sita[j];//求隐层输入
                H[j]=1.0/(1.0+exp(-X[j]));//求隐层输出
			}
	
	printf("输出层输出为:\n");
    for (int k=0;k<ON;k++)
	{
		for (int j=0;j<HN;j++)
		{
			sigma+=H[j]*V[j][k];//求输出层内积
		    Y[k]=sigma-gama[k];//求输出层净输入
            O[k]=1.0/(1.0+exp(-Y[k]));//求输出层输出
            cout<<"O["<<k<<"]="<<setw(20)<<O[k]<<endl;
			//printf("O[%d]=%f\n",k,O[k]);
		}
	}
}
bpnet::~bpnet()
{
}
main(int argc, char* argv[])
{
	bpnet MY;
	MY.Setbp(); 
	double total_err=0.0;
	double Pre_error;
	cout<<"请输入预定误差:"<<endl;
	cin>>Pre_error;
	int study=0;
	if(total_err<Pre_error)
	{
		for (int m=0;m<N;m++) 
		{
			MY.bp_learning(m);
		    ++study;
		} //全部样本训练完毕
			
	}
	cout<<"网络已经学习了"<<study<<"次"<<endl;
    MY.bp_testing(); 
    char s;
	cout<<"请随便输入一个字符，按回车退出程序!"<<endl;
	cin>>s;
	return 1;
 }