📄 som_algorithm.cpp
字号:
#include <fstream.h>
#include <iomanip.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define InputLayerNum 35
#define OutputLayerRow 8
#define OutputLayerColumn 12
#define total_iteration_Num 80//10000//80//100//1000
#define error_limit 0.0000000000008//0.1//0.0000000000008//0.000000000000008//0.0001
#define efficiency 0.9//0.3//0.9//0.3//0.9
int i,j,k,l,m,n;
int inputMode[26][7][5];
double weight[OutputLayerRow*OutputLayerColumn][InputLayerNum];
int current_iteration_num=0;
double study_efficiency=efficiency;
long double distance[OutputLayerRow*OutputLayerColumn];
int neighbor_width=OutputLayerColumn;
int neighbor_height=OutputLayerRow;
int row[OutputLayerRow],column[OutputLayerColumn];
int flag[OutputLayerRow][OutputLayerColumn];
int temp_row,temp_column;
int winner_row,winner_column;
long double min_distance=1000.0;
/****************************************************************/
//该函数初始化距离变量为0,初始化保存胜出节点的位置的变量
/****************************************************************/
void init_distance()
{
for(i=0;i<OutputLayerRow;i++)
for(j=0;j<OutputLayerColumn;j++)
distance[i*OutputLayerColumn+j]=0.0;
}
/****************************************************************/
//该函数用于计算欧氏距离,并找到获胜神经元
/****************************************************************/
void eula_distance()
{
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<7;m++)
for(n=0;n<5;n++)
distance[i*OutputLayerColumn+j]+=
pow((inputMode[l][m][n]-weight[i*OutputLayerColumn+j][m*5+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 weight_change()
{
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<7;m++)
for(n=0;n<5;n++)
weight[i*OutputLayerColumn+j][m*5+n]=
weight[i*OutputLayerColumn+j][m*5+n]+
study_efficiency*(inputMode[l][m][n]-weight[i*OutputLayerColumn+j][m*5+n]);
}
}
}
/****************************************************************/
//调整学习效率以及获胜节点的邻域大小
/****************************************************************/
void 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 initialize()
{
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<26;i++)
for(j=0;j<7;j++)
for(k=0;k<5;k++)
fscanf(pf,"%d",&inputMode[i][j][k]);
/////////////////////////////////////////////////////
//用于测试是否能够正确读入输入模式
char character[26];
for(i=0;i<26;i++)
character[i]=(65+i);
ofstream mode ("相关数据\\输出数据\\向量模式.txt",ios::out) ;
for(i=0;i<26;i++)
{
mode<<character[i]<<"\n"<<endl;
for(j=0;j<7;j++)
{
for(k=0;k<5;k++)
mode<<inputMode[i][j][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 main(void)
{
int iteration_numbers[26];
int total_num=0;
char character[26];
void test_netWork_1();//function declaration
void test_netWork_2();//function declaration
for(l=0;l<26;l++)
{
iteration_numbers[l]=0;
character[l]=(65+l);
}
initialize();
for(l=0;l<26;l++)
{
winner_row=OutputLayerRow/2;
winner_column=OutputLayerColumn/2;
while(current_iteration_num<total_iteration_Num)
{
init_distance();
eula_distance();
weight_change();
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<26;l++)
total_num+=iteration_numbers[l];
ofstream iteration_num("相关数据\\输出数据\\迭代次数.txt",ios::out);
for(l=0;l<26;l++)
{
iteration_num<<character[l]<<" 迭代"<<iteration_numbers[l]<<"次！\n"<<endl;
if(l==25)
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");
///////////////////////////////////////////////////
//网络测试
test_netWork_1();
test_netWork_2();
}
/************************************************************/
//利用标准数据测试训练后的网络
/************************************************************/
void test_netWork_1()
{
ofstream test1("相关数据\\输出数据\\标准测试.txt",ios::out);
char character[26];
for(i=0;i<26;i++)
character[i]=(65+i);
for(l=0;l<26;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<7;m++)
for(n=0;n<5;n++)
distance[i*OutputLayerColumn+j]+=(long double)
pow(((long double)inputMode[l][m][n]-(long double)weight[i*OutputLayerColumn+j][m*5+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 test_netWork_2()
{
ofstream test2("相关数据\\输出数据\\非标准测试.txt",ios::out);
char character[26];
FILE *pf=fopen("相关数据\\输入数据\\非标准数据测试.txt","a+");
if(pf==NULL)
{
cout<<"Can not open input file!\n";
exit(0);
}
for(i=0;i<26;i++)
for(j=0;j<7;j++)
for(k=0;k<5;k++)
fscanf(pf,"%d",&inputMode[i][j][k]);
for(i=0;i<26;i++)
character[i]=(65+i);
for(l=0;l<26;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<7;m++)
for(n=0;n<5;n++)
distance[i*OutputLayerColumn+j]+=(long double)
pow(((long double)inputMode[l][m][n]-(long double)weight[i*OutputLayerColumn+j][m*5+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;
}
}⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -