kmean.cpp

神经网络的好程序

//#include "stdafx.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <iomanip.h>
#include <iostream.h>
#include <math.h>
#include <fstream.h>
#include <dos.h>
#include <conio.h>



const int   TRUE=1, FALSE=0;
const int   MAXPATTERN=14,MAXVECTDIM=2,MAXCLUSTER=4;

struct aCluster {
   double       Center[MAXVECTDIM];
   int          Member[MAXPATTERN];
   int          NumMembers;
};

class System {
private:
   double       Pattern[MAXPATTERN][MAXVECTDIM];
   aCluster     Cluster[MAXCLUSTER];
   int          NumPatterns;
   int          SizeVector;
   int          NumClusters;
   void         DistributeSamples();
   int          CalcNewClustCenters();
   double       EucNorm(int, int);
   int          FindClosestCluster(int);

public:
   void LoadPatterns();
   void InitClusters();
   void RunKMeans();
   void SaveClusters();
};

void System::LoadPatterns(){
   FILE *InFilePtr;

   int    i,j,k,tmp,Randomsequence[MAXPATTERN];
   
   double x;
if((InFilePtr = fopen("fname.txt", "r")) == NULL)
    return ;
fscanf(InFilePtr, "%d", &NumPatterns);
fscanf(InFilePtr, "%d", &SizeVector);
fscanf(InFilePtr, "%d", &NumClusters);

    srand((unsigned)time(NULL));

	for(i=0;i<NumPatterns;i++)
      Randomsequence[i]=i;
	
      
	for(i=0;i<NumPatterns;i++){
        j=rand()%NumPatterns;
        k=rand()%NumPatterns;
        tmp=Randomsequence[j];
        Randomsequence[j]=Randomsequence[k];
        Randomsequence[k]=tmp;
	  }


for (i=0; i<NumPatterns; i++) {
   for (j=0; j<SizeVector; j++) {
      fscanf(InFilePtr,"%lg",&x);
      Pattern[Randomsequence[i]][j]=x;
      }
   }
}

void System::InitClusters(){
for (int i=0; i<NumClusters; i++) {
   Cluster[i].Member[0]=i;
   for (int j=0; j<SizeVector; j++) {
      Cluster[i].Center[j]=Pattern[i][j];
      }
   }
}

void System::RunKMeans(){
  int converged=FALSE;
while (converged==FALSE) {
   DistributeSamples();
   converged=CalcNewClustCenters();
   }
}

double System::EucNorm(int p, int c){
double dist=0.0;
for(int i=0; i<SizeVector;i++){
  dist+=(Cluster[c].Center[i]-Pattern[p][i])*(Cluster[c].Center[i]-Pattern[p][i]);
   }
return dist;
}


int System::FindClosestCluster(int pat){
   int i, ClustID;
   double MinDist, d;
MinDist =9.9e+99;
ClustID=-1;
for (i=0; i<NumClusters; i++) {
   d=EucNorm(pat,i);
   if (d<MinDist) {
      MinDist=d;
      ClustID=i;
      }
   }
if (ClustID<0) {
   printf("Aaargh");
   exit(0);
   }
return ClustID;
}


void System::DistributeSamples(){
int i,pat,Clustid,MemberIndex;
for (i=0; i<NumClusters;i++){
   Cluster[i].NumMembers=0;
   }
for (pat=0; pat<NumPatterns; pat++) {
   Clustid= FindClosestCluster(pat);
   MemberIndex=Cluster[Clustid].NumMembers;
   Cluster[Clustid].Member[MemberIndex]=pat;
   Cluster[Clustid].NumMembers++;
   }
}


int  System::CalcNewClustCenters(){
   int    ConvFlag,VectID,i,j,k;
   double tmp[MAXVECTDIM];
   ConvFlag=TRUE;
for (i=0; i<NumClusters; i++) {
  for (j=0; j<SizeVector; j++)
    tmp[j]=0.0;

   for (j=0; j<Cluster[i].NumMembers; j++) {
      VectID=Cluster[i].Member[j];
      for (k=0; k<SizeVector; k++)
         tmp[k]+= Pattern[VectID][k];
            }

   double temp1=0.0;
   for (k=0; k<SizeVector; k++) {
      tmp[k]=tmp[k]/Cluster[i].NumMembers;
      temp1+=(tmp[k]-Cluster[i].Center[k])*(tmp[k]-Cluster[i].Center[k]);
      }
   temp1=sqrt(temp1);

   for (k=0; k<SizeVector; k++)
        Cluster[i].Center[k]=tmp[k];
    
   if (temp1>0.0000001)
       ConvFlag=FALSE;
   }
return ConvFlag;
}


void System::SaveClusters(){
 
  int i,j,k,VectID; 
	ofstream fout;
    fout.open("123.txt",ios::app|ios::out);

  for(i=0;i<NumClusters;i++)
    {
     fout<<endl;
/* 
//     fout<<setw(11)<<setiosflags(ios::right)<<"Center:  ";

//     fout<<setw(7)<<setiosflags(ios::right)<<Cluster[i].Center[0];

//	 for (j=1;j<SizeVector;j++)
//       fout<<setw(12)<<setiosflags(ios::right)<<Cluster[i].Center[j];
//     fout<<endl;
*/
     fout<<setw(11)<<setiosflags(ios::right)<<"Pattern:  ";

      VectID=Cluster[i].Member[0];
      fout<<setw(7)<<setiosflags(ios::right)<<Pattern[VectID][0];
     
	  for (k=1; k<SizeVector; k++)
        fout<<setw(12)<<setiosflags(ios::right)<<Pattern[VectID][k];
      fout<<endl;

	 for (j=1; j<Cluster[i].NumMembers; j++) {
      VectID=Cluster[i].Member[j];

      fout<<setw(18)<<setiosflags(ios::right)<<Pattern[VectID][0];
     
	  for (k=1; k<SizeVector; k++)
        fout<<setw(12)<<setiosflags(ios::right)<<Pattern[VectID][k];
      fout<<endl;
	}
    
   	  double x4=0.0;

	  for (j=0; j<Cluster[i].NumMembers; j++){
        VectID=Cluster[i].Member[j];
	
		for (k=0; k<SizeVector; k++)
          x4+=(Pattern[VectID][k]-Cluster[i].Center[k])
			  *(Pattern[VectID][k]-Cluster[i].Center[k]); 
	  }
/*
//	    fout<<setw(10)<<setiosflags(ios::right)<<"Radii:";		
//	    fout<<setw(8)<<setiosflags(ios::right)<<x4/Cluster[i].NumMembers<<endl;		

  */
  
 
     fout<<setw(11)<<setiosflags(ios::right)<<"Center:  ";

     fout<<setw(7)<<setiosflags(ios::right)<<Cluster[i].Center[0];

	 for (j=1;j<SizeVector;j++)
       fout<<setw(12)<<setiosflags(ios::right)<<Cluster[i].Center[j];
     fout<<endl;
	  
	  
	  
//	  fout<<setw(10)<<setiosflags(ios::right)<<"Clu.Num:";		
//	    fout<<setw(8)<<setiosflags(ios::right)<<Cluster[i].NumMembers<<endl;		

  
  
  }

      fout<<"///////////////////////////"<<endl;
      fout.close();
}


void main(void) {

   System kmeans;
   kmeans.LoadPatterns();
   kmeans.InitClusters();
   kmeans.RunKMeans();
   kmeans.SaveClusters();
}