2. 程式人生 > >模糊C均值聚類(FCM)演算法

模糊C均值聚類(FCM)演算法

阿新 • • 發佈：2019-02-19

本程式碼演算法用例為鳶尾花資料集合；

IOSDATA演算法實現步驟，在很多資料和論壇中都有詳細的介紹，這裡就不對演算法步驟進行陳述了。

就我程式碼中，我對下面幾個控制引數的理解：

初始聚類數：初始類聚中心，跟聚類聚中心劃分簇。

期望得到的聚類數：這個數並不是最終得到的類聚數目，可以理解為我們人為的預估可能得到的類聚數，最後的結果不一定與這個數相等。

最大迭代次數：控制程式的迭代次數，根據樣本數量大小設定，本程式碼中的最大迭代次數設定為10，但迭代到4步左右就已經類聚完成了。

其他的一些控制引數看註解或一些資料便知道其作用，這裡就不做多餘介紹。

建議先將K-MEAN聚類演算法看懂，再看IOSDATA聚類演算法，程式理解就容易多。K-MEAN演算法的程式碼和實現步驟在我之前的部落格中也有。

c語言程式碼如下：

（程式碼並不是很完美，當類聚得到的數目過少（本例為<3時）時會出現錯誤，本程式碼僅供學習參考）

#include "stdio.h"
#include "stdlib.h"
#include "time.h"
#include "math.h"
#include "vector"
using namespace std;


#define alpha 0.5   //分裂比
#define dimNum 3   //維數為3
#define cNum 8  //初始類數
#define expectNum 4  //預期成類數
#define minNum 3     //小於此數則不能成類
#define splitVar 1.2  //大於此數分裂
#define connectVar 0.3  //小於此數合併
#define connectNum 2   //每次迭代允許合併的最大數
#define iterNum 10  //迭代次數為10




typedef vector<double> doubleVector;
typedef vector<doubleVector> clusterVector;


void ISODATA(vector<doubleVector> srcInf);  //開始引擎
vector<doubleVector> getInf();  //獲取檔案資料
int getClusterNum(vector<doubleVector> mCenter, doubleVector srcInf); //歸類
double getEUCdis(doubleVector t1, doubleVector t2);  //計算歐式距離
doubleVector get_wMean(clusterVector cluster);  //計算均值向量
doubleVector averageDist(doubleVector mCenter, clusterVector cluster); //計算Wi中所有樣本距其相應聚類中心的平均距離
doubleVector allAvgDist(vector<doubleVector> avgDis); //計算所以樣本距其相應的聚類中心的平均值
doubleVector getDeviation(doubleVector mCenter, clusterVector cluster); //計算沒一聚類的標準偏差
double getMaxDev(doubleVector Dev);  //獲取最大標準偏差
doubleVector clusterSplit(doubleVector wMean, double sigma);  //進行分裂
doubleVector eachCenterDist(doubleVector t1, doubleVector t2, int i, int j);  //計算聚類中心兩兩間的距離
vector<doubleVector> distSort(vector<doubleVector> eachDist);   //按距離進行排序
vector<doubleVector> Union(vector<doubleVector> mCenter, vector<doubleVector> sortDist); //進行合併
void Output(vector<clusterVector> cluster);  //結果輸出


//主函式
void main()
{
vector<doubleVector> srcInf;
srcInf = getInf();
ISODATA(srcInf);
}




//迭代開始引擎
void ISODATA(vector<doubleVector> srcInf)
{
int c;
int i, j;
int iter=1;
int lable;
vector<doubleVector> mCenter;
vector<clusterVector> cluster;
vector<doubleVector> wMean;   //均值向量
vector<doubleVector> avgDist;
doubleVector all_AvgDis;
vector<doubleVector> devVal;  //標準偏差值
vector<doubleVector> eachDist;  //兩兩聚類中心距離
vector<doubleVector> eachDistSort;  //兩兩聚類中心距離
doubleVector devMax;   //最大偏差值
double sigma;


start:
printf("聚類開始:\n");




//初始化類聚中心
step1:   
srand(time(NULL));
int chooseNum;
if(mCenter.empty()==NULL)
mCenter.clear();


mCenter.resize(cNum);
for(i=0; i<cNum; i++)
{
chooseNum = rand()%(int)(srcInf.size()/cNum)+i*(srcInf.size()/cNum);
for(j=0; j<dimNum; j++)
mCenter[i].push_back(srcInf[chooseNum][j]);
}




//根據距離歸類
step2:  
if(cluster.empty()==NULL)
cluster.clear();


cluster.resize(2*cNum);
for(i=0; i<srcInf.size(); i++)
{
lable = getClusterNum(mCenter, srcInf[i]);
cluster[lable].push_back(srcInf[i]);
}




//捨棄過小的類
step3:
for(i=0; i<cluster.size(); )
{
if(cluster[i].size()<minNum)
{
cluster.erase(cluster.begin()+i);
if(i<mCenter.size())
mCenter.erase(mCenter.begin()+i);
}

else
i++;
}
c = mCenter.size();




//更新均值向量
step4:  
if(wMean.empty()==NULL)
wMean.clear();


for(i=0; i<cluster.size(); i++)
wMean.push_back(get_wMean(cluster[i]));



//獲取各平均距離
step5:
if(avgDist.empty()==NULL)
avgDist.clear();


for(i=0; i<cluster.size(); i++)   //計算Wi中所有樣本距其相應聚類中心的平均距離
avgDist.push_back(averageDist(mCenter[i], cluster[i]));  


all_AvgDis = allAvgDist(avgDist);  //計算所以樣本距其相應的聚類中心的平均值




//判斷分裂、合併及迭代的運算步驟
step7:
if(iter==iterNum)   //步驟(1)
{

//connectNum = 0;
goto step11;
}


if(c<=expectNum/2)//步驟(2)
goto step8;


if(iter%2==0 || c>=2*expectNum)//步驟(3)
goto step11;




//計算標準偏差
step8:
if(devVal.empty()==NULL)
devVal.clear();


for(i=0; i<mCenter.size(); i++)   //計算標準偏差
devVal.push_back(getDeviation(mCenter[i], cluster[i]));






//計算標準偏差中偏差最大值
step9:
if(devMax.empty()==NULL)
devMax.clear();


for(i=0; i<devVal.size(); i++)    //計算標準偏差中偏差最大值
devMax.push_back(getMaxDev(devVal[i]));






//進行分裂
step10:
for(i=0; i<devMax.size(); i++)
{
if((devMax[i]>splitVar && cluster[i].size()>2*minNum) || c<=expectNum/2)
{
sigma = alpha*devMax[i];
mCenter.push_back(clusterSplit(wMean[i], sigma));
mCenter.push_back(clusterSplit(wMean[i], -sigma));
mCenter.erase(mCenter.begin()+i);
}
}
c = mCenter.size();




//計算兩兩聚類間的距離
step11:
if(eachDist.empty()==NULL)
eachDist.clear();


for(i=0; i<mCenter.size()-1; i++)
for(j=i+1; j<mCenter.size(); j++)
{
eachDist.push_back(eachCenterDist(mCenter[i], mCenter[j], i, j));

}






//對距離進行排序
step12:
eachDistSort = distSort(eachDist);




//進行合併
step13:
mCenter = Union(mCenter, eachDistSort);
c = mCenter.size();




step14:
if(iter==iterNum)
{
printf("類聚結果為：\n");
Output(cluster);
system("pause");
return;
}


else
{
iter++;
goto step2;
}


}






//獲取檔案資料
vector<doubleVector> getInf()
{
int i=1;
vector<doubleVector> dst;
doubleVector temp;
double num;

FILE *fp;

fp = fopen("Inf.txt", "r");

if(fp == NULL)
printf("Open file error!\n");

//讀取檔案的資料
while(fscanf(fp, "%lf", &num)!=EOF)
{
temp.push_back(num);
if(i%3==0)
{
dst.push_back(temp);
temp.clear();
}
i++;
}

fclose(fp);

return dst;
}




//計算歐式距離
double getEUCdis(doubleVector t1, doubleVector t2)
{
double distance=0;
int i;


for(i=0; i<dimNum; i++)
distance += (t1[i]-t2[i])*(t1[i]-t2[i]);


return sqrtf(distance);
}


//根據初始中心進行歸類
int getClusterNum(vector<doubleVector> mCenter, doubleVector srcInf)
{
double Dis;
double minDis = getEUCdis(mCenter[0], srcInf);
int i, lable=0;


for(i=1; i<mCenter.size(); i++)
{
Dis = getEUCdis(mCenter[i], srcInf);
if(Dis<minDis)
{
minDis = Dis;
lable = i;
}
}


return lable;
}




//計算均值向量
doubleVector get_wMean(clusterVector cluster)
{
doubleVector wMean;
double temp[dimNum];
int i, j;


for(i=0; i<dimNum; i++)
temp[i] = 0;


for(i=0; i<cluster.size(); i++)
for(j=0; j<dimNum; j++)
temp[j] += cluster[i][j];


for(i=0; i<dimNum; i++)
temp[i] = temp[i]/cluster.size();


wMean.clear();
for(i=0; i<dimNum; i++)
wMean.push_back(temp[i]);


return wMean;
}




//計算類聚中心m[i]的平均距離
doubleVector averageDist(doubleVector mCenter, clusterVector cluster)
{
 int i, j;
 doubleVector avgDist;
double temp[dimNum]={0};


for(i=0; i<cluster.size(); i++)
for(j=0; j<dimNum; j++)
temp[j] += cluster[i][j];


for(i=0; i<dimNum; i++)
temp[i] /= cluster.size();


avgDist.clear();
for(i=0; i<dimNum; i++)
avgDist.push_back(temp[i]);


return avgDist;


}




//計算所以樣本距其相應的聚類中心的平均值
doubleVector allAvgDist(vector<doubleVector> avgDis)
{
int i, j;
doubleVector allAvg;
double temp[dimNum]={0};


for(i=0; i<avgDis.size(); i++)
for(j=0; j<dimNum; j++)
temp[j] += (i+1)*avgDis[i][j];


for(i=0; i<dimNum; i++)
temp[i] /= avgDis.size();


allAvg.clear();
for(i=0; i<dimNum; i++)
allAvg.push_back(temp[i]);


return allAvg;
}




//計算每一個聚類的標準偏差
doubleVector getDeviation(doubleVector mCenter, clusterVector cluster)
{
doubleVector dst;
int i, j;
double temp[dimNum]={0};


for(i=0; i<cluster.size(); i++)
for(j=0; j<dimNum; j++)
temp[j] += (cluster[i][j]-mCenter[j])*(cluster[i][j]-mCenter[j]);


dst.clear();
for(i=0; i<dimNum; i++)
{
temp[i] /= cluster.size();
temp[i] = sqrtf(temp[i]);
dst.push_back(temp[i]);
}


return dst;


}




//獲取最大標準偏差
double getMaxDev(doubleVector Dev)
{
int i;
double max = Dev[0];


for(i=1; i<dimNum; i++)
if(max<Dev[i])
max = Dev[i];


return max;
}




//進行分裂
doubleVector clusterSplit(doubleVector wMean, double sigma)
{
int i;
doubleVector newMean;
double temp;


newMean.clear();
for(i=0; i<dimNum; i++)
{
temp = wMean[i]+sigma;
newMean.push_back(temp);
}


return newMean;
}




//計算聚類中心兩兩間的距離
doubleVector eachCenterDist(doubleVector t1, doubleVector t2, int x, int y)
{
int i;
doubleVector dist;


dist.clear();
for(i=0; i<dimNum; i++)
dist.push_back(fabs(t1[i]-t2[i]));


dist.push_back(x);
dist.push_back(y);


return dist;
}




//按距離進行排序
vector<doubleVector> distSort(vector<doubleVector> eachDist)
{
int i, j, l;
vector<doubleVector> dst;
doubleVector maxEachDist;
double temp;
doubleVector tempVet;
double min;


dst = eachDist;
//尋找每組中最大的距離
maxEachDist.clear();
for(i=0; i<eachDist.size(); i++)
maxEachDist.push_back(getMaxDev(eachDist[i]));


//排序
for(i=0; i<maxEachDist.size(); i++)
{
l=i;
min = maxEachDist[i]; 
for(j=i+1; j<maxEachDist.size(); j++)
if(min>maxEachDist[j])
{
min = maxEachDist[j];
l = j;
}


temp = maxEachDist[i];
maxEachDist[i] = maxEachDist[l];
maxEachDist[l] = temp;


tempVet = dst[i];
dst[i] = dst[l];
dst[l] = tempVet;
}


return dst;
}




//進行合併
vector<doubleVector> Union(vector<doubleVector> mCenter, vector<doubleVector> sortDist)
{
int i[connectNum], j[connectNum];
int m, n, delNum=0;
vector<doubleVector> newCenter;
vector<int> del;
doubleVector temp;


newCenter = mCenter;


//可聯合數量
for(m=0; m<connectNum; m++)
for(n=0; n<dimNum; n++)
if(sortDist[m][n]<connectVar)
{
delNum++;
break;
}


//進行聯合
for(m=0; m<delNum; m++)
{
i[m] = sortDist[m][dimNum];
j[m] = sortDist[m][dimNum+1];


for(n=0; n<dimNum; n++)
temp.push_back((i[m]*mCenter[i[m]][n]+j[m]*mCenter[j[m]][n])/(i[m]+j[m]));


newCenter.push_back(temp);
}


//避免重複刪除
for(m=0; m<delNum; m++)
del.push_back(i[m]);

for(n=0; n<delNum; n++)
{
if(del[n]==j[n])
continue;
else
del.push_back(j[n]);
}



 for(m=0; m<del.size(); m++)
 newCenter[del[m]].clear();


for(m=0; m<newCenter.size(); )
{
if(newCenter[m].empty())
newCenter.erase(newCenter.begin()+m);
else
m++;
}

return newCenter;
}




//結果輸出
void Output(vector<clusterVector> cluster)
{
int i, j, k;


for(i=0; i<cluster.size(); i++)
{
printf("\n類聚%d :\n", i+1);
for(j=0; j<cluster[i].size(); j++)
printf("%lf  %lf  %lf\n", cluster[i][j][0], cluster[i][j][1], cluster[i][j][2]);
}
}

相關推薦

模糊C均值聚類(FCM)演算法

本程式碼演算法用例為鳶尾花資料集合；IOSDATA演算法實現步驟，在很多資料和論壇中都有詳細的介紹，這裡就不對演算法步驟進行陳述了。就我程式碼中，我對下面幾個控制引數的理解：初始聚類數：初始類聚中心，跟聚類聚中心劃分簇。期望得到的聚類數：這個數並不是最終得到的類聚數目，可以理

FCM 模糊C均值聚類演算法

首先FCM在影象分割領域有很多應用，FCM演算法我覺得主要是兩個部分，一個是模糊理論，一個是C/Kmean演算法，這兩者在數學家手中完美的結合。 下面切入整體，我也是為了溫故才寫的這篇部落格，如有錯誤或者瑕疵的地方歡迎指出。話說有一個集合，甭管是啥，但是如果你是影象分割的話

模糊C均值聚類演算法及實現

模糊C均值聚類演算法的實現 研究背景 https://blog.csdn.net/liu_xiao_cheng/article/details/50471981    聚類分析是多元統計分析的一種，也是無監督模式識別的一個重要分支，在模式分類 影象處理和模糊

機器學習演算法原理總結系列---演算法基礎之(13)模糊C均值聚類（Fuzzy C-means Clustering）

筆者在韓國Chonnam National University攻讀碩士學位，FCM演算法是professer Lim在這學期主要授課的內容，他說他剛發一篇FCM結合遺傳演算法還有各種腦電訊號處理，搭建分析AD病人的EEG訊號的計算智慧模型。反正就是各種難

模糊C均值聚類演算法

The Algorithm Fuzzy c-means (FCM) is a method of clustering which allows one piece of data to belong to two or more clusters. This method

模糊C均值聚類演算法的實現

 模糊C均值聚類演算法的實現 研究背景 聚類分析是多元統計分析的一種，也是無監督模式識別的一個重要分支，在模式分類 影象處理和模糊規則處理等眾多領域中獲得最廣泛的應用。它把一個沒有類別標記的樣本按照某種準則劃分為若干子集，使相似的樣本

模糊C均值聚類以及C實現

1. 基本介紹     同K均值類似，FCM演算法也是一種基於劃分的聚類演算法，它的思想就是使得被劃分到同一簇的物件之間相似度最大，而不同簇之間的相似度最小。     模糊C均值是普通C均值聚類演算法的改進，普通C均值對資料進行硬性劃分，一個樣本一定明確的屬於某一類，FC

k-means(k均值聚類)演算法介紹及實現(c++)

基本介紹： k-means 演算法接受輸入量 k ；然後將n個數據物件劃分為 k個聚類以便使得所獲得的聚類滿足：同一聚類中的物件相似度較高；而不同聚類中的物件相似度較小。聚類相似度是利用各聚類中物件的均值所獲得一個“中心物件”（引力中心）來進行計算的。 工作過程： 　　k

機器學習實戰（Machine Learning in Action）學習筆記————06.k-均值聚類演算法（kMeans）學習筆記

機器學習實戰（Machine Learning in Action）學習筆記————06.k-均值聚類演算法（kMeans）學習筆記關鍵字：k-均值、kMeans、聚類、非監督學習作者：米倉山下時間：2018-11-3機器學習實戰（Machine Learning in Action,@author: Pet

機器學習——K-均值聚類（K-means）演算法

本文轉載自：https://www.cnblogs.com/ybjourney/p/4714870.html 一 K-均值聚類（K-means）概述 聚類 “類”指的是具有相似性的集合。聚類是指將資料集劃分為若干類，使得類內之間的資料最為相似，各類之間的資料相

在Ignite中使用k-均值聚類演算法

在本系列前面的文章中，簡單介紹了一下Ignite的k-最近鄰(k-NN)分類演算法，下面會嘗試另一個機器學習演算法，即使用泰坦尼克資料集介紹k-均值聚類演算法。正好，Kaggle提供了CSV格式的資料集，而要分析的是兩個分類：即乘客是否倖存。 為了將資料轉換為Ignite支援的格式，前期需要做一些清理和格式化

k-均值 聚類演算法

  首先初始化k個點作為質心，遍歷資料集，把每一個數據點分配到距離最近的質心，把這個質心下的所有點的均值作為新的質心，迭代更新。   度量聚類效果的指標：SSE( sum of squared error)誤差平方和 改進演算法：二分-k-均值演算法（克服k-均值區

機器學習實戰———k均值聚類 演算法

問題：關於第九章list（）新增的問題 fltLine = list(map(float,curLine)) fltLine = map(float,curLine) 二者的區別在於 加list（）輸出為數 [1.658985, 4.285136] [-3.453

《機器學習實戰》二分-kMeans演算法（二分K均值聚類）

首先二分-K均值是為了解決k-均值的使用者自定義輸入簇值k所延伸出來的自己判斷k數目，其基本思路是： 為了得到k個簇，將所有點的集合分裂成兩個簇，從這些簇中選取一個繼續分裂，如此下去，直到產生k個簇。 虛擬碼： 初始化簇表，使之包含由所有的點組成的簇。 repeat   &n

機器學習實戰---讀書筆記： 第10章 利用K均值聚類演算法對未標註資料分組---1

#!/usr/bin/env python # encoding: utf-8 import os from matplotlib import pyplot as plt from numpy import * ''' 讀書筆記之--<<機器學習實戰>>--第10章_

機器學習 聚類(Clustering)____K-均值聚類演算法(K-means Clustering) 層次聚類(Hierarchical Clustering)

____tz_zs學習筆記聚類(Clustering) 顧名思義，就是將相似樣本聚合在一起，屬於機器學習中的非監督學習 (unsupervised learning) 問題。聚類的目標是找到相近的資料點，並將相近的資料點聚合在一起。實現聚類的演算法主要有：1.K-均值聚類演算

《機器學習實戰》KMeans均值聚類演算法

一、引言聚類是一種無監督學習，對一些沒有標籤的資料進行分類。二、K均值聚類演算法2.1 演算法過程:隨機確定K個初始點為質心（簇個數k由使用者給定），計算資料集中每個點到每個質心的距離本次採用的是歐式距離，然後將資料集中的每個點尋找距其最近的質心，分配到對應的簇中完成後，每個

K-means(K-均值)聚類演算法

劃分方法 聚類分析最簡單、最基本的版本是劃分，它把物件組織成多個互斥的簇。這一方法，要求每個物件必須/恰好屬於每一個簇。（事實上，我們應該知道，這個要求是很不合理的，因為它忽略了離群點，假若把噪聲資料強行劃分在簇裡，那勢必會降低聚類的準確率，所以為了改進這一點

K-means均值聚類演算法的原理與實現

轉自：http://blog.csdn.net/xiaolewennofollow/article/details/45541159 K-均值聚類演算法的原理與實現 聚類是一種無監督的學習，它將相似的物件歸到同一個簇中，聚類方法幾乎可以應用於所有物件，簇內的物件越相似，聚類的效果越好，本文主要介紹K-均值聚

【opencv學習之四十三】K均值聚類演算法

K均值聚類演算法，在opencv中通過kmeans()函式實現；k均值通俗講：就是從一堆樣本中，隨便挑出幾個，比如3個吧，然後用樣本中的和這挑出來的比較，比較後排序，誰和挑出的那個接近就把他劃到那個類裡，比如樣A和挑1、挑2、挑3中，挑2最接近，則把樣A劃到挑2裡，當然還沒完