somnet.cpp

一个可以运行的som神经网络程序

// Somnet.cpp: implementation of the CSomnet class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Somnet.h"
#include <fstream.h>
#include <iomanip.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>


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

CSomnet::CSomnet()
{
	current_iteration_num=0;
	 min_distance=1000.0;
	 study_efficiency=efficiency;
	 neighbor_width=OutputLayerColumn;
     neighbor_height=OutputLayerRow;
	 winner_row=OutputLayerRow/2;
	 winner_column=OutputLayerColumn/2;

}

CSomnet::~CSomnet()
{

}

int CSomnet::getcurrentnum()
{
	return current_iteration_num;
}

long double CSomnet::getmindistance()
{
	return min_distance;
}
/****************************************************************/
//该函数初始化输入数组
/****************************************************************/
CSomnet::CSomnet(int layer,int nd)
{
	int i;
	layernumber=layer;
	/*midianumber=midia;*/
	ndnumber=nd;
	inputMode=new double*[layernumber];
	for(i=0;i<layernumber;i++)
	{
		*(inputMode+i)=new double[ndnumber];
	}
//     for(i=0;i<layernumber;i++)
// 		for(j=0;j<midianumber;j++)
// 	{
//       *(*(inputMode+i)+j)=new int[ndnumber];	
// 	}
	InputLayerNum=ndnumber;
	weight=new double*[OutputLayerColumn*OutputLayerRow];
	for(i=0;i<OutputLayerRow*OutputLayerColumn;i++)
	{
		weight[i]=new double[InputLayerNum];
	}
}

/****************************************************************/
//该函数初始化距离变量为0,初始化保存胜出节点的位置的变量
/****************************************************************/
void CSomnet::init_distance()
{
	for(int i=0;i<OutputLayerRow;i++)
	for(int j=0;j<OutputLayerColumn;j++)
	distance[i*OutputLayerColumn+j]=0.0;        
 }

/****************************************************************/
//该函数用于计算欧氏距离,并找到获胜神经元
/****************************************************************/
void CSomnet::eula_distance(int z)
{
	int i,j,n;
	int ttLow,ttUp,ppLow,ppUp;
	ttLow=winner_column-neighbor_width/2;
	ttUp=winner_column+neighbor_width/2;
	ppLow=winner_row-neighbor_height/2;
	ppUp=winner_row+neighbor_height/2;
	if(ttLow<0)
		ttLow=0;
	if(ttUp>=OutputLayerColumn)
		ttUp=OutputLayerColumn-1;
	if(ppLow<0)
		ppLow=0;
	if(ppUp>=OutputLayerRow)
		ppUp=OutputLayerRow-1;
	for( i=ppLow;i<=ppUp;i++)
	for( j=ttLow;j<=ttUp;j++)
	{
		if(!(flag[i][j]==100))                       //用一个变化的外部变量控制循环的方法
		{
			/*for(m=0;m<midianumber;m++)*/
			for(n=0;n<ndnumber;n++)
				distance[i*OutputLayerColumn+j]+=
				pow((inputMode[z][n]-weight[i*OutputLayerColumn+j][n]),2);
			if(distance[i*OutputLayerColumn+j]<min_distance)
			{
				min_distance=distance[i*OutputLayerColumn+j];
				temp_row=i;
				temp_column=j;
			}
		}
		
	}
	if(current_iteration_num>0)
	{
		if(min_distance<=error_limit)                     
		{
			row[temp_row]=temp_row;
			column[temp_column]=temp_column;
			flag[temp_row][temp_column]=100;
		}
		
	}
}

/****************************************************************/
//调整权值
/****************************************************************/
void CSomnet::weight_change(int z)
{
	int i,j,n;
	int ttLow,ttUp,ppLow,ppUp;
	winner_row=temp_row;
	winner_column=temp_column;
	ttLow=winner_column-neighbor_width/2;
	ttUp=winner_column+neighbor_width/2;
	ppLow=winner_row-neighbor_height/2;
	ppUp=winner_row+neighbor_height/2;
	if(ttLow<0)
		ttLow=0;
	if(ttUp>=OutputLayerColumn)
		ttUp=OutputLayerColumn-1;
	if(ppLow<0)
		ppLow=0;
	if(ppUp>=OutputLayerRow)
		ppUp=OutputLayerRow-1;
	for(i=ppLow;i<=ppUp;i++)
	for(j=ttLow;j<=ttUp;j++)
	{
		if(!(flag[i][j]==100))
		{
/*			for(m=0;m<midianumber;m++)*/
			for(n=0;n<ndnumber;n++)
			weight[i*OutputLayerColumn+j][n]=
			weight[i*OutputLayerColumn+j][n]+
			study_efficiency*(inputMode[z][n]-weight[i*OutputLayerColumn+j][n]);
		}
		
	}
	
}
/****************************************************************/
//调整学习效率以及获胜节点的邻域大小
/****************************************************************/
void CSomnet::paraChange()
{
	
	study_efficiency=
		study_efficiency*(1.0-((double)current_iteration_num)/total_iteration_Num);
	neighbor_width=
		int(neighbor_width*(1.0-((double)current_iteration_num)/total_iteration_Num));
	neighbor_height=
		int(neighbor_height*(1.0-((double)current_iteration_num)/total_iteration_Num));
}
/*****************************************************************/
//该函数用于将所有输入模式从文件中读入，并存放到数组inputMode中；
//同时进行权值的初始化，采用随机赋值的方法；
/*****************************************************************/
void CSomnet::initialize()
{
	int i,j,k;
	for(i=0;i<OutputLayerRow;i++)
		row[i]=100;
	for(j=0;j<OutputLayerColumn;j++)
		column[j]=100;
	for(i=0;i<OutputLayerRow;i++)
	for(j=0;j<OutputLayerColumn;j++)
		flag[i][j]=0;
	//从文件中将所有输入模式读入，并存放到数组inputMode中
	FILE *pf=fopen("相关数据\\输入数据\\input.txt","a+");
	if(pf==NULL)
	{
		cout<<"Can not open input file!\n";
		exit(0);
	}
	
	for(i=0;i<layernumber;i++)
/*	for(j=0;j<midianumber;j++)*/
	for(k=0;k<ndnumber;k++)
	fscanf(pf,"%lf",&inputMode[i][k]);
	/////////////////////////////////////////////////////
	//用于测试是否能够正确读入输入模式
	char  character[26];
	for(i=0;i<26;i++)
		character[i]=(65+i);
	ofstream mode ("相关数据\\输出数据\\向量模式.txt",ios::out) ;
	for(i=0;i<layernumber;i++)
	{
		mode<<character[i]<<"\n"<<endl;
/*		for(j=0;j<midianumber;j++)*/
			for(k=0;k<ndnumber;k++)
				mode<<inputMode[i][k]<<" ";
			mode<<"\n";
		mode<<"\n\n\n";
	}
	////////////////////////////////////////////////////
	//权值初始化，采用随机赋值的方法
	for(i=0;i<OutputLayerRow;i++)
	for(j=0;j<OutputLayerColumn;j++)
	for(k=0;k<InputLayerNum;k++)
		weight[i*OutputLayerColumn+j][k]=(double(rand()%101))/100.0;
	/////////////////////////////////////////////////////
	//用于测试是否能够正确初始化权值
	ofstream quan ("相关数据\\输出数据\\初始的权值.txt",ios::out) ;
	for(i=0;i<OutputLayerRow;i++)
	for(j=0;j<OutputLayerColumn;j++)
		{
			quan<<"\n\n\n"<<"Node["<<i+1<<"]["<<j+1<<"]"<<"\n";
			for(k=0;k<InputLayerNum;k++)
			{
				if(k%5==0)
					quan<<"\n";
				quan<<setprecision(6)<<setiosflags(ios::fixed)<<weight[i*OutputLayerColumn+j][k]<<"      ";
			}
			quan<<"\n\n\n";
		}
	////////////////////////////////////////////////////
}
/*****************************************************************/
//对网络进行训练
/*****************************************************************/

void  CSomnet::Treatnet()
{
	int l,i,j,k;
	int iteration_numbers[26];
	int total_num=0;
	char  character[26];
		for(l=0;l<layernumber;l++)
	{
		iteration_numbers[l]=0;
		character[l]=(65+l);     //65的ASC码为'a',character数组中储存了26个英文字母
	}
	initialize();
	for(l=0;l<layernumber;l++)     //26是指26个英文字母
	{
		winner_row=OutputLayerRow/2;
		winner_column=OutputLayerColumn/2;
		while(current_iteration_num<total_iteration_Num)
		{
			init_distance();
			eula_distance(l);
			weight_change(l);
			if(min_distance<=error_limit)
				break;
			++current_iteration_num;
			paraChange();
		};
		iteration_numbers[l]=current_iteration_num+1;
		neighbor_width=OutputLayerColumn;
		neighbor_height=OutputLayerRow;
		study_efficiency=efficiency;
		current_iteration_num=0;
		min_distance=1000.0;
	}
	for(l=0;l<layernumber;l++)
		total_num+=iteration_numbers[l];
	ofstream iteration_num("相关数据\\输出数据\\迭代次数.txt",ios::out);
	for(l=0;l<layernumber;l++)
	{
		iteration_num<<character[l]<<" 迭代"<<iteration_numbers[l]<<"次！\n"<<endl;
		if(l==(layernumber-1))
		iteration_num<<"整个训练过程共迭代"<<total_num<<"次！\n"<<endl;
	}
	ofstream all_weight("相关数据\\输出数据\\训练后所有权值.txt",ios::out ) ;
	ofstream winner_weight("相关数据\\输出数据\\训练后胜出权值.txt",ios::out) ;
	for(i=0;i<OutputLayerRow;i++)
	for(j=0;j<OutputLayerColumn;j++)
	{
		printf("\n\n\n");
		all_weight<<"\n\n\n"<<"Node["<<i+1<<"]["<<j+1<<"]"<<"\n";
		for(k=0;k<InputLayerNum;k++)
		{
			if(k%5==0)
			{
				printf("\n");
				all_weight<<"\n";
			}
		/*	/////////////////////////////////////////////////
			if(weight[i*OutputLayerColumn+j][k]>0.9999999)
				weight[i*OutputLayerColumn+j][k]=1.0;
			if(weight[i*OutputLayerColumn+j][k]<0.0000001)
				weight[i*OutputLayerColumn+j][k]=0.0;
		*/	/////////////////////////////////////////////////
			printf("%f   ",weight[i*OutputLayerColumn+j][k]);
			all_weight<<setprecision(8)<<setiosflags(ios::fixed)<<weight[i*OutputLayerColumn+j][k]<<"      ";
		}
	}
	ofstream winner_node("相关数据\\输出数据\\获胜节点.txt",ios::out) ;
	for(i=0;i<OutputLayerRow;i++)
	for(j=0;j<OutputLayerColumn;j++)
	{
		if(flag[i][j]==100)
		{
			printf("\n\n\n");
			winner_weight<<"\n\n\n"<<"Node["<<i+1<<"]["<<j+1<<"]"<<"\n";
			for(k=0;k<InputLayerNum;k++)
			{
				if(k%5==0)
				{	
					printf("\n");
					winner_weight<<"\n";
				}
			/*	/////////////////////////////////////////////////
				if(weight[i*OutputLayerColumn+j][k]>0.9999999)
				weight[i*OutputLayerColumn+j][k]=1.0;
				if(weight[i*OutputLayerColumn+j][k]<0.0000001)
				weight[i*OutputLayerColumn+j][k]=0.0;
			*/	/////////////////////////////////////////////////
				printf("%f   ",weight[i*OutputLayerColumn+j][k]);
				winner_weight<<setprecision(8)<<setiosflags(ios::fixed)<<weight[i*OutputLayerColumn+j][k]<<"      ";
			}
			winner_node<<"Node["<<i+1<<"]["<<j+1<<"]"<<endl;
		}
		
	}
	printf("\n");
}

/************************************************************/
//利用标准数据测试训练后的网络
/************************************************************/
void CSomnet::test_netWork_1()
{
	int i,j,l,n;
	ofstream   test1("相关数据\\输出数据\\标准测试.txt",ios::out);
	char  character[26];
	for(i=0;i<26;i++)
		character[i]=(65+i);
	for(l=0;l<layernumber;l++)
	{
		for(i=0;i<OutputLayerRow;i++)
		for(j=0;j<OutputLayerColumn;j++)
		distance[i*OutputLayerColumn+j]=0.0;
		min_distance=1000;
		for(i=0;i<OutputLayerRow;i++)
		for(j=0;j<OutputLayerColumn;j++)
		{
		/*	for(m=0;m<midianumber;m++)*/
			for(n=0;n<ndnumber;n++)
				distance[i*OutputLayerColumn+j]+=(long double)
				pow(((long double)inputMode[l][n]-(long double)weight[i*OutputLayerColumn+j][n]),2);
			if(distance[i*OutputLayerColumn+j]<min_distance)
			{
				min_distance=distance[i*OutputLayerColumn+j];
				temp_row=i;
				temp_column=j;
			}
		}
		test1<<character[l]<<"'s winner is Node["<<temp_row+1<<"]["<<temp_column+1<<"]"<<endl<<endl;
	}
}
/************************************************************/
//利用非标准数据测试训练后的网络
/************************************************************/
void CSomnet::test_netWork_2()
{
	int i,j,k,l,n;
	ofstream   test2("相关数据\\输出数据\\非标准测试.txt",ios::out);
	char  character[26];
	if(inputMode!=NULL)
		delete []inputMode;
	inputMode=new double*[layernumber];
	for(i=0;i<layernumber;i++)
		*(inputMode+i)=new double[ndnumber];
	if(inputMode!=NULL)
	{
			FILE *pf1=fopen("相关数据\\输入数据\\非标准数据测试.txt","a+");
	if(pf1==NULL)
	{
		cout<<"Can not open input file!\n";
		exit(0);
	}
	for(i=0;i<layernumber;i++)
/*	for(j=0;j<midianumber;j++)*/
	for(k=0;k<ndnumber;k++)
	fscanf(pf1,"%lf",&inputMode[i][k]);
	for(i=0;i<26;i++)
		character[i]=(65+i);
// 	char  character[26];
// 	for(i=0;i<26;i++)
// 		character[i]=(65+i);
	ofstream mode1 ("相关数据\\输出数据\\非标准向量模式.txt",ios::out) ;
	for(i=0;i<layernumber;i++)
	{
		mode1<<character[i]<<"\n"<<endl;
/*		for(j=0;j<midianumber;j++)*/
			for(k=0;k<ndnumber;k++)
				mode1<<inputMode[i][k]<<" ";
			mode1<<"\n";
		mode1<<"\n\n\n";
	}
	for(l=0;l<layernumber;l++)
	{
		for(i=0;i<OutputLayerRow;i++)
		for(j=0;j<OutputLayerColumn;j++)
		distance[i*OutputLayerColumn+j]=0.0;
		min_distance=1000;
		for(i=0;i<OutputLayerRow;i++)
		for(j=0;j<OutputLayerColumn;j++)
		{
		/*	for(m=0;m<midianumber;m++)*/
			for(n=0;n<ndnumber;n++)
				distance[i*OutputLayerColumn+j]+=(long double)
				pow(((long double)inputMode[l][n]-(long double)weight[i*OutputLayerColumn+j][n]),2);
			if(distance[i*OutputLayerColumn+j]<min_distance)
			{
				min_distance=distance[i*OutputLayerColumn+j];
				temp_row=i;
				temp_column=j;
			}
		}
		test2<<character[l]<<"'s winner is Node["<<temp_row+1<<"]["<<temp_column+1<<"]"<<endl<<endl;
	}

	}

}