聚類算法---kmeans以及DBSCAN算法

一、聚類分析又稱群分析，它是研究（樣品或指標）分類問題的一種統計分析方法，同時也是數據挖掘的一個重要算法。

聚類（Cluster）分析是由若干模式（Pattern）組成的，通常，模式是一個度量（Measurement）的向量，或者是 多維空間中的一個點。

聚類分析以相似性為基礎，在一個聚類中的模式之間比不在同一聚類中的模式之間具有更多的相似性。

 

二、聚類算法分類
1.基於划分
給定一個有N個元組或者紀錄的數據集，分裂法將構造K個分組，每一個分組就代表一個聚類，K<N。
特點：計算量大。很適合發現中小規模的數據庫中小規模的數據庫中的球狀簇。
算法：K-MEANS算法、K-MEDOIDS算法、CLARANS算法

2.基於層次
對給定的數據集進行層次似的分解，直到某種條件滿足為止。具體又可分為“自底向上”和“自頂向下”兩種方案。
特點：較小的計算開銷。然而這種技術不能更正錯誤的決定。
算法：BIRCH算法、CURE算法、CHAMELEON算法

3.基於密度
只要一個區域中的點的密度大過某個閾值，就把它加到與之相近的聚類中去。
特點：能克服基於距離的算法只能發現“類圓形”的聚類的缺點。
算法：DBSCAN算法、OPTICS算法、DENCLUE算法

4.基於網格
將數據空間划分成為有限個單元（cell）的網格結構,所有的處理都是以單個的單元為對象的。
特點：處理速度很快，通常這是與目標數據庫中記錄的個數無關的，只與把數據空間分為多少個單元有關。
算法：STING算法、CLIQUE算法、WAVE-CLUSTER算法
---------------------

三、度量指標

 

---

算法步驟及代碼實現

1. K-Means(K均值)聚類

算法步驟：
(1) 首先我們選擇一些類/組，並隨機初始化它們各自的中心點。中心點是與每個數據點向量長度相同的位置。這需要我們提前預知類的數量(即中心點的數量)。
(2) 計算每個數據點到中心點的距離，數據點距離哪個中心點最近就划分到哪一類中。
(3) 計算每一類中中心點作為新的中心點。
(4) 重復以上步驟，直到每一類中心在每次迭代后變化不大為止。也可以多次隨機初始化中心點，然后選擇運行結果最好的一個。
下圖演示了K-Means進行分類的過程：
---------------------

優點：
速度快，計算簡便
缺點：
我們必須提前知道數據有多少類/組。
K-Medians是K-Means的一種變體，是用數據集的中位數而不是均值來計算數據的中心點。
K-Medians的優勢是使用中位數來計算中心點不受異常值的影響；缺點是計算中位數時需要對數據集中的數據進行排序，速度相對於K-Means較慢。
---------------------

肘部法則
如果問題中沒有指定k的值，可以通過肘部法則這一技術來估計聚類數量。肘部法則會把不同k值的成本函數值畫出來。隨着kk值的增大，平均畸變程度會減小；每個類包含的樣本數會減少，於是樣本離其重心會更近。但是，隨着k值繼續增大，平均畸變程度的改善效果會不斷減低。k值增大過程中，畸變程度的改善效果下降幅度最大的位置對應的k值就是肘部。為了讓讀者看的更加明白，下面讓我們通過一張圖用肘部法則來確定最佳的kk值。下圖數據明顯可分成兩類：

import random
from sklearn import datasets
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
%matplotlib inline


# 正規化數據集 X
def normalize(X, axis=-1, p=2):
    lp_norm = np.atleast_1d(np.linalg.norm(X, p, axis))
    lp_norm[lp_norm == 0] = 1
    return X / np.expand_dims(lp_norm, axis)


# 計算一個樣本與數據集中所有樣本的歐氏距離的平方
def euclidean_distance(one_sample, X):
    one_sample = one_sample.reshape(1, -1)
    X = X.reshape(X.shape[0], -1)
    distances = np.power(np.tile(one_sample, (X.shape[0], 1)) - X, 2).sum(axis=1)
    return distances



class Kmeans():
    """Kmeans聚類算法.

    Parameters:
    -----------
    k: int
        聚類的數目.
    max_iterations: int
        最大迭代次數. 
    varepsilon: float
        判斷是否收斂, 如果上一次的所有k個聚類中心與本次的所有k個聚類中心的差都小於varepsilon, 
        則說明算法已經收斂
    """
    def __init__(self, k=2, max_iterations=500, varepsilon=0.0001):
        self.k = k
        self.max_iterations = max_iterations
        self.varepsilon = varepsilon

    # 從所有樣本中隨機選取self.k樣本作為初始的聚類中心
    def init_random_centroids(self, X):
        n_samples, n_features = np.shape(X)
        centroids = np.zeros((self.k, n_features))
        for i in range(self.k):
            centroid = X[np.random.choice(range(n_samples))]
            centroids[i] = centroid
        return centroids

    # 返回距離該樣本最近的一個中心索引[0, self.k)
    def _closest_centroid(self, sample, centroids):
        distances = euclidean_distance(sample, centroids)
        closest_i = np.argmin(distances)
        return closest_i

    # 將所有樣本進行歸類，歸類規則就是將該樣本歸類到與其最近的中心
    def create_clusters(self, centroids, X):
        n_samples = np.shape(X)[0]
        clusters = [[] for _ in range(self.k)]
        for sample_i, sample in enumerate(X):
            centroid_i = self._closest_centroid(sample, centroids)
            clusters[centroid_i].append(sample_i)
        return clusters

    # 對中心進行更新
    def update_centroids(self, clusters, X):
        n_features = np.shape(X)[1]
        centroids = np.zeros((self.k, n_features))
        for i, cluster in enumerate(clusters):
            centroid = np.mean(X[cluster], axis=0)
            centroids[i] = centroid
        return centroids

    # 將所有樣本進行歸類，其所在的類別的索引就是其類別標簽
    def get_cluster_labels(self, clusters, X):
        y_pred = np.zeros(np.shape(X)[0])
        for cluster_i, cluster in enumerate(clusters):
            for sample_i in cluster:
                y_pred[sample_i] = cluster_i
        return y_pred

    # 對整個數據集X進行Kmeans聚類，返回其聚類的標簽
    def predict(self, X):
        # 從所有樣本中隨機選取self.k樣本作為初始的聚類中心
        centroids = self.init_random_centroids(X)

        # 迭代，直到算法收斂(上一次的聚類中心和這一次的聚類中心幾乎重合)或者達到最大迭代次數
        for _ in range(self.max_iterations):
            # 將所有進行歸類，歸類規則就是將該樣本歸類到與其最近的中心
            clusters = self.create_clusters(centroids, X)
            former_centroids = centroids

            # 計算新的聚類中心
            centroids = self.update_centroids(clusters, X)

            # 如果聚類中心幾乎沒有變化，說明算法已經收斂，退出迭代
            diff = centroids - former_centroids
            if diff.any() < self.varepsilon:
                break

        return self.get_cluster_labels(clusters, X)


def main():
    # Load the dataset
    X, y = datasets.make_blobs(n_samples=10000, 
                               n_features=3, 
                               centers=[[3,3, 3], [0,0,0], [1,1,1], [2,2,2]], 
                               cluster_std=[0.2, 0.1, 0.2, 0.2], 
                               random_state =9)

    # 用Kmeans算法進行聚類
    clf = Kmeans(k=4)
    y_pred = clf.predict(X)


    # 可視化聚類效果
    fig = plt.figure(figsize=(12, 8))
    ax = Axes3D(fig, rect=[0, 0, 1, 1], elev=30, azim=20)
    plt.scatter(X[y==0][:, 0], X[y==0][:, 1], X[y==0][:, 2])
    plt.scatter(X[y==1][:, 0], X[y==1][:, 1], X[y==1][:, 2])
    plt.scatter(X[y==2][:, 0], X[y==2][:, 1], X[y==2][:, 2])
    plt.scatter(X[y==3][:, 0], X[y==3][:, 1], X[y==3][:, 2])
    plt.show()


if __name__ == "__main__":
    main()

 

---

2.DBSCAN也是基於密度的聚類算法，與均值漂移聚類類似

具體步驟：
1. 首先確定半徑r和minPoints（數目）. 從一個沒有被訪問過的任意數據點開始，以這個點為中心，r為半徑的圓內包含的點的數量是否大於或等於minPoints，如果大於或等於minPoints則改點被標記為central point,反之則會被標記為noise point。
2. 重復1的步驟，如果一個noise point存在於某個central point為半徑的圓內，則這個點被標記為邊緣點，反之仍為noise point。重復步驟1，知道所有的點都被訪問過。

在DBSCAN算法中將數據點分為一下三類： 
核心點：在半徑Eps內含有超過MinPts數目的點 
邊界點：在半徑Eps內點的數量小於MinPts，但是落在核心點的鄰域內 
噪音點：既不是核心點也不是邊界點的點 

優點：不需要知道簇的數量
缺點：需要確定距離r和minPoints

import numpy as np

from sklearn.cluster import DBSCAN
from sklearn import metrics
from sklearn.datasets.samples_generator import make_blobs
from sklearn.preprocessing import StandardScaler


##############################################################################
# Generate sample data
centers = [[1, 1], [-1, -1], [1, -1]]
X, labels_true = make_blobs(n_samples=750, centers=centers, cluster_std=0.4,
                            random_state=0)

X = StandardScaler().fit_transform(X)

##############################################################################
# Compute DBSCAN
db = DBSCAN(eps=0.3, min_samples=10).fit(X)
core_samples_mask = np.zeros_like(db.labels_, dtype=bool)
core_samples_mask[db.core_sample_indices_] = True
labels = db.labels_

# Number of clusters in labels, ignoring noise if present.
n_clusters_ = len(set(labels)) - (1 if -1 in labels else 0)

print('Estimated number of clusters: %d' % n_clusters_)
print("Homogeneity: %0.3f" % metrics.homogeneity_score(labels_true, labels))
print("Completeness: %0.3f" % metrics.completeness_score(labels_true, labels))
print("V-measure: %0.3f" % metrics.v_measure_score(labels_true, labels))
print("Adjusted Rand Index: %0.3f"
      % metrics.adjusted_rand_score(labels_true, labels))
print("Adjusted Mutual Information: %0.3f"
      % metrics.adjusted_mutual_info_score(labels_true, labels))
print("Silhouette Coefficient: %0.3f"
      % metrics.silhouette_score(X, labels))

##############################################################################
# Plot result
import matplotlib.pyplot as plt

# Black removed and is used for noise instead.
unique_labels = set(labels)
colors = plt.cm.Spectral(np.linspace(0, 1, len(unique_labels)))
for k, col in zip(unique_labels, colors):
    if k == -1:
        # Black used for noise.
        col = 'k'

    class_member_mask = (labels == k)

    xy = X[class_member_mask & core_samples_mask]
    plt.plot(xy[:, 0], xy[:, 1], 'o', markerfacecolor=col,
             markeredgecolor='k', markersize=14)

    xy = X[class_member_mask & ~core_samples_mask]
    plt.plot(xy[:, 0], xy[:, 1], 'o', markerfacecolor=col,
             markeredgecolor='k', markersize=6)

plt.title('Estimated number of clusters: %d' % n_clusters_)
plt.show()

            黑色的點代表離群點或者叫噪聲點

 

---

 3.層次聚類

層次聚類算法分為兩類：自上而下和自下而上。凝聚層級聚類(HAC)是自下而上的一種聚類算法。HAC首先將每個數據點視為一個單一的簇，然后計算所有簇之間的距離來合並簇，知道所有的簇聚合成為一個簇為止。 

度量方法：

算法步驟：

1. 首先我們將每個數據點視為一個單一的簇，然后選擇一個測量兩個簇之間距離的度量標准。例如我們使用average linkage作為標准，它將兩個簇之間的距離定義為第一個簇中的數據點與第二個簇中的數據點之間的平均距離。
2. 在每次迭代中，我們將兩個具有最小average linkage的簇合並成為一個簇。
3. 重復步驟2知道所有的數據點合並成一個簇，然后選擇我們需要多少個簇。
層次聚類優點：（1）不需要知道有多少個簇
（2）對於距離度量標准的選擇並不敏感
缺點：效率低
---------------------

import numpy as np
import pandas as pd
from sklearn.cluster import AgglomerativeClustering
import matplotlib.pyplot as plt
import numpy as np
from scipy import ndimage
from matplotlib import pyplot as plt
from sklearn import manifold, datasets


# In[2]:
#1797個樣本，每個樣本包括8*8像素的圖像和一個[0, 9]整數的標簽
digits = datasets.load_digits(n_class=10)#手寫字體數據集,
X = digits.data
y = digits.target
n_samples, n_features = X.shape
print(digits.keys())
print X[:5,:]
print n_samples,n_features


# In[3]:

# Visualize the clustering
def plot_clustering(X_red, X, labels, title=None):
    x_min, x_max = np.min(X_red, axis=0), np.max(X_red, axis=0)
    X_red = (X_red - x_min) / (x_max - x_min)

    plt.figure(figsize=(6, 4))
    for i in range(X_red.shape[0]):
        plt.text(X_red[i, 0], X_red[i, 1], str(y[i]),
                 color=plt.cm.spectral(labels[i] / 10.),
                 fontdict={'weight': 'bold', 'size': 9})

    plt.xticks([])
    plt.yticks([])
    if title is not None:
        plt.title(title, size=17)
    plt.axis('off')
    plt.tight_layout()


# In[ ]:

# 2D embedding of the digits dataset
print("Computing embedding")
X_red = manifold.SpectralEmbedding(n_components=2).fit_transform(X)
print("Done.")

from sklearn.cluster import AgglomerativeClustering

for linkage in ('ward', 'average', 'complete'):
    clustering = AgglomerativeClustering(linkage=linkage, n_clusters=10)
    clustering.fit(X_red)
    plot_clustering(X_red, X, clustering.labels_, "%s linkage" % linkage)


plt.show()

 

 

 上圖顯示層次聚類采用不同距離度量方法的效果，complete在此數據集上效果較差。