bp.cpp

用人工神经网络实现异或的功能。用反向传播算法（BP）来实现神经网络

// Bp.cpp: implementation of the Bp class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Bp.h"

//#include "Sample.h"
#include "stdio.h"
#include "stdlib.h"
#include "math.h"

#include "time.h"

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

Bp::Bp()
{
	f=fopen("BPN.txt","w");

}

Bp::~Bp()
{

}


void Bp::InitializeRandom()
{
	time_t t;
	srand((unsigned)time(&t));
}

int Bp::RandomInt(int low,int high)
{
	return rand()%(high-low+1)+low;
}

double Bp::RandomReal(double low,double high)
{
	return ((double)rand()/RAND_MAX)*(high-low)+low;
}


void Bp::InputMultV(double input[],int n,double (*Vmatrix)[H],int h,double output[])
{
	//对应有n个输入端 ，n*h输入层连接矩阵，h个隐单元   h个隐单元得输出

	int i;

	for(i=0;i<h;i++)
		output[i]=0.0;


	for( i=0;i<h;i++)
		for(int j=0;j<n;j++)
		{
			output[i]=output[i]+input[j]*Vmatrix[j][i];

		}

}

void Bp::HMultoutput(double hidden[],int h,double (*Wmatrix)[M],int m,double output[])
{ 
	//对应有h个隐单元，h*m输出层连接矩阵，m个输出单元
	int i;
	for(i=0;i<m;i++)
		output[i]=0.0;

	for(i=0;i<m;i++)
		for(int j=0;j<h;j++)
		{
			output[i]=output[i]+hidden[j]*Wmatrix[j][i];
		}
}

double  Bp::NetFunction(double net)
{
	double f;
	f=1.0/(1.0+exp(-net));
	return f;

}

void Bp::netoutput(Sample *question[],int questionnum,double(*w)[M],double(*v)[H],int h)
{
	int scount;
	double outhidden[H];
	double outlast[M];

	int hunit;
	int outunit;

	for(scount=0;scount<questionnum;scount++)
	{
		int m=question[scount]->outputnum;

		InputMultV(question[scount]->x,question[scount]->inputnum,v,h,outhidden);
		for( hunit=0;hunit<h;hunit++)
			outhidden[hunit]=NetFunction(outhidden[hunit]);
		

		HMultoutput(outhidden,h,w,m,outlast);
		for( outunit=0;outunit<m;outunit++)
		{
			outlast[outunit]=NetFunction(outlast[outunit]);
			//question[scount]->y[outunit]=outlast[outunit];
			if(outlast[outunit]<0.5)
				question[scount]->y[outunit]=0.0;
			else 
				question[scount]->y[outunit]=1.0;
		}
		
	}
}


void Bp::bpnet(double alph,Sample *samples[],int samplenum,double (*w)[M],double(*v)[H],int h)
{
	double neterror;
	int loopcount;
	int scount;

	double outhidden[H];
	double outlast[M];

	double detaout[M];
	double detahidden[H];

	int outunit;
	int hunit;
	
	neterror=1.0+EPSILON;
	loopcount=0;

	while(neterror>EPSILON && loopcount<MAX_LOOP)
	{
		loopcount++;
		neterror=0.0;
		for(scount=0;scount<samplenum;scount++)
		{
			int m=samples[scount]->outputnum;

			InputMultV(samples[scount]->x,samples[scount]->inputnum,v,h,outhidden);
			for( hunit=0;hunit<h;hunit++)
				outhidden[hunit]=NetFunction(outhidden[hunit]);
		

			HMultoutput(outhidden,h,w,m,outlast);
			for( outunit=0;outunit<m;outunit++)
				outlast[outunit]=NetFunction(outlast[outunit]);

			// 计算输出层的权修改误差

			for(outunit=0;outunit<m;outunit++)
				
			{
				detaout[outunit]=outlast[outunit]*(1.0-outlast[outunit])*
				                 (samples[scount]->y[outunit]-outlast[outunit]);
			
				//计算输出误差
			
				neterror=neterror+(samples[scount]->y[outunit]-outlast[outunit])*
					              (samples[scount]->y[outunit]-outlast[outunit]);
			}
			//计算隐层的权修改量
			for(hunit=0;hunit<h;hunit++)
			{

				double z=0.0;

				for(outunit=0;outunit<m;outunit++)
				{
					z=z+w[hunit][outunit]*detaout[outunit];
				}
				detahidden[hunit]=z*outhidden[hunit]*(1.0-outhidden[hunit]);
			}
			//修改输出层权矩阵 
			for(hunit=0;hunit<h;hunit++)

				for(outunit=0;outunit<m;outunit++)
					
					w[hunit][outunit]=w[hunit][outunit]+alph*outhidden[hunit]*detaout[outunit];

		

			//修改隐层权矩阵
			for(int incnt=0;incnt<samples[scount]->inputnum;incnt++)
				
				for(hunit=0;hunit<h;hunit++)

					v[incnt][hunit]=v[incnt][hunit]+alph*samples[scount]->x[incnt]*
					                                     detahidden[hunit];

			



		

		}//for every sample



	}

}




void  Bp::application()
{
	

	double xarray[2];
	double yarray[2];

	Sample *samples[4];

	xarray[0]=0.0;
	xarray[1]=0.0;
	

	
	yarray[0]=0.0;
	yarray[1]=0.0;

	

	samples[0]=new Sample(2,2,xarray,yarray);
//-------------------------------------------------
	xarray[0]=0.0;
	xarray[1]=1.0;
	

	
	yarray[0]=1.0;
	yarray[1]=1.0;

	samples[1]=new Sample(2,2,xarray,yarray);
//---------------------------------------------------
	xarray[0]=1.0;
	xarray[1]=0.0;
	

	
	yarray[0]=1.0;
	yarray[1]=1.0;

	samples[2]=new Sample(2,2,xarray,yarray);
//-----------------------------------------------------
	xarray[0]=1.0;
	xarray[1]=1.0;


	
	yarray[0]=0.0;
	yarray[1]=0.0;

	samples[3]=new Sample(2,2,xarray,yarray);
//--------------------------------------------------

//-----------question----------------------------

    Sample *question[4];
	xarray[0]=0.0;
	xarray[1]=0.0;
	
	
	yarray[0]=0.0;
	yarray[1]=0.0;

	
	question[0]=new Sample(2,2,xarray,yarray);
//----------------------------------------
	xarray[0]=0.0;
	xarray[1]=1.0;
	

	
	yarray[0]=0.0;
	yarray[1]=0.0;

	question[1]=new Sample(2,2,xarray,yarray);
//---------------------------------
	xarray[0]=1.0;
	xarray[1]=0.0;
	

	
	yarray[0]=0.0;
	yarray[1]=0.0;

	question[2]=new Sample(2,2,xarray,yarray);
//-----------------------------------------
	xarray[0]=1.0;
	xarray[1]=1.0;


	
	yarray[0]=0.0;
	yarray[1]=0.0;

	question[3]=new Sample(2,2,xarray,yarray);
//-----------------------------------------
	
	
for(int outloop=0;outloop<TEST_LOOP;outloop++)
{

	InitializeRandom();
	

	int i;
	int j;
	int n=samples[0]->inputnum;
	double w[10][2];
	double v[4][10];
	for(i=0;i<10;i++)
		for(j=0;j<2;j++)
			w[i][j]=RandomReal(-3.0,3.0);


	for(i=0;i<4;i++)
		for(j=0;j<10;j++)
			v[i][j]=RandomReal(-3.0,3.0);
	bpnet(0.5,samples,4,w,v,10);

	netoutput(question,4,w,v,10);

	

	fprintf(f,"\nthe %dth test result\n  ",outloop);
	for(i=0;i<4;i++)
	{
		fprintf(f,"\nquestion %d \n",i);

		fprintf(f,"input:  %6.3f",question[i]->x[0]);
		
		fprintf(f,"%6.3f ",question[i]->x[1]);
	

		fprintf(f,"output: %6.3f ",question[i]->y[0]);
	    //fprintf(f,"%6.3f \n",question[i]->y[1]);


	}

	
	

}
	
}