聚类分析：原型K-Means/K-Means++聚类、层次聚类；密度聚类DBSCAN

聚类分析–处理无标签数据

from IPython.display import Image
%matplotlib inline

1.使用K-Means方法按照相似度对对象进行分组

1.1使用sklearn实现K-Means聚类

from sklearn.datasets import make_blobs

X, y = make_blobs(n_samples=150, 
                  n_features=2, 
                  centers=3, 
                  cluster_std=0.5, 
                  shuffle=True, 
                  random_state=0)

import matplotlib.pyplot as plt

plt.scatter(X[:, 0], X[:, 1], 
            c='white', marker='o', edgecolor='black', s=50)
plt.grid()
plt.tight_layout()
#plt.savefig('images/11_01.png', dpi=300)
plt.show()

from sklearn.cluster import KMeans

km = KMeans(n_clusters=3, 
            init='random', 
            n_init=10, 
            max_iter=300,
            tol=1e-04,
            random_state=0)

y_km = km.fit_predict(X)

1.2K-Means算法步骤总结

1.从样本中随机选择$K$个质心作为初始簇的中心；

2.将每个样本分配给最近的质心${\mu }^{(j)}$，其中 j ∈ { 1 , 2 , 3 , ⋯   , K } j\in\{1,2,3,\cdots,K\} j∈{1,2,3,⋯,K};

3.在新形成的簇中重新计算质心；

4.重复步骤2和3，直到达到最大迭代次数或用户定义的容忍度或者簇不再发生变化就停止；

如何衡量对象之间的相似性？

这里将相似性定义为距离的反义词，且对于具有连续特征的示例进行聚类的常用距离是平方欧氏距离：

$$d(\mathbf{x},\mathbf{y}{)}^2=\sum _{j=1}^m{\left(x_j-y_j\right)}^2=\Vert \mathbf{x}-\mathbf{y}{\Vert }_2^2$$

基于上述欧氏距离，我们可以将K-Means算法描述为一个简单的优化问题，一种用于迭代求解实现最小化的方法是使用SSE：

$$SSE=\sum _{i=1}^n\sum _{j=1}^k{w}^{(i,j)}{\Vert {\mathbf{x}}^{(i)}-{\mathbf{\mu }}^{(j)}\Vert }_2^2$$

这里的${\mu }^{(j)}$代表的是簇$j$的质心，其中$w^{(i,j)}$定义如下：
$$w^{(i,j)}=\{\begin{array}{ll}1,& \text{ if }{x}^{(i)}\in j\\ 0,& \text{ otherwise }\end{array}$$

如果在达到最大迭代次数之前，算法已经收敛了，则sklearn中的K-Means会提前停止。

然而，对于一些特定的情况，K-Means可能无法收敛，即便是选择了相对较大的迭代次数。

处理收敛问题的一种方法是，选择相对较大的tol参数值，该参数控制簇内部SSE中该表的容忍度以声明收敛。

K-Means算法的一个问题是一个或者多个簇可能是空的。但对于K-medoids或者模糊fuzzy C-Means中将不存在此问题。

Sklearn中，解决了上述问题。如果簇是空的，则算法会搜索距离空簇的质心最远的样本，然后它会将质心重新指定为最远的点。

当使用欧氏距离度量法的时候，希望确保在相同的尺度上度量特征尺度，在必要的时候使用z-score标准化或者线性函数归一化实现特征缩放。

plt.scatter(X[y_km == 0, 0],
            X[y_km == 0, 1],
            s=50, c='lightgreen',
            marker='s', edgecolor='black',
            label='Cluster 1')

plt.scatter(X[y_km == 1, 0],
            X[y_km == 1, 1],
            s=50, c='orange',
            marker='o', edgecolor='black',
            label='Cluster 2')

plt.scatter(X[y_km == 2, 0],
            X[y_km == 2, 1],
            s=50, c='lightblue',
            marker='v', edgecolor='black',
            label='Cluster 3')

plt.scatter(km.cluster_centers_[:, 0],
            km.cluster_centers_[:, 1],
            s=250, marker='*',
            c='red', edgecolor='black',
            label='Centroids')

plt.legend(scatterpoints=1)
plt.grid()
plt.tight_layout()
#plt.savefig('images/11_02.png', dpi=300)
plt.show()

上述方法需要提前指定簇的个数，当数据维度很高的时候，将非常困难。

2.使用K-Means++来更智能地选择初始聚类中心

经典的K-Means算法，使用随机种子来确定初始质心，如果质心选择不当，则可能会导致聚类效果不好或者收敛速度过慢。

解决此问题的一种方法是：：在数据集上多次运行K-Means算法，并且根据SSE选择最佳性能的模型。

使用K-Means++算法：

通过将初始质心放置在远离彼此的位置，这将会比经典K-Means算法产生更好个更加一致的结果。

K-Means++算法步骤总结：

1.初始化一个空的集合$M$,用于存储选出来的$K$个初始聚类中心；

2.从输入样本中随机选择第一个聚类中心${\mu }^{(j)}$,并将其指派到集合$M$中；

3.对于每个样本$x^{(i)}$,（该样本不属于集合$M$）,求出其与集合$M$中所有初始聚类中心的最小平方距离$d(x^{(i)},M{)}^2$；

4.为了随机选择下一个质心${\mu }^{(p)}$,使用一个加权概率分布$\frac{d{\left({\mathbf{\mu }}^{(p)},\mathbf{M}\right)}^2}{{\sum }_{i}d{\left({\mathbf{x}}^{(i)},\mathbf{M}\right)}^2}$；

5.重复上述步骤2,3,直到选出了$K$个聚类中心；

6.继续使用经典的K-Means算法；

使用的方法是，在初始化对象的时候，将参数初始化微init='K-means++'

from sklearn.cluster import KMeans

km = KMeans(n_clusters=3, 
            init='k-means++', 
            n_init=10, 
            max_iter=300,
            tol=1e-04,
            random_state=0)

y_km = km.fit_predict(X)

plt.scatter(X[y_km == 0, 0],
            X[y_km == 0, 1],
            s=50, c='lightgreen',
            marker='s', edgecolor='black',
            label='Cluster 1')

plt.scatter(X[y_km == 1, 0],
            X[y_km == 1, 1],
            s=50, c='orange',
            marker='o', edgecolor='black',
            label='Cluster 2')

plt.scatter(X[y_km == 2, 0],
            X[y_km == 2, 1],
            s=50, c='lightblue',
            marker='v', edgecolor='black',
            label='Cluster 3')

plt.scatter(km.cluster_centers_[:, 0],
            km.cluster_centers_[:, 1],
            s=250, marker='*',
            c='red', edgecolor='black',
            label='Centroids')

plt.legend(scatterpoints=1)
plt.grid()
plt.tight_layout()
#plt.savefig('images/11_02.png', dpi=300)
plt.show()

3.硬聚类和软聚类

硬聚类(Hard clustering):描述了一系列算法，其中数据集中的每一个样本都被分配给了一个簇，比如前面的K-Means算法和K-Means++算法。

软聚类或者模糊聚类(soft clustering或者fuzzy clustering)：将样本分配给一个或者多个簇。

一种流行的软聚类算法为：fuzzy C-Means(FCM),也被称为soft K-Means or fuzzy K-Means.

FCM过程与K-Means非常相似，但是使用的是属于每个聚类的点的概率值来替代硬聚类分配。在K-Means算法中，使用二进制值的稀疏向量来表示样本$x$的簇成员；

$$\left[\begin{array}{ll}x\in {\mu }^{(1)}& \to w^{(i,j)}=0\\ x\in {\mu }^{(2)}& \to w^{(i,j)}=1\\ x\in {\mu }^{(3)}& \to w^{(i,j)}=0\end{array}\right]$$

这里的值为1的索引位置表示簇的质心。

与上述不同，FCM算法描述如下：

$$\left[\begin{array}{ll}x\in {\mu }^{(1)}& \to w^{(i,j)}=0.1\\ x\in {\mu }^{(2)}& \to w^{(i,j)}=0.85\\ x\in {\mu }^{(3)}& \to w^{(i,j)}=0.05\end{array}\right]$$

这里的每个值都在$[0,1]$之间，分别代表每个样本输入某簇成员的概率值。

FCM算法步骤如下：

1.指定簇的数量$K$,并随机分配每个簇所包含的成员；

2.计算聚类中心${\mu }^{(j)}$，其中 j ∈ { 1 , ⋯   , K } j\in\{1,\cdots,K\} j∈{1,⋯,K};

3.为每个质心更新其所包含的簇成员；

4.重复步骤2,3,直到隶属系数不再改变或者达到用户定义的公差，或者达到最大迭代次数；

FCM算法的目标函数：

$$J_m=\sum _{i=1}^n\sum _{j=1}^k{w}^{(i,j{)}^m}{\Vert {\mathbf{x}}^{(i)}-{\mathbf{\mu }}^{(j)}\Vert }_2^2$$

注意：这里的$w^{(i,j)}$不再是二进制值，而代表的是概率。这里的指数$m$：任何大于或者等于1(通常设置m=2)，其代表的是模糊系数，或者称为模糊器，用于控制模糊度。

这里的$m$越大，则$w^{(i,j)}$变得越小，意味着簇成员资格越小，就会导致更加模糊的簇。

$$w^{(i,j)}={\left[\sum _{c=1}^k{\left(\frac{{\Vert x^{(i)}-{\mu }^{(j)}\Vert }_2}{{\Vert x^{(i)}-{\mu }^{(c)}\Vert }_2}\right)}^{\frac{2}{m-1}}\right]}^{-1}$$

示例，如果选择了三个簇，则：
$$w^{(i,j)}={\left[{\left(\frac{{\Vert {\mathbf{x}}^{(i)}-{\mathbf{\mu }}^{(j)}\Vert }_2}{{\Vert {\mathbf{x}}^{(i)}-{\mathbf{\mu }}^{(1)}\Vert }_2}\right)}^{\frac{2}{m-1}}+{\left(\frac{{\Vert {\mathbf{x}}^{(i)}-{\mathbf{\mu }}^{(j)}\Vert }_2}{{\Vert {\mathbf{x}}^{(i)}-{\mathbf{\mu }}^{(2)}\Vert }_2}\right)}^{\frac{2}{m-1}}+{\left(\frac{{\Vert {\mathbf{x}}^{(i)}-{\mathbf{\mu }}^{(j)}\Vert }_2}{{\Vert {\mathbf{x}}^{(i)}-{\mathbf{\mu }}^{(3)}\Vert }_2}\right)}^{\frac{2}{m-1}}\right]}^{-1}$$

这里的${\mu }^{(j)}$计算如下：
$${\mathbf{\mu }}^{(j)}=\frac{{\sum }_{i=1}^n{w}^{(i,j{)}^m}{\mathbf{x}}^{(i)}}{{\sum }_{i=1}^n{w}^{(i,j{)}^m}}$$

4.使用手肘法求出最优簇数

使用sklearn不需要显示地计算簇内的SSE，其可以通过inertia属性进行访问：

print('Distortion: %.2f' % km.inertia_)

Distortion: 72.48

手肘法，基于簇内部的SSE。

distortions = []
for i in range(1, 11):
    km = KMeans(n_clusters=i, 
                init='k-means++', 
                n_init=10, 
                max_iter=300, 
                random_state=0)
    km.fit(X)
    distortions.append(km.inertia_)
plt.plot(range(1, 11), distortions, marker='o')
plt.xlabel('Number of clusters')
plt.ylabel('Distortion')
plt.tight_layout()
#plt.savefig('images/11_03.png', dpi=300)
plt.show()

从上图可以看出，elbow位于当K=3的时候，该值对当前数据集来讲，是很好的选择。

5.使用轮廓图量化聚类质量

步骤如下：

1.计算簇的内聚力$\alpha (i)$,作为一个样本和同一个簇中所有其它点之间的平均距离；

2.计算簇的散度$b^{(i)}$,作为从下一个最近的簇和簇中所有其它点之间的平均距离；

3.计算轮廓$s^{(i)}$,用于反映簇内聚和簇散度差异的大小程度，定义如下：

$$s^{(i)}=\frac{b^{(i)}-a^{(i)}}{\max \left\{b^{(i)},a^{(i)}\right\}}$$

轮廓系数在正负一之间，从上式可知，当聚类散度和内聚力相同的时候，轮廓系数为零。

若，$b^{(i)}\gg a^{(i)}$,将得到接近于1的理想轮廓系数，因为$b^{(i)}$量化了一个示例与其他簇的不同程度。$a^{(i)}$反映了当前样本与其内部簇中的其他样本的相似程度。

import numpy as np
from matplotlib import cm
from sklearn.metrics import silhouette_samples

km = KMeans(n_clusters=3, 
            init='k-means++', 
            n_init=10, 
            max_iter=300,
            tol=1e-04,
            random_state=0)

y_km = km.fit_predict(X)

cluster_labels = np.unique(y_km)
n_clusters = cluster_labels.shape[0]
silhouette_vals = silhouette_samples(X, y_km, metric='euclidean')
y_ax_lower, y_ax_upper = 0, 0
yticks = []


for i, c in enumerate(cluster_labels):
    c_silhouette_vals = silhouette_vals[y_km == c]
    c_silhouette_vals.sort()
    y_ax_upper += len(c_silhouette_vals)
    color = cm.jet(float(i) / n_clusters)
    plt.barh(range(y_ax_lower, y_ax_upper), c_silhouette_vals, height=1.0, 
             edgecolor='none', color=color)

    yticks.append((y_ax_lower + y_ax_upper) / 2.)
    y_ax_lower += len(c_silhouette_vals)
    
silhouette_avg = np.mean(silhouette_vals)
plt.axvline(silhouette_avg, color="red", linestyle="--") 

plt.yticks(yticks, cluster_labels + 1)
plt.ylabel('Cluster')
plt.xlabel('Silhouette coefficient')

plt.tight_layout()
#plt.savefig('images/11_04.png', dpi=300)
plt.show()

图中虚线为平均轮廓系数。

将上述聚类结果与一个相对较差的聚类相对比。

km = KMeans(n_clusters=2,
            init='k-means++',
            n_init=10,
            max_iter=300,
            tol=1e-04,
            random_state=0)
y_km = km.fit_predict(X)

plt.scatter(X[y_km == 0, 0],
            X[y_km == 0, 1],
            s=50,
            c='lightgreen',
            edgecolor='black',
            marker='s',
            label='Cluster 1')
plt.scatter(X[y_km == 1, 0],
            X[y_km == 1, 1],
            s=50,
            c='orange',
            edgecolor='black',
            marker='o',
            label='Cluster 2')

plt.scatter(km.cluster_centers_[:, 0], km.cluster_centers_[:, 1],
            s=250, marker='*', c='red', label='Centroids')
plt.legend()
plt.grid()
plt.tight_layout()
#plt.savefig('images/11_05.png', dpi=300)
plt.show()

cluster_labels = np.unique(y_km)
n_clusters = cluster_labels.shape[0]
silhouette_vals = silhouette_samples(X, y_km, metric='euclidean')
y_ax_lower, y_ax_upper = 0, 0
yticks = []
for i, c in enumerate(cluster_labels):
    c_silhouette_vals = silhouette_vals[y_km == c]
    c_silhouette_vals.sort()
    y_ax_upper += len(c_silhouette_vals)
    color = cm.jet(float(i) / n_clusters)
    plt.barh(range(y_ax_lower, y_ax_upper), c_silhouette_vals, height=1.0, 
             edgecolor='none', color=color)

    yticks.append((y_ax_lower + y_ax_upper) / 2.)
    y_ax_lower += len(c_silhouette_vals)
    
silhouette_avg = np.mean(silhouette_vals)
plt.axvline(silhouette_avg, color="red", linestyle="--") 

plt.yticks(yticks, cluster_labels + 1)
plt.ylabel('Cluster')
plt.xlabel('Silhouette coefficient')

plt.tight_layout()
#plt.savefig('images/11_06.png', dpi=300)
plt.show()

可以看出，轮廓图现在具有折明显不同的长度和宽度，充分表明这是一个相对较差的聚类结果。

6.将簇组织为层次树

层次聚类是另一种基于原型的聚类方法，

层次聚类的一个优点：允许绘制树状图，即二进制分层聚类的可视化。而且无需预先指定簇的数量。

层次聚类的两种主要方法：凝聚型和分裂型

在分裂的分层聚类中，从一个包含完整数据集的簇开始，迭代地将簇划分为更小的簇，直到每个簇中仅包含一个样本实例。

在凝聚型聚类中，将每个样本实例作为单个簇开始，并合并最近的簇对，直至剩下一个簇。

6.1以自底向上的方式对簇进行分组

凝聚层次聚类的两种标准算法是单链接算法和完全链接算法。

利用单链接算法：:计算每一对聚类中最相似成员之间的距离，并将具有最相似成员之间的距离最小的两个聚类合并。

完全链接算法：：不是比较每一对簇中最相似的成员，而是比较最不相似的成员来执行合并。

完全链接算法几何表示如下：

Image(filename='./images/11_07.png', width=400) 

其他类型的链接：

包括平均链接、Ward’s链接。

在平均链接中，根据两个聚类中所有成员之间的最小平均距离来合并簇对儿。

在Ward’s链接中，导致簇内SSE总量增幅最小的两个簇将被合并。

完全链接的凝聚型层次聚类：

1.计算所有样本的距离矩阵；

2.将每个数据点单独表示为一个簇；

3.基于最不相近(遥远)成员之间的距离合并两个最近的簇；

4.更新相似性矩阵；

5.重复上述2，3, 4，步骤，直到形成唯一的一个簇；

# 首先生成一个随机数据样本
# 行代表不同的观测值(id 0-4)，列代表不同的特征

import pandas as pd
import numpy as np

np.random.seed(123)

variables = ['X', 'Y', 'Z']
labels = ['ID_0', 'ID_1', 'ID_2', 'ID_3', 'ID_4']

X = np.random.random_sample([5, 3])*10
df = pd.DataFrame(X, columns=variables, index=labels)
df

	X	Y	Z
ID_0	6.964692	2.861393	2.268515
ID_1	5.513148	7.194690	4.231065
ID_2	9.807642	6.848297	4.809319
ID_3	3.921175	3.431780	7.290497
ID_4	4.385722	0.596779	3.980443

6.2在距离矩阵上执行层次聚类

# 为了计算距离矩阵，作为层次聚类的输入，这里使用Scipy的pdist函数。

from scipy.spatial.distance import pdist, squareform

row_dist = pd.DataFrame(squareform(pdist(df, metric='euclidean')),
                        columns=labels,
                        index=labels)
row_dist

	ID_0	ID_1	ID_2	ID_3	ID_4
ID_0	0.000000	4.973534	5.516653	5.899885	3.835396
ID_1	4.973534	0.000000	4.347073	5.104311	6.698233
ID_2	5.516653	4.347073	0.000000	7.244262	8.316594
ID_3	5.899885	5.104311	7.244262	0.000000	4.382864
ID_4	3.835396	6.698233	8.316594	4.382864	0.000000

# 1. 不正确的方法: Squareform distance matrix

from scipy.cluster.hierarchy import linkage

row_clusters = linkage(row_dist, method='complete', metric='euclidean')

pd.DataFrame(row_clusters,
             columns=['row label 1', 'row label 2',
                      'distance', 'no. of items in clust.'],
             index=['cluster %d' % (i + 1)
                    for i in range(row_clusters.shape[0])])

D:\installation\anaconda3\lib\site-packages\ipykernel_launcher.py:5: ClusterWarning: scipy.cluster: The symmetric non-negative hollow observation matrix looks suspiciously like an uncondensed distance matrix
  """

	row label 1	row label 2	distance	no. of items in clust.
cluster 1	0.0	4.0	6.521973	2.0
cluster 2	1.0	2.0	6.729603	2.0
cluster 3	3.0	5.0	8.539247	3.0
cluster 4	6.0	7.0	12.444824	5.0

# 2. 正确的方法: Condensed distance matrix

row_clusters = linkage(pdist(df, metric='euclidean'), method='complete')

pd.DataFrame(row_clusters,
             columns=['row label 1', 'row label 2',
                      'distance', 'no. of items in clust.'],
             index=['cluster %d' % (i + 1) 
                    for i in range(row_clusters.shape[0])])

	row label 1	row label 2	distance	no. of items in clust.
cluster 1	0.0	4.0	3.835396	2.0
cluster 2	1.0	2.0	4.347073	2.0
cluster 3	3.0	5.0	5.899885	3.0
cluster 4	6.0	7.0	8.316594	5.0

# 3. correct approach: Input matrix

row_clusters = linkage(df.values, method='complete', metric='euclidean')
pd.DataFrame(row_clusters,
             columns=['row label 1', 'row label 2',
                      'distance', 'no. of items in clust.'],
             index=['cluster %d' % (i + 1)
                    for i in range(row_clusters.shape[0])])

	row label 1	row label 2	distance	no. of items in clust.
cluster 1	0.0	4.0	3.835396	2.0
cluster 2	1.0	2.0	4.347073	2.0
cluster 3	3.0	5.0	5.899885	3.0
cluster 4	6.0	7.0	8.316594	5.0

链接矩阵由几行组成，每一行表示一次合并。第一列和第二列表示每个集群中最不相似的成员，第三列报告这些成员之间的距离。最后一列返回每个簇中的成员计数。

from scipy.cluster.hierarchy import dendrogram

# make dendrogram black (part 1/2)
# from scipy.cluster.hierarchy import set_link_color_palette
# set_link_color_palette(['black'])

row_dendr = dendrogram(row_clusters, 
                       labels=labels,
                       # make dendrogram black (part 2/2)
                       # color_threshold=np.inf
                       )
plt.tight_layout()
plt.ylabel('Euclidean distance')
#plt.savefig('images/11_11.png', dpi=300, 
#            bbox_inches='tight')
plt.show()

# 上述图概括了基于欧式距离度量的最相似的例子，ID_0和ID_4，然后是ID_1和ID_2.

6.3将树状图连接到热力图上

# plot row dendrogram
fig = plt.figure(figsize=(8, 8), facecolor='white')
axd = fig.add_axes([0.09, 0.1, 0.2, 0.6])

# note: for matplotlib < v1.5.1, please use orientation='right'
row_dendr = dendrogram(row_clusters, orientation='left')

# reorder data with respect to clustering
df_rowclust = df.iloc[row_dendr['leaves'][::-1]]

axd.set_xticks([])
axd.set_yticks([])

# remove axes spines from dendrogram
for i in axd.spines.values():
    i.set_visible(False)

# plot heatmap
axm = fig.add_axes([0.23, 0.1, 0.6, 0.6])  # x-pos, y-pos, width, height
cax = axm.matshow(df_rowclust, interpolation='nearest', cmap='hot_r')
fig.colorbar(cax)
axm.set_xticklabels([''] + list(df_rowclust.columns))
axm.set_yticklabels([''] + list(df_rowclust.index))

#plt.savefig('images/11_12.png', dpi=300)
plt.show()

6.4通过sklearn应用凝聚聚类

from sklearn.cluster import AgglomerativeClustering

ac = AgglomerativeClustering(n_clusters=3, 
                             affinity='euclidean', 
                             linkage='complete')
labels = ac.fit_predict(X)
print('Cluster labels: %s' % labels)

Cluster labels: [1 0 0 2 1]

这里允许我们指定希望返回的簇的数量，对于修建分层的分层簇树，很有用。通过将n_cluster参数设置为3，可以将使用相同的基于欧氏距离的完全链接方法将输入实例分为三组。

从结果中可以看出，第一个和第五个样本被划分到了同一个簇，标签都为1.ID_1和ID_2被划分到另一个簇，标签为0.ID_3的样本被放入子集的簇，标签为2.

# 设置簇的个数为2，用于对比
ac = AgglomerativeClustering(n_clusters=2, 
                             affinity='euclidean', 
                             linkage='complete')
labels = ac.fit_predict(X)
print('Cluster labels: %s' % labels)

Cluster labels: [0 1 1 0 0]

7.通过DBSCAN定位高密度区域

基于密度的DBSCAN聚类，不会假设像K-Means这样的球状聚类，也不会将数据划分为需要手动截断点的层次结构。

基于密度的聚类基于点的密集区域分配聚类标签。但DBSCAN中，密度的概念定义为指定半径内点的数量。

准则：

1.如果在指定的半径内至少有指定数量的相邻点，则将该点视为一个核心点；

2.边界点定义为：若一个比1中半径内有着更少的点，但该点依然位于1中的半径内的点；

3.其他所有既不是核心点，也不是边界点的余下点，都被视为噪声；

Image(filename='images/11_13.png', width=500) 

使用DBSCAN的一个主要优点是，不需要像K-Means那样假定簇具有球形特征。

DBSCAN与K-Means以及分层聚类的不同之处在于，不一定将每个点分配给一个簇，但其能够去除噪声点。

# 构建半月形数据集
from sklearn.datasets import make_moons

X, y = make_moons(n_samples=200, noise=0.05, random_state=0)
plt.scatter(X[:, 0], X[:, 1])
plt.tight_layout()
#plt.savefig('images/11_14.png', dpi=300)
plt.show()

首先使用K-Means算法和完全链接聚类，看其是否可以有效识别出半月形作为单独的聚类。

f, (ax1, ax2) = plt.subplots(1, 2, figsize=(8, 3))

km = KMeans(n_clusters=2, random_state=0)
y_km = km.fit_predict(X)
ax1.scatter(X[y_km == 0, 0], X[y_km == 0, 1],
            edgecolor='black',
            c='lightblue', marker='o', s=40, label='cluster 1')
ax1.scatter(X[y_km == 1, 0], X[y_km == 1, 1],
            edgecolor='black',
            c='red', marker='s', s=40, label='cluster 2')
ax1.set_title('K-means clustering')

ac = AgglomerativeClustering(n_clusters=2,
                             affinity='euclidean',
                             linkage='complete')
y_ac = ac.fit_predict(X)
ax2.scatter(X[y_ac == 0, 0], X[y_ac == 0, 1], c='lightblue',
            edgecolor='black',
            marker='o', s=40, label='Cluster 1')
ax2.scatter(X[y_ac == 1, 0], X[y_ac == 1, 1], c='red',
            edgecolor='black',
            marker='s', s=40, label='Cluster 2')
ax2.set_title('Agglomerative clustering')

plt.legend()
plt.tight_layout()
#plt.savefig('images/11_15.png', dpi=300)
plt.show()

使用密度聚类：

from sklearn.cluster import DBSCAN

db = DBSCAN(eps=0.2, min_samples=5, metric='euclidean')
y_db = db.fit_predict(X)
plt.scatter(X[y_db == 0, 0], X[y_db == 0, 1],
            c='lightblue', marker='o', s=40,
            edgecolor='black', 
            label='Cluster 1')
plt.scatter(X[y_db == 1, 0], X[y_db == 1, 1],
            c='red', marker='s', s=40,
            edgecolor='black', 
            label='Cluster 2')
plt.legend()
plt.tight_layout()
#plt.savefig('images/11_16.png', dpi=300)
plt.show()