K-Means Clustering 簡介

K-Means Clustering(k均值聚類算法) 屬於無監督學習算法, 它可以發現 k 個不同的簇, 每個簇的質心採用簇中所含值的均值計算而成.

優點	容易實現
缺點	可能收斂到局部最小值, 在大規模數據集上收斂較慢
適用數據類型	數值型

基礎概念
1. 無監督學習
目標變量不存在, 即不區分訓練集與測試集, 沒有訓練階段.
2. SSE
Sum of Squared Error(SSE, 誤差平方和), 用於度量聚類效果的指標, 它是樣本點到其所屬簇的質心的距離的平方和, SSE 值越小表示數據點越接近它們的質心, 聚類效果也越好.

算法描述
1. K-Means
(1). 隨機選取K個質心
(2). 遍歷每個樣本點, 與距離其最近的質心作爲一簇, 最後共生成 K 個簇 (代碼 47-60 行)
(3). 重新計算K個質心, 即將每個簇中所有樣本點求均值, 得到新的質心 (代碼 66-68 行)
(4). 重複(2)->(3), 若 (2) 進行完後, 每個樣本點所屬的簇都沒有發生改變, 則聚類完成
(5). 當聚類完成後, 應該能得到K個質心的座標, 各個樣本點所屬的簇及其與質心的誤差(距離)
2. 二分 K-Means
二分 K-Means 算法是爲了解決 K-Means 會碰到的收斂到局部最小值的情況而提出的.
(1). 初始化時, 將所有樣本點作爲一個簇 (代碼 82-83 行)
(2). 每一步劃分都增加一個簇, 直至簇的總數爲 K 爲止
(3). 每次劃分時, 都嘗試對當前每個簇進行 K=2 的 K-Means 劃分, 劃分完後, 將此簇劃分出來的 2 個簇的 SSE 與其他簇的 SSE 相加; 取總 SSE 最小的劃分爲當前劃分 (代碼 95 - 108 行)

算法流程圖
1. K-Means

2. 二分 K-Means

代碼

# -*- coding: utf-8 -* 
from numpy import *

# 加載數據, 最後一列爲其實際所屬類別
# 數據由 tab 分隔
def loadDataSet(fileName):      
    dataMat = []                
    fr = open(fileName)
    for line in fr.readlines():
        curLine = line.strip().split('\t')
        fltLine = map(float,curLine) # map all elements to float()
        dataMat.append(fltLine)
    return dataMat


# 計算兩個向量的歐氏距離
def distEclud(vecA, vecB):
    return sqrt(sum(power(vecA - vecB, 2))) #la.norm(vecA-vecB)


# 基於數據集構建 K 個隨機質心, 這些質心必須在數據集的範圍內
def randCent(dataSet, k):
    n = shape(dataSet)[1]
    centroids = mat(zeros((k,n)))   # 存放隨機質心, k 行 n 列
    for j in range(n):  
        minJ = min(dataSet[:,j])    # 第 j 列的最小值
        rangeJ = float(max(dataSet[:,j]) - minJ)    # 第 j 列的範圍
        centroids[:,j] = mat(minJ + rangeJ * random.rand(k,1))
    return centroids


# kMeans 算法
# 1. 參數 k 表示需要劃分的簇的大小
# 2. 返回值爲分好類後的質心 及 各個樣本點所屬簇和樣本點到質心的距離
def kMeans(dataSet, k, distMeas=distEclud, createCent=randCent):
    m = shape(dataSet)[0]            # 數據集行數, 即樣本數

    # 存放簇分配結果, 第 1 列爲簇索引, 第二列爲存儲誤差(當前點到質心的距離)
    # 誤差可以用來評價聚類的效果
    clusterAssment = mat(zeros((m,2)))

    # 初始取 k 個隨機質心
    centroids = createCent(dataSet, k)
    clusterChanged = True

    # 如果遍歷所有樣本點後, 它們所屬簇都未發生變化, 則說明分類完成
    while clusterChanged:
        clusterChanged = False
        # 對每個樣本, 將其 assign 到與它距離最近的質心
        for i in range(m):
            minDist = inf; 
            minIndex = -1
            for j in range(k):
                distJI = distMeas(centroids[j,:],dataSet[i,:])
                if distJI < minDist:
                    minDist = distJI; 
                    minIndex = j

            # 樣本點所屬簇發生了變化
            if clusterAssment[i,0] != minIndex: 
                clusterChanged = True
            clusterAssment[i,:] = minIndex,minDist**2

        # 重新計算質心
        # 以每個簇中所有樣本點的均值爲新質心
        for cent in range(k):
            ptsInClust = dataSet[nonzero(clusterAssment[:,0].A==cent)[0]]
            centroids[cent,:] = mean(ptsInClust, axis=0) # 求均值

    return centroids, clusterAssment


# 二分 kMeans 算法
# 1. 參數 k 表示需要劃分的簇的大小, distMeas 爲計算兩點間距離(誤差)的函數
def biKmeans(dataSet, k, distMeas=distEclud):
    m = shape(dataSet)[0]

    # 存儲每個點分配到的簇及誤差
    clusterAssment = mat(zeros((m,2)))

    # 初始取所有點的均值作爲質心
    centroid0 = mean(dataSet, axis=0).tolist()[0]
    centList =[centroid0]   # 初始只有一個質心

    # 遍歷所有的樣本點, 計算這些樣本點到質心的距離(誤差)
    for j in range(m):      
        clusterAssment[j,1] = distMeas(mat(centroid0), dataSet[j,:])**2

    # 每個循環都會增加一個簇, 直至 k 個簇   
    while (len(centList) < k):
        lowestSSE = inf

        # 遍歷所有已分的簇, 對每個簇中的數據採用 k 爲 2 的 kMeans 分成兩簇
        # 取劃分後誤差(SSE)最小的劃分作爲下一步的劃分
        for i in range(len(centList)):
            # 取當前簇中的所有點
            ptsInCurrCluster = dataSet[nonzero(clusterAssment[:,0].A==i)[0],:]
            # 按 k=2 進行 kMeans 劃分
            centroidMat, splitClustAss = kMeans(ptsInCurrCluster, 2, distMeas)
            # 計算誤差
            sseSplit = sum(splitClustAss[:,1])
            sseNotSplit = sum(clusterAssment[nonzero(clusterAssment[:,0].A!=i)[0],1])
            # 取最小誤差
            if (sseSplit + sseNotSplit) < lowestSSE:
                bestCentToSplit = i
                bestNewCents = centroidMat
                bestClustAss = splitClustAss.copy()
                lowestSSE = sseSplit + sseNotSplit

        # 保存最佳劃分的質心
        bestClustAss[nonzero(bestClustAss[:,0].A == 1)[0],0] = len(centList) 
        bestClustAss[nonzero(bestClustAss[:,0].A == 0)[0],0] = bestCentToSplit
        centList[bestCentToSplit] = bestNewCents[0,:].tolist()[0]
        centList.append(bestNewCents[1,:].tolist()[0])

        # 保存簇索引及誤差
        clusterAssment[nonzero(clusterAssment[:,0].A == bestCentToSplit)[0],:]= bestClustAss
    return mat(centList), clusterAssment


if __name__ == "__main__":
    # 測試 kMeans
    # datMat = mat(loadDataSet('testSet.txt'))
    # myCentroids, clustAssing = kMeans(datMat,4)
    # print myCentroids

    # 測試 二分 kMeans
    datMat3 = mat(loadDataSet('testSet2.txt'))
    centList,myNewAssments = biKmeans(datMat3,3)
    print centList

說明
本文爲《Machine Leaning in Action》第十章(Grouping unlabeled items using k-means clustering)讀書筆記, 代碼稍作修改及註釋.

好文參考
1.《K-Means 算法》
2.《漫談 Clustering (1): k-means》
3.《K-means聚類算法》

轉自：https://my.oschina.net/zenglingfan/blog/178356