bpann.cpp

采用Visual C++6.0开发的BP神经网络程序

#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <time.h>


///////////////////////////以下为定义各个所用变量
int m_InputNums = 4;      //输入层节点数     
int m_OutputNums = 4;     //输出层节点数      
int m_HideNums = 10;       //隐层节点数      
int m_Maxcount = 100;    //最大迭代次数      
float m_Precision = 0.001;    //设置精度     
float m_Moon = 1.1;         //加快走出平坦区 
float Outdao[4];            //输出层偏导
float Yidao[10];            //隐层偏导

float Erro[4] = {0.0};              //误差存储
double Erroc[300];
double Y1[10];				//隐层输出
double Y2[4];				//输出层输出

float bc = 0.88;		//步长通常取值在0.1-3之间
float at = 0.90;     //惯性项系数 影响收敛速度
float Wp[4][8];		//输入层到隐层的权值 
float Vp[8][4];		//隐层到输出层的权值
float Input[3][4] = {
	    0.1323 ,0.323  ,-0.132 ,-0.1342,
		0.321  ,0.2434 ,0.456  ,-0.5342,
		-0.6546,-0.3242,0.3255 ,0.2313
};   //训练集样本 即输入
float Output[3][4] = {
	    0.5435 ,0.422 ,-0.642,-0.3425,
		0.1    ,0.562 ,0.5675,-0.3452,
		-0.6464,-0.756,0.11  ,0.2312
};  //预期输出值

///////////////////////////以下为函数声明

void InitNet(void);    //初始化网络
void FCalcul(float*Feature);  //前向计算网络隐含层和输出层各神经元的输出
void ErroCalcul();  //计算误差
void BCalcul();   //后向计算修正权值



////////////////////////////
void InitNet(void)
{
	int i,j;
	int flag;
	int test = 0;
	srand( (unsigned)time( NULL ) ); 
	//给输入层到隐层权值赋值为-0.1~0.1
	printf("输入层到隐层权值初始值为\n");
	for(i=0;i<m_InputNums;i++)
	{
		for(j=0;j<m_HideNums;j++)
		{			
			Wp[i][j] = float(rand()%100); //产生0~100
			Wp[i][j] = Wp[i][j]/1000;     //产生0~0.1
			flag = rand()%2;
			if(flag == 0)
			{
				Wp[i][j] = -Wp[i][j];
				test ++;
			}	
		 printf("%6f",Wp[i][j]);
		}
		printf("\n");
	}
	test = 0;
	//给隐层到输出层权值赋值为-0.1~0.1
	printf("隐层到输出层权值初始值为\n");
	for(i=0;i<m_HideNums;i++)
	{
		for(j=0;j<m_OutputNums;j++)
		{				
			Vp[i][j] = float(rand()%100); //产生0~100
			Vp[i][j] = Vp[i][j]/1000;     //产生0~0.1
			flag = rand()%2;
			if(flag == 0)
			{
				Vp[i][j] = -Vp[i][j];
				test ++;
			}
			printf("%6f",Vp[i][j]);
		}
		printf("\n");
	}	
		printf("\n");
}

void FCalcul(float* Feature)
{
	int i,j;
	float net;
	for(j = 0; j < m_HideNums; j++)
	{
		net = 0.0;
		for(i = 0; i < m_InputNums; i++)
		{
			net += Wp[i][j]*Feature[i]; //输入层到隐层各个单元的加权和
		}
	  Y1[j] = 1.0/(1.0+exp(-net));  //计算隐层个单元输出
	}
	for(j = 0; j < m_OutputNums; j++)
	{
		net = 0.0;
		for(i = 0; i < m_HideNums; i++)
		{
			net += Vp[i][j]*Y1[i]; //隐层到输出层的加权和∑X(i)V(i) 
		}
		Y2[j] = 1.0/(1.0+exp(-net)); //计算各单元输出
	}
}

void ErroCalcul(float* Feature,int t)
{
	float ErroTemp = 0.0;
	int i,j;
	for(i = 0;i < m_OutputNums;i++)
	{
		ErroTemp+= (Feature[i]-Y2[i])*(Feature[i]-Y2[i]);
		ErroTemp = 0.5*ErroTemp;
		Erro[t] = ErroTemp;
	}

	for(j = 0;j < m_OutputNums;j++)
	{
		Outdao[j] = (Feature[j]-Y2[j])*Y2[j]*(1-Y2[j]); //输出层误差偏导
	}

	for(j = 0;j < m_HideNums;j++)
	{
		float tmp = 0.0;
		for(i = 0;i < m_OutputNums;i++)
		{
			tmp = tmp+Outdao[i]*Vp[j][i]; //为了求隐层偏导计算的求和
		}
		Yidao[j] = tmp*Y1[j]*(1-Y1[j]);  //隐层偏导
	}	
}

void BCalcul()
{
	float m_Vdelfo[10][4] = {0.0},m_Vdel[10][4] = {0.0}; //隐层到输入层权值调整矩阵
	float m_Wdelfo[4][10] = {0.0},m_Wdel[4][10] = {0.0}; //输入层到隐层权值调整矩阵 
	int i,j;
	for(i = 0;i < m_HideNums;i++)       //调整隐层到输入层的权值
		for(j = 0;j < m_OutputNums;j++)
		{
			m_Vdelfo[i][j] = bc*Outdao[j]*Y2[j];
			Vp[i][j] = Vp[i][j]+m_Vdelfo[i][j]+at*m_Vdel[i][j];
			m_Vdel[i][j] = m_Vdelfo[i][j];
		}

	for(i = 0;i < m_InputNums;i++)         //调整输入层到隐层的权值
		for(j = 0;j < m_HideNums;j++)
		{
			m_Wdelfo[i][j] = bc*Yidao[j]*Y1[j];
			Wp[i][j] = Wp[i][j]+m_Wdelfo[i][j]+at*m_Wdel[i][j];
			m_Wdel[i][j] = m_Wdelfo[i][j];
		}			
}

void main(int argc, char *argv[])
{
	
	int m_Sampnum,m_count; //学习样本和学习次数
	
	InitNet();
	m_count = 1;
	while(m_count<=m_Maxcount)
	{
		m_Sampnum = 1;
		while(m_Sampnum <= 3)
		{
			FCalcul(Input[m_Sampnum-1]);
			ErroCalcul(Output[m_Sampnum-1],m_Sampnum-1);
			BCalcul();
			m_Sampnum++;
		}
		//调整使快速走出平坦区
		double temp = 0.0;
		for(int i = 0;i < m_Sampnum-1;i++)
		{
			temp = temp+Erro[i]*Erro[i];
		}
		Erroc[m_count] =sqrt(temp/3);
		if(m_count>=2&&Erroc[m_count]-Erroc[m_count+1]<=0.0001)	
		{
			for(int t = 0;t < m_OutputNums;t++)
			{
				float net = 0.0;
				for(int j = 0; j < m_OutputNums; j++)
				{
					for(i = 0; i < m_HideNums; i++)
					{
						net += Vp[i][j]*Y1[i];  //输入层到隐层的加权和∑X(i)V(i)
					}
				}
				
				Y2[t] = 1/(1+exp(-net)/m_Moon);
				printf("%6f ",Y2[t]);
			}
		
		}
		
		if(Erroc[m_count] <= m_Precision)
			break;
		m_count++;
		Erroc[m_count+1] = Erroc[m_count];
	}

	///////////////////////以下为显示结果
	printf("学习次数为%d\n",m_count-1);

	printf("学习样本如下\n");
	for(int t = 0;t < 3;t++)
	{	
		for(int p = 0;p < 4;p++)
		{
			printf(" %6f ",Input[t][p]);
		}
		printf("\n");
	}
	printf("预期输出值如下\n");
	for(t = 0;t < 3;t++)
	{	
		for(int p = 0;p < 4;p++)
		{
			printf(" %6f ",Output[t][p]);
		}
		printf("\n");
	}
    printf("网络输出结果如下\n ");
		for(int p = 0;p < 4;p++)
		{
			printf("%8f ",Y2[p]);
		}
	printf("\n");
	printf("误差为%8f\n ",Erroc[m_count]);

	int i;
	scanf("%d",&i);
}