數據挖掘十大算法（二）：K-means聚類算法原理與實現

參考：

1.機器學習-KMeans聚類 K值以及初始類簇中心點的選取

2.K-Means算法的研究分析及改進

一、K-means算法原理

K-means算法是最常用的一種聚類算法。算法的輸入爲一個樣本集（或者稱爲點集），通過該算法可以將樣本進行聚類，具有相似特徵的樣本聚爲一類。

針對每個點，計算這個點距離所有中心點最近的那個中心點，然後將這個點歸爲這個中心點代表的簇。一次迭代結束之後，針對每個簇類，重新計算中心點，然後針對每個點，重新尋找距離自己最近的中心點。如此循環，直到前後兩次迭代的簇類沒有變化。

下面通過一個簡單的例子，說明K-means算法的過程。如下圖所示，目標是將樣本點聚類成3個類別。

基本的步驟爲：

step1：選定要聚類的類別數目k（如上例的k=3類），選擇k箇中心點。

step2：針對每個樣本點，找到距離其最近的中心點（尋找組織），距離同一中心點最近的點爲一個類，這樣完成了一次聚類。

step3：判斷聚類前後的樣本點的類別情況是否相同，如果相同，則算法終止，否則進入step4。

step4：針對每個類別中的樣本點，計算這些樣本點的中心點，當做該類的新的中心點，繼續step2。

上述步驟的關鍵兩點是：

1. 找到距離自己最近的中心點。

2. 更新中心點。

二、Python實現

下面給出它的Python實現，其中中心點的選取是手動選擇的。在代碼中隨機產生了一個樣本，用於測試K-means算法：

# K-means Algorithm is a clustering algorithm
import numpy as np
import matplotlib.pyplot as plt
import random


def get_distance(p1, p2):
    diff = [x-y for x, y in zip(p1, p2)]
    distance = np.sqrt(sum(map(lambda x: x**2, diff)))
    return distance


# 計算多個點的中心
# cluster = [[1,2,3], [-2,1,2], [9, 0 ,4], [2,10,4]]
def calc_center_point(cluster):
    N = len(cluster)
    m = np.matrix(cluster).transpose().tolist()
    center_point = [sum(x)/N for x in m]
    return center_point


# 檢查兩個點是否有差別
def check_center_diff(center, new_center):
    n = len(center)
    for c, nc in zip(center, new_center):
        if c != nc:
            return False
    return True


# K-means算法的實現
def K_means(points, center_points):

    N = len(points)         # 樣本個數
    n = len(points[0])      # 單個樣本的維度
    k = len(center_points)  # k值大小

    tot = 0
    while True:             # 迭代
        temp_center_points = [] # 記錄中心點

        clusters = []       # 記錄聚類的結果
        for c in range(0, k):
            clusters.append([]) # 初始化

        # 針對每個點，尋找距離其最近的中心點（尋找組織）
        for i, data in enumerate(points):
            distances = []
            for center_point in center_points:
                distances.append(get_distance(data, center_point))
            index = distances.index(min(distances)) # 找到最小的距離的那個中心點的索引，

            clusters[index].append(data)    # 那麼這個中心點代表的簇，裏面增加一個樣本

        tot += 1
        print(tot, '次迭代   ', clusters)
        k = len(clusters)
        colors = ['r.', 'g.', 'b.', 'k.', 'y.']  # 顏色和點的樣式
        for i, cluster in enumerate(clusters):
            data = np.array(cluster)
            data_x = [x[0] for x in data]
            data_y = [x[1] for x in data]
            plt.subplot(2, 3, tot)
            plt.plot(data_x, data_y, colors[i])
            plt.axis([0, 1000, 0, 1000])

        # 重新計算中心點（該步驟可以與下面判斷中心點是否發生變化這個步驟，調換順序）
        for cluster in clusters:
            temp_center_points.append(calc_center_point(cluster))

        # 在計算中心點的時候，需要將原來的中心點算進去
        for j in range(0, k):
            if len(clusters[j]) == 0:
                temp_center_points[j] = center_points[j]

        # 判斷中心點是否發生變化：即，判斷聚類前後樣本的類別是否發生變化
        for c, nc in zip(center_points, temp_center_points):
            if not check_center_diff(c, nc):
                center_points = temp_center_points[:]   # 複製一份
                break
        else:   # 如果沒有變化，那麼退出迭代，聚類結束
            break

    plt.show()
    return clusters # 返回聚類的結果




# 隨機獲取一個樣本集，用於測試K-means算法
def get_test_data():

    N = 1000

    # 產生點的區域
    area_1 = [0, N / 4, N / 4, N / 2]
    area_2 = [N / 2, 3 * N / 4, 0, N / 4]
    area_3 = [N / 4, N / 2, N / 2, 3 * N / 4]
    area_4 = [3 * N / 4, N, 3 * N / 4, N]
    area_5 = [3 * N / 4, N, N / 4, N / 2]

    areas = [area_1, area_2, area_3, area_4, area_5]
    k = len(areas)

    # 在各個區域內，隨機產生一些點
    points = []
    for area in areas:
        rnd_num_of_points = random.randint(50, 200)
        for r in range(0, rnd_num_of_points):
            rnd_add = random.randint(0, 100)
            rnd_x = random.randint(area[0] + rnd_add, area[1] - rnd_add)
            rnd_y = random.randint(area[2], area[3] - rnd_add)
            points.append([rnd_x, rnd_y])

    # 自定義中心點，目標聚類個數爲5，因此選定5箇中心點
    center_points = [[0, 250], [500, 500], [500, 250], [500, 250], [500, 750]]

    return points, center_points


if __name__ == '__main__':

    points, center_points = get_test_data()
    clusters = K_means(points, center_points)
    print('#######最終結果##########')
    for i, cluster in enumerate(clusters):
        print('cluster ', i, ' ', cluster)

由於樣本點是隨機產生的，所以每次運行的結果不相同。6次迭代得到的聚類結果分別如下圖。

控制檯輸出結果爲：

三、初始中心點的選取

初始中心點的選取，對聚類的結果影響較大。可以驗證，不同初始中心點，會導致聚類的效果不同。如何選擇初始中心點呢？一個原則是：

初始中心點之間的間距應該較大。因此，可以採取的策略是：

step1：計算所有樣本點之間的距離，選擇距離最大的一個點對（兩個樣本C1, C2）作爲2個初始中心點，從樣本點集中去掉這兩個點。

step2：如果初始中心點個數達到k個，則終止。如果沒有，在剩餘的樣本點中，選一個點C3，這個點優化的目標是：

這是一個雙目標優化問題，可以約束其中一個，極值化另外一個，這樣可以選擇一個合適的C3點，作爲第3個初始中心點。

如果要尋找第4個初始中心點，思路和尋找第3個初始中心點是相同的。

四、誤差平方和（Sum of Squared Error）

誤差平法和，SSE，用於評價聚類的結果的好壞，SSE的定義如下。

一般情況下，k越大，SSE越小。假設k=N=樣本個數，那麼每個點自成一類，那麼每個類的中心點爲這個類中的唯一一個點本身，那麼SSE=0。

五、k值得確定

一般k不會很大，大概在2~10之間，因此可以作出這個範圍內的SSE-k的曲線，再選擇一個拐點，作爲合適的k值。

可以看到，k=5之後，SSE下降的變得很緩慢了，因此最佳的k值爲5。