som_.cpp

som 神经网络 分类小例 （将八组4维数据聚类）

#include <stdio.h>
#include <math.h>
#include <conio.h>
#include <stdlib.h>
#define  maxtimes 100
#define  M        6
#define  N        5
#define  n        4
/*------神经元数据结构-------*/ 
typedef struct 
{   float   wedgit[n];
	float   output;
	float   dis;
} netiterm;

 netiterm kernon[M][N];

/*---------输入向量点乘权值向量函数-------*/ 
float add(float *in,float *w,int victlength)
{ int i;
  float out;
  for (i=0;i<victlength;i++)
  out+= in[i]*w[i];
  return(out);
} 
/*-------标准化------*/ 
void changeto(float *c,int victlength)
{ int i;
  float s=0.0;
  for (i=0;i<victlength;i++)
    s+=c[i]*c[i];
    s=sqrt(s);
  for(i=0;i<victlength;i++)
  c[i]=c[i]/s;
}

void changeto1(float *c,int victlength)
{int i;
 float min=c[0],max=c[0];
 for(i=0;i<victlength;i++)
 if (min>c[i]) min=c[i];
 else if (max < c[i])  max =c[i];
 
 for(i=0;i<victlength;i++)
 c[i]=(c[i]-min)/(max-min);
}


/*------计算欧氏距离-----*/
float distance(float* a,float* b ,int s)
{ int i;
  float d;
  for(i=0;i<s;i++)
  d+=(a[i]-b[i])*(a[i]-b[i]);
  d=sqrt(d);
  return(d);
}

/*--------训练网络 ----------*/ 
int* nettrain(float input[8][n],int patern) 
{
 int i,j,p,q,d0,d,f1,f2,t=0,flag=1,*winner;
 float hc=0.5,hn0=0.4,hn,max=0,min,s;
 winner=(int *)malloc(2*patern);
 for(i=0;i<patern;i++)
 winner[i]=0;

 d0=M/6;
 hn=hn0; d=d0;
 //初始权值 
 for(i=0;i<M;i++)
  for(j=0;j<N;j++)
   for(p=0;p<n;p++)
   kernon[i][j].wedgit[p]=(float)(rand() % 1001) * 0.001f;

   
  while(t++<maxtimes)   
{
  for(q=0;q<patern;q++)
 {min=999;

  //标准化输入
  //changeto(input[q],n); 

   //标准化权值
  //for(i=0;i<M;i++)
   //for(j=0;j<N;j++)
   //changeto(kernon[i][j].wedgit,n);  
   
  //计算欧氏距离
   for(i=0;i<M;i++)
   for(j=0;j<N;j++)
   kernon[i][j].dis=distance(input[q],kernon[i][j].wedgit,n); 
  
  //找出欧氏距离最小神经元
  for(i=0;i<M;i++)
   for(j=0;j<N;j++)
   if(min>kernon[i][j].dis)
    { min=kernon[i][j].dis;
      winner[q]= (i+1)*(j+1);
      f1=i;f2=j;
     }   
   
 //调整权值 
 for(i=(f1-d)<0?0:(f1-d);i<((f1+d)>M?M:(f1+d));i++)
  for(j=(f2-d)<0?0:(f2-d);j<((f2+d)>N?N:(f2+d));j++)
   for(p=0;p<n;p++)
    kernon[i][j].wedgit[p]=kernon[i][j].wedgit[p]+hn*(input[q][p]-kernon[i][j].wedgit[p]);
// for(p=0;p<n;p++)
//{kernon[f1][f2].wedgit[p]=kernon[f1][f2].wedgit[p]+hc*(input[q][p]-kernon[f1][f2].wedgit[p]);
//if(kernon[f1][f2].wedgit[p]!=input[p]) flag=0;}
//if(flag) break;
 
 }// for end

 hn=hn0*(1-t/maxtimes);
 d =d *(1-t/maxtimes);
  }
 return winner;
}
 
 
int  *simulate(float input[8][n],int partern) 
{ 
 int i,j,p;
 int *winner;
 float max;
	
  winner=(int *)malloc(2*partern);
	
  for(p=0;p<partern;p++)
  {max=0;
  //计算每个神经元输出 
  for(i=0;i<M;i++)
   for(j=0;j<N;j++)
   kernon[i][j].output= add(input[p],kernon[i][j].wedgit,n);
 
  //找到最大输出元素 
   for(i=0;i<M;i++)
    for(j=0;j<N;j++)
    if(max<kernon[i][j].output)
    {max=kernon[i][j].output;
     winner[p]= (i+1)*(j+1);
     }
   }
return winner;	
}
 
 
 
int main()
{
 int *kind,*kind2,i,j;   
 float input[8][4]={{0.4,0.3,0.1,0.4},
                    {0.5,0.3,0.2,0.1},
                    {65,2,1,2},
                    {65,2,1,2},
                    {16,17,7,8},                              
                    {16,13,4,7},
                    {4,5,6,8},
                    {4,5,6,8}};   

  kind=nettrain(input,8); 
  kind2= simulate(input,8);
  
  for(i=0;i<8;i++) 
  { printf("第%d个样本:",i);
   for(j=0;j<4;j++)
   printf("%2.1f\t",input[i][j]);
   printf("\n");} 
  
  for(i=0;i<8;i++)
  printf("第%d个样本属于第%d类\n",i,kind[i]);
  while(1);
  return 0;
}