模糊c-means算法的c++实现

首先输入点的个数，维度，分类数目

我的代码FCM中主要过程如下：

1：(init_c函数)随机初始化聚类中心

2：(comp_dis函数)计算每个点到每个聚类距离 dis[i][j] 表示i点到j聚类中心的距离

3：(while(1))进入循环

4：(comp_u函数)计算隶属度矩阵u[i][j]表示i点对应j聚类中心的隶属度

5：(update_c函数)根据隶属度和每个点的位置更新聚类中心

6：(compdis函数)因为聚类中心更新了嘛，再重新计算下每个点到每个聚类中心的距离

7：(comp_obj_func函数)计算函数值差值如果小于设定值eps则进行第8步，否则进行第9步

8：(break)退出循环

9：根据每个点的隶属度情况，给每个点分类（距离哪个聚类中心近，就给谁）

注意事项：

1.如果点很少的话，可能在我的初始化聚类中心函数中会有相同的点，造成分类错误，但实际应用中，点数足够多的情况则这个概率可以忽略

2.在计算隶属度的函数中，如果一个点距离一个聚类中心足够的近，那么直接将它的隶属度设置成1，其他的为0

其他：

如果有错误和疑问欢迎探讨，望多多指教！

代码：

 #include<iostream>
 #include<cstdio>
 #include<vector>
 #include<fstream>
 #include<cmath>
 #include<ctime>
 #include<cstdlib>
 using namespace std;
 struct Mode
 {
     int x,y;
     int di;
     vector<double> datas;
 };
 typedef vector<vector<Mode> > ModeVec;
 const int N=;
 const double eps=1e-;
 const double eps_dis=1e-;

 double getDistance(Mode &m1,Mode &m2);
 void FCM(Mode *p,int n,int di,int clusternum,vector<vector<Mode> > &ans);
 void init_c(Mode *p,int n,int clusternum,Mode *c);
 void comp_dis(Mode *p,Mode *c,int n,int clusternum,double dis[][]);
 void comp_u(double dis[][],int n,int clusternum,double u[][]);
 void update_c(Mode *p,double u[][],int n,int clusternum,Mode *c);
 double comp_obj_func(double u[][],double dis[][],int n,int clusternum,int di);
 int main()
 {
     int n,dimension,clusternum;
     Mode p[N];
 //    freopen("in.txt","r",stdin);
 //    freopen("out.txt","w",stdout);
     ifstream fin("in.txt");
     ofstream fout("out.txt");
     fin>>n>>dimension>>clusternum;  //输入点的个数，维度，聚类数目
     for(int i=; i<n; i++)
     {
         p[i].di=dimension;
         for(int j=; j<dimension; j++)
             {
                 double temp;
                 fin>>temp;
                 p[i].datas.push_back(temp);
             }
     }
     vector<vector<Mode> > ans;
     FCM(p,n,dimension,clusternum,ans);  //传入数组p，有n个点，维度为dimension，结果保存在ans
     for(int i=;i<clusternum;i++)
     {
         printf("第%d类：\n",i+);
         for(int j=;j<ans[i].size();j++)
         {
             printf("(");
             for(int k=;k<dimension;k++)
             {
                 if(k==) printf("%f",ans[i][j].datas[k]);
                 else printf(",%f",ans[i][j].datas[k]);
             }
             printf(") ");
         }
         printf("\n");
     }
     return ;
 }
 double getDistance(Mode &m1,Mode &m2)
 {
     int di=m1.di;
     double ans=;
     for(int i=; i<di; i++)
         ans+=(m1.datas[i]-m2.datas[i])*(m1.datas[i]-m2.datas[i]);
     return ans;
 }
 void init_c(Mode *p,int n,int clusternum,Mode *c) //初始化聚类中心
 {
     int di=p[].di;
     srand(time(NULL));
     for(int i=;i<clusternum;i++)
         {
             c[i].di=di;
             c[i].datas.clear();
             for(int j=;j<di;j++)
                 c[i].datas.push_back();
         }
     for(int i=;i<n;i++)
         for(int j=;j<di;j++)
             for(int k=;k<clusternum;k++)
                 c[k].datas[j]+=p[i].datas[j];
     for(int i=;i<clusternum;i++)
     {
         for(int j=;j<di;j++)
         {
             int tp=rand()%n+;
             c[i].datas[j]/=tp;
         }
     }
 }
 void comp_dis(Mode *p,Mode *c,int n,int clusternum,double dis[][]) //初始化每个点和每个簇的距离
 {
     for(int i=; i<n; i++)
         for(int j=; j<clusternum; j++)
             dis[i][j]=getDistance(p[i],c[j]);
 }
 void comp_u(double dis[][],int n,int clusternum,double u[][])  //计算隶属度矩阵
 {
     for(int i=; i<n; i++)
     {
         double tp=;
         for(int j=;j<clusternum;j++)
             {
                 if(dis[i][j]<eps_dis)  //如果这个点很接近一个簇类中心，那么这个隶属度设为1，其他为0
                 {
                     for(int k=;k<clusternum;k++)
                         u[i][k]=;
                     u[i][j]=;
                     return;
                 }
                 tp+=/dis[i][j];
             }
         tp=/tp;
         for(int j=; j<clusternum; j++)
             u[i][j]=tp*(/dis[i][j]);
     }
 }
 void update_c(Mode *p,double u[][],int n,int clusternum,Mode *c)
 {
     int di=p[].di;
     for(int j=;j<clusternum;j++)
     {
         c[j].di=di;
         c[j].datas.clear();
         for(int i=;i<di;i++)
             c[j].datas.push_back();
         double tp=;
         for(int i=;i<n;i++)
         {
             for(int k=;k<di;k++)
                 c[j].datas[k]+=u[i][j]*u[i][j]*p[i].datas[k];
             tp+=u[i][j]*u[i][j];
         }
         for(int k=;k<di;k++)
             c[j].datas[k]/=tp;
     }
 }
 double comp_obj_func(double u[][],double dis[][],int n,int clusternum,int di)
 {
     double sum=;
     for(int i=;i<n;i++)
         for(int j=;j<clusternum;j++)
             sum+=u[i][j]*u[i][j]*dis[i][j];
     return sum;
 }
 void FCM(Mode *p,int n,int di,int clusternum,vector<vector<Mode> > &ans)        //in: n,d,c       time:O(c*n*d) 时间复杂度=聚类数*点数*维数
 {
     int index=;
     double sum=,psum;
     Mode c[]; //聚类中心
     double dis[N][]; //距离
     double u[N][];  //隶属度矩阵
     init_c(p,n,clusternum,c); // 初始化聚类中心  time: O(c)
     comp_dis(p,c,n,clusternum,dis); //更新距离矩阵dis
     while()
     {
         index++;
         printf("第%d次循环----------------------------------------\n",index);
         comp_u(dis,n,clusternum,u);  //计算隶属度矩阵u  time:O(n*c);
         for(int i=;i<n;i++)
         {
             printf("第%d个点的隶属值\n",i+);
             for(int j=;j<clusternum;j++)
             {
                 printf("%f ",u[i][j]);
             }
             printf("\n");
         }
         update_c(p,u,n,clusternum,c);   //更新聚类中心 time:O(c*(2*d+(n*d))) = O(c*n*d)
         comp_dis(p,c,n,clusternum,dis); //重新计算距离矩阵
         psum=sum;
         sum=comp_obj_func(u,dis,n,clusternum,di);
         printf("函数值=%f\n",sum);
         if(fabs(psum-sum)<eps)
             break;
     }
     for(int i=;i<clusternum;i++)
     {
         vector<Mode> m;
         ans.push_back(m);
     }
     for(int i=;i<n;i++)
     {
         double tp=-;
         int index=;
         for(int j=;j<clusternum;j++)
         {
             if(u[i][j]>tp)
             {
                 tp=u[i][j];
                 index=j;
             }
         }
         ans[index].push_back(p[i]);
     }
 }