rbf_nn.cpp

4输入层

# include <iostream.h>   
# include <fstream.h>   
# include <iomanip.h> 

# include <stdlib.h>
# include <time.h>

# include <math.h>

const int     TrainSize=120;
const int     TextSize=30;
const double  Emax=0.05;
const int     InputLayerSize=4;
const int     HiddenLayerSize=3;
const int     OutputLayerSize=2;
char    trainfile[]="Data/2_5-1train.txt";
char    textfile[]="Data/2_5-1test.txt";
char    finalfile[]="Data/final_RBF.txt";
char    weightfile[]="Data/weighefile_RBF.txt";

double Train[TrainSize][InputLayerSize+OutputLayerSize];
double Text[TextSize][InputLayerSize+OutputLayerSize];


class Data
{
public:
	double data;
};

class i_layer
{
public:
	Data output[TrainSize];
};

class h_layer  
{
public:
	Data    output[TrainSize];	
	int     c[TrainSize];
	int     no;
	Data    t[InputLayerSize];
	double  d;
	double  wight_HO[OutputLayerSize];
};

class o_layer  
{
public:
	Data input[TrainSize]; 
	Data ioutput[TrainSize];
	Data routput[TrainSize];
	Data error[TrainSize];
};

class RBF
{
public:
	i_layer IL[InputLayerSize+1];
	h_layer HL[HiddenLayerSize+1]; 
	o_layer OL[OutputLayerSize];

	double   D;

	unsigned long count;
	double   E;
	double   alpha;

	void InputFileData(char * file, double data[][InputLayerSize+2]);
	void Init();


	void Study()
	{
		cout<<"********************************************************"<<endl;
    	cout<<"\t\t-----RBF神经网络学习开始(2)-----"<<endl<<endl;
		InputData(0,Train);

		Study_1();
		Study_2();
		ShowFinalWight();

	    cout<<"\t\t-----RBF神经网络学习结束(2)-----"<<endl<<endl;
		cout<<"********************************************************"<<endl;
	}

	void Study_1()
	{
		Separate();
		CalculationT();
		CalculationD();
	}

    void Study_2()
	{
	    count=0;
		CalculationHLo(Train);
	    do{	
            CalculationOLro(0);
            CalculationOLerror();
	        ModifyHLwight_HO();
            CalculationE();
		}while(count<100*TrainSize && E>=Emax);
	}

    void DataText()
	{
	    cout<<"********************************************************"<<endl;
    	cout<<"\t\t-----RBF神经网络测试开始(3)-----"<<endl<<endl;

		InputData(1,Text);
		CalculationHLo(Text);
		CalculationOLro(1);
	    ShowFinalClass();

        cout<<"\t\t-----RBF神经网络测试结束(3)-----"<<endl<<endl;
		cout<<"RBF神经网络测试结果已经输出到： "<<finalfile<<endl<<endl;
		cout<<"********************************************************"<<endl;
	}


	void InputData(int flag,double data[][InputLayerSize+2]);

	void Separate();
	void CalculationT();
	void CalculationD();

	void CalculationHLo(double data[][InputLayerSize+2]);
    void CalculationOLro(int flag);
    void CalculationOLerror();
    void ModifyHLwight_HO();
    void CalculationE();
	void ShowFinalWight();
	void InputWightData(h_layer*HL,double &D);
    void ShowFinalClass();
	void ShowData();

};



void main()
{
	char flag='a';
	while(flag!='E'&&flag!='e')
	{
    	cout<<"\t\t-----欢迎使用RBF神经网络分类器-----"<<endl;
    	cout<<"\t\t-----新建RBF神经网络分类器请输入(C/c)-----"<<endl;
	    cout<<"\t\t-----测试RBF神经网络分类器请输入(T/t)-----"<<endl;
    	cout<<"\t\t-----新建并测试RBF神经网络分类器(S/s)-----"<<endl;
		cout<<"\t\t-----退出程序(E/e)-----"<<endl;
		cin>>flag;
		while(flag!='C'&&flag!='c'&&flag!='T'&&flag!='t'&&flag!='S'&&flag!='s'&&flag!='E'&&flag!='e')
		{
			cout<<"\t\t-----命令输入错误，请重新输入!--退出程序(E/e)-----"<<endl;
			cin>>flag;
		}
		if(flag=='E'||flag=='e')
			break;

    	RBF rbf_nn;

     	rbf_nn.InputFileData(trainfile,Train); 
    	rbf_nn.InputFileData(textfile,Text);   
    	rbf_nn.Init();                         
 
    	if(flag=='C'||flag=='c')
		{
			cout<<"********************************************************"<<endl<<endl;
			cout<<"\t\t-----新建RBF神经网络分类器开始-----"<<endl<<endl;

          	rbf_nn.Study();                        

			cout<<"\t\t-----新建RBF神经网络分类器完成-----"<<endl<<endl;
			cout<<"********************************************************"<<endl<<endl;
		}
		if(flag=='T'||flag=='t')
		{
			cout<<"********************************************************"<<endl<<endl;
			cout<<"\t\t-----测试RBF神经网络分类器开始-----"<<endl;

			rbf_nn.InputWightData(rbf_nn.HL,rbf_nn.D);
    	    rbf_nn.DataText();                     

			cout<<"\t\t-----测试RBF神经网络分类器完成-----"<<endl;
			cout<<"********************************************************"<<endl<<endl;
		}
		if(flag=='S'||flag=='s')
		{
			cout<<"********************************************************"<<endl<<endl;
			cout<<"\t\t-----新建并测试RBF神经网络分类器开始-----"<<endl;

			rbf_nn.Study();                        
			rbf_nn.DataText();                     

			cout<<"\t\t-----新建并测试RBF神经网络分类器完成-----"<<endl;
			cout<<"********************************************************"<<endl<<endl;
		}
		if(flag!='E'&&flag!='e')
		{
		    cout<<"退出程序(E/e),输入任意字符重新开始分类器"<<endl;
    	    cin>>flag;
		}
	}
	
	cout<<"********************************************************"<<endl<<endl;
    cout<<"\t\t-----程序结束-----"<<endl<<endl;
	cout<<"********************************************************"<<endl;
	
}



void RBF:: InputFileData(char * file, double data[][InputLayerSize+2])
{
	cout<<"********************************************************"<<endl;
	count=0;

	int size;
	char *show1;
	char *show2;
	if(file==trainfile)
	{
		size=TrainSize;
		show1="\t\t-----训练数据读入开始(1.2)-----";
       	int i=5;
		show2="\t\t-----训练数据读入结束(1.2)-----";
	}
	else
	{
		size=TextSize;
		show1="\t\t-----测试数据读入开始(1.2)-----";
		int i=5;
		show2="\t\t-----测试数据读入结束(1.2)-----";
	}

	cout<<show1<<endl<<endl;

	int i=5;
    char temp[2];  
	ifstream   in;
	in.open(file,ios::nocreate);
	if(!in)
	{
		cout<<"\t\t-----文件不存在打开失败-----"<<endl<<endl;
		exit(0);  
	}
	else
		cout<<"\t\t-----文件打开成功-----"<<endl<<endl;
	for(int k=0;k<size;k++) 
	{
		for(int n=0;n<InputLayerSize+OutputLayerSize;n++)  
		{
			in>>temp;
   	        data[k][n]=strtod(temp,NULL);     
				in.ignore();
		}
		if(in.eof()!=0)   break; 
	}
	in.close();
	cout<<"\t\t-----文件成功关闭-----"<<endl<<endl;



	cout<<show2<<endl<<endl;
	cout<<"********************************************************"<<endl;
} 


void RBF::Init()
{
	cout<<"********************************************************"<<endl;
	cout<<"\t\t-----程序初始化开始(1.1)-----"<<endl<<endl;

	E=0.0;
	count=0;
	alpha=0.5;
	for(int p=1;p<=HiddenLayerSize;p++)
		for(int n=0;n<=InputLayerSize;n++)
			HL[p].t[n].data=Train[((p-1)*40+37)%TrainSize][n];
	CalculationD(); 
	
	srand((unsigned)time(NULL));

	for(int p1=0;p1<=HiddenLayerSize;p1++)  
		for(int q=0;q<OutputLayerSize;q++)
			HL[p1].wight_HO[q]=rand()/(double)RAND_MAX;

    for(int m=0;m<TrainSize;m++)
		HL[0].output[m].data=-1.0;
	for(    p=0;p<=HiddenLayerSize;p++)
		HL[p].no=0;

	cout<<"\t\t-----程序初始化结束(1.1)-----"<<endl<<endl;
	cout<<"********************************************************"<<endl;

}

void RBF:: InputData(int flag,double data[][InputLayerSize+2])
{
	int Size;
	if(flag==0)
		Size=TrainSize;
	else
		Size=TextSize;
	for(int n=0;n<Size;n++)
	{
		for(int m=0;m<InputLayerSize+OutputLayerSize;m++)
		{
	    	if(m<InputLayerSize)
	    		IL[m+1].output[n].data=data[n][m];
	    	else 
	    		OL[m-InputLayerSize].ioutput[n].data=data[n][m];

		} 
	}

}

void RBF:: Separate()
{
	double dmin=0.0;
	double dsum=0.0;
	int    a;
	int    p1=0;
	for(int n=0;n<TrainSize;n++)
	{
		dmin=0.0;p1=0;
		for(int p=1;p<=HiddenLayerSize;p++)
		{
	    	dsum=0.0;
	    	for(int m=0;m<InputLayerSize;m++)
	    		dsum+=pow(fabs(Train[n][m]-HL[p].t[m].data),2);
			if(p==1)
			{					
				dmin=dsum;a=n;p1=p;
			}
    		if(dmin>dsum)
			{
				dmin=dsum;a=n;p1=p;
			}
		}
		HL[p1].no++;
		HL[p1].c[HL[p1].no-1]=a;		
	}
}

void RBF:: CalculationT()
{
	double sum=0.0;
	for(int p=1;p<=HiddenLayerSize;p++)
	{
		for(int m=0;m<InputLayerSize;m++)
		{
			sum=0.0;
	    	for(int i=1;i<=HL[p].no;i++)
		    	sum+=Train[HL[p].c[i-1]][m];
			HL[p].t[m].data=sum/HL[p].no;
		}			
	}
}

void RBF:: CalculationD()
{
	double dsum=0.0;
	double dmax=0.0;
	for(int p=1;p<HiddenLayerSize;p++)
		for(int p1=p+1;p1<=HiddenLayerSize;p1++)
		{
			dsum=0.0;
			for(int m=0;m<InputLayerSize;m++)
				dsum+=pow(fabs(HL[p].t[m].data-HL[p1].t[m].data),2);
			if(dsum>dmax) 	
				dmax=dsum;
		}
	
	dmax = sqrt(dmax);            
	D = dmax/sqrt(2*HiddenLayerSize);     
}

void RBF:: CalculationHLo(double data[][InputLayerSize+2])
{
	double sum=0.0;
	int Size;
	if(data==Train)
    	Size=TrainSize;
	else
		Size=TextSize;
	for(int n=0;n<Size;n++)
	{
		for(int p=1;p<=HiddenLayerSize;p++)
		{
	    	sum=0.0;
	    	for(int m=0;m<InputLayerSize;m++)
		    	sum+=pow(fabs(data[n][m]-HL[p].t[m].data),2);
			HL[p].output[n].data=exp(-1.0*sum/(2*D*D));
		}
	}
}


void RBF:: CalculationOLro(int flag)
{
	int Size;
	double temp=0.0;
	if(flag==0)
		Size=TrainSize;
	else
		Size=TextSize;
	for(int n=0;n<Size;n++)
	{ 
       	for(int q=0;q<OutputLayerSize;q++)
		{
   	    	temp=0.0;
	        for(int p=0;p<=HiddenLayerSize;p++)
	        	temp+=HL[p].output[n].data*HL[p].wight_HO[q];
        	OL[q].input[n].data=temp;
		}
       	for(q=0;q<OutputLayerSize;q++)
        	OL[q].routput[n].data=1.0/(1.0+exp(-OL[q].input[n].data));
	}
}

void RBF:: CalculationOLerror()
{
	for(int n=0;n<TrainSize;n++)
		for(int q=0;q<OutputLayerSize;q++)
			OL[q].error[n].data=(OL[q].ioutput[n].data-OL[q].routput[n].data)*OL[q].routput[n].data*(1.0-OL[q].routput[n].data);
}


void RBF:: ModifyHLwight_HO()
{
    double temp=0.0;
   	for(int p=0;p<=HiddenLayerSize;p++)
	{
    	for(int q=0;q<OutputLayerSize;q++)
		{
    	    temp=0.0;
    		for(int n=0;n<TrainSize;n++)
	    		temp=temp+OL[q].error[n].data*HL[p].output[n].data;
    		HL[p].wight_HO[q]=HL[p].wight_HO[q]+alpha*temp;
		}
	}
}

void RBF:: CalculationE()
{
	double temp1=0.0;
	double temp2=0.0;
   	for(int n=0;n<TrainSize;n++)
	{
		temp1=0.0;
	    for(int q=0;q<OutputLayerSize;q++)
			temp1+=(OL[q].ioutput[n].data-OL[q].routput[n].data)*(OL[q].ioutput[n].data-OL[q].routput[n].data);
	    temp2+=temp1/2;
	}
   	E=temp2/TrainSize;
}


void RBF:: ShowFinalWight()
{
	cout<<"\t\t********************************************"<<endl;
    cout<<"\t\t-----向文件输出训练好的网络中心值，方差，网络权值 阈值开始-----"<<endl<<endl;
    ofstream out(weightfile);
	if(!out)
	{
    	cout<<"\t\t-----中心值、方差、权值、阈值输出到文件打开失败-----"<<endl<<endl;
   		exit(0);  
	}
   	else
		cout<<"\t\t-----中心值、方差、权值、阈值输出到文件打开成功-----"<<endl<<endl;

	for(int p=1;p<=HiddenLayerSize;p++)
	{
		for(int m=0;m<InputLayerSize;m++)
			out<<setprecision(6)<<HL[p].t[m].data<<" ";
		out<<endl;
	}
	out<<D<<endl;

   	for(int p1=0;p1<=HiddenLayerSize;p1++)  
	{
    	for(int q=0;q<OutputLayerSize;q++)
    		out<<setprecision(6)<<HL[p1].wight_HO[q]<<" ";
   		out<<endl;
	}

   	out.close();
    cout<<"\t\t-----中心值、方差、权值、阈值输出到文件关闭成功-----"<<endl<<endl;
   	cout<<"训练好的网络中心值、方差、权值、阈值已经输出到： "<<weightfile<<endl<<endl;
   	cout<<"\t\t-----向文件输出训练好的网络中心值，方差，网络权值 阈值结束-----"<<endl<<endl;
   	cout<<"\t\t********************************************"<<endl;
}
void RBF:: InputWightData(h_layer*HL,double &D)
{
	cout<<"********************************************************"<<endl;
   	cout<<"\t\t-----从文件读取已经训练好的中心值,方差,阈值,权值开始-----"<<endl<<endl;
   	char temp[2];
   	ifstream   in;
   	in.open(weightfile,ios::nocreate);
    if(!in)
	{
       	cout<<"\t\t-----RBF神经网络分类器还未生成，请先新建RBf神经网络分类器-----"<<endl<<endl;
       	exit(0);  
	}
   	else
	 	cout<<"\t\t-----文件打开成功-----"<<endl<<endl;

	for(int p=1;p<=HiddenLayerSize;p++)
	{
    	for(int m=0;m<InputLayerSize;m++)
		{
    		in>>temp;
    		HL[p].t[m].data=strtod(temp,NULL);     
    		in.ignore();
		}
    	in.ignore();
    	if(in.eof()!=0)   break;
	}

	in.ignore();
   	in>>temp;
   	D=strtod(temp,NULL);
   	in.ignore();

   	for(    p=0;p<=HiddenLayerSize;p++) 
	{
       	for(int q=0;q<OutputLayerSize;q++)  
		{
           	in>>temp;
            HL[p].wight_HO[q]=strtod(temp,NULL);     
        	in.ignore();
		}

       	if(in.eof()!=0)   break; 
	}
    in.close();
    cout<<"\t\t-----文件成功关闭-----"<<endl<<endl;

	cout<<"\t\t-----从文件读取已经训练好的中心值,方差,阈值,权值完成-----"<<endl<<endl;
    cout<<"********************************************************"<<endl;
}


void RBF:: ShowFinalClass()
{
	ofstream   out(finalfile);
   	if(!out)
	{
    	cout<<"\t\t-----文件打开失败-----"<<endl<<endl;
       	exit(0);  
	}
   	for(int n=0;n<TextSize;n++)
	{
		for(int m=1;m<=InputLayerSize;m++)  
			out<<setprecision(7)<<setw(10)<<IL[m].output[n].data;
       	for(int q=0;q<OutputLayerSize;q++)  
           	out<<setprecision(7)<<setw(10)<<OL[q].ioutput[n].data<<"  ";
        for(    q=0;q<OutputLayerSize;q++)  
           	out<<setprecision(7)<<setw(10)<<OL[q].routput[n].data<<"  ";
        out<<endl;
	}
   	out.close();
}


void RBF:: ShowData()
{
	cout<<"********************************************************"<<endl;
	cout<<"\t\t~~~~~RBF神经网络参数调试输出开始~~~~~"<<endl<<endl;

	cout<<endl<<"各隐含层中心值:"<<endl<<endl;
	for(int p=1;p<=HiddenLayerSize;p++)
	{
		cout<<"第"<<p<<"个隐含层结点中心值:"<<endl;
		for(int n=0;n<InputLayerSize;n++)
			cout<<setprecision(7)<<setw(10)<<HL[p].t[n].data;
		cout<<endl;
	}

	cout<<endl<<"中心值方差,D="<<setprecision(7)<<setw(10)<<D<<endl<<endl;
	
	cout<<endl<<"隐含层到输出层的阈值,权值:"<<endl<<endl;
	for(int p1=0;p1<=HiddenLayerSize;p1++)
	{
		cout<<"第"<<p1<<"个隐含层到输出层权值:"<<endl;
		for(int q=0;q<OutputLayerSize;q++)
			cout<<setprecision(7)<<setw(10)<<HL[p1].wight_HO[q];
		cout<<endl;
	}

	cout<<"\t\t~~~~~RBF神经网络参数调试输出结束~~~~~"<<endl<<endl;
	cout<<"********************************************************"<<endl;
}