十七、聚类

作者：Chris Albon

译者：飞龙

协议：CC BY-NC-SA 4.0

凝聚聚类

十七、聚类 - 图1

  1. # 加载库
  2. from sklearn import datasets
  3. from sklearn.preprocessing import StandardScaler
  4. from sklearn.cluster import AgglomerativeClustering
  6. # 加载数据
  7. iris = datasets.load_iris()
  8. X = iris.data
  10. # 标准化特征
  11. scaler = StandardScaler()
  12. X_std = scaler.fit_transform(X)

在 scikit-learn 中，AgglomerativeClustering使用linkage参数来确定合并策略，来最小化（1）合并簇的方差（ward），（2）来自簇对的观测点的距离均值（average） ，或（3）来自簇对的观测之间的最大距离（complete）。

其他两个参数很有用。 首先，affinity参数确定用于linkage的距离度量（minkowski，euclidean等）。 其次，n_clusters设置聚类算法将尝试查找的聚类数。 也就是说，簇被连续合并，直到只剩下n_clusters。

  1. # 创建聚类对象
  2. clt = AgglomerativeClustering(linkage='complete', 
  3.                               affinity='euclidean', 
  4.                               n_clusters=3)
  6. # 训练模型
  7. model = clt.fit(X_std)
  9. # 展示簇的成员
  10. model.labels_
  12. '''
  13. array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  14.        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1,
  15.        1, 1, 1, 1, 0, 0, 0, 2, 0, 2, 0, 2, 0, 2, 2, 0, 2, 0, 0, 0, 0, 2, 2,
  16.        2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 0, 2, 0, 2, 2, 0,
  17.        2, 2, 2, 0, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0,
  18.        0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  19.        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]) 
  20. '''

DBSCAN 聚类

十七、聚类 - 图2

  1. # 加载库
  2. from sklearn import datasets
  3. from sklearn.preprocessing import StandardScaler
  4. from sklearn.cluster import DBSCAN
  6. # 加载数据
  7. iris = datasets.load_iris()
  8. X = iris.data
  10. # 标准化特征
  11. scaler = StandardScaler()
  12. X_std = scaler.fit_transform(X)

DBSCAN有三个要设置的主要参数：

  • eps: 观测到被认为是邻居的另一个观测的最大距离
  • min_samples: 小于上面的eps距离的最小观测数量
  • metric: eps使用的距离度量。 例如，minkowski，euclidean等（请注意，如果使用 Minkowski 距离，参数p可用于设置 Minkowski 度量的指数）

如果我们在训练数据中查看簇，我们可以看到已经识别出两个簇，“0”和“1”，而异常观测被标记为“-1”。

  1. # 创建 DBSCAN 对象
  2. clt = DBSCAN(n_jobs=-1)
  4. # 训练模型
  5. model = clt.fit(X_std)

评估聚类

  1. import numpy as np
  2. from sklearn.metrics import silhouette_score
  3. from sklearn import datasets
  4. from sklearn.cluster import KMeans
  5. from sklearn.datasets import make_blobs
  7. # 生成特征矩阵
  8. X, _ = make_blobs(n_samples = 1000,
  9.                   n_features = 10,
  10.                   centers = 2,
  11.                   cluster_std = 0.5,
  12.                   shuffle = True,
  13.                   random_state = 1)
  15. # 使用 k-means 来对数据聚类
  16. model = KMeans(n_clusters=2, random_state=1).fit(X)
  18. # 获取预测的类别
  19. y_hat = model.labels_

正式地，第 十七、聚类 - 图3 个观测的轮廓系数是：

十七、聚类 - 图4

其中 十七、聚类 - 图5 是观测 十七、聚类 - 图6 的轮廓系数，十七、聚类 - 图7 是 十七、聚类 - 图8 和同类的所有观测值之间的平均距离，而 十七、聚类 - 图9 是 十七、聚类 - 图10 和不同类的所有观测的平均距离的最小值。silhouette_score返回的值是所有观测值的平均轮廓系数。 轮廓系数介于 -1 和 1 之间，其中 1 表示密集，分离良好的聚类。

  1. # 评估模型
  2. silhouette_score(X, y_hat)
  4. # 0.89162655640721422

均值移动聚类

十七、聚类 - 图11

  1. # 加载库
  2. from sklearn import datasets
  3. from sklearn.preprocessing import StandardScaler
  4. from sklearn.cluster import MeanShift
  6. # 加载数据
  7. iris = datasets.load_iris()
  8. X = iris.data
  10. # 标准化特征
  11. scaler = StandardScaler()
  12. X_std = scaler.fit_transform(X)

MeanShift有两个我们应该注意的重要参数。 首先，bandwidth设置区域（即观测核）半径，用于确定移动方向。 在我们的比喻中，带宽是一个人可以在雾中看到的距离。 我们可以手动设置此参数，但默认情况下会自动估算合理的带宽（计算成本会显着增加）。 其次，有时在均值移动中，观测核中没有其他观测结果。 也就是说，我们足球上的一个人看不到任何其它人。 默认情况下，MeanShift将所有这些“孤例”观测值分配给最近观测核。 但是，如果我们想要留出这些孤例，我们可以设置cluster_all = False，其中孤例观测标签为 -1。

  1. # 创建 MeanShift 对象
  2. clt = MeanShift(n_jobs=-1)
  4. # 训练模型
  5. model = clt.fit(X_std)

小批量 KMeans 聚类

小批量 k-means 的工作方式与上一个方案中讨论的 k-means 算法类似。 没有太多细节，不同之处在于，在小批量 k-means中，计算成本最高的步骤仅在随机的观测样本上进行，而不是所有观测。 这种方法可以显着减少算法发现收敛（即适合数据）所需的时间，而质量成本很低。

  1. # 加载库
  2. from sklearn import datasets
  3. from sklearn.preprocessing import StandardScaler
  4. from sklearn.cluster import MiniBatchKMeans
  6. # 加载数据
  7. iris = datasets.load_iris()
  8. X = iris.data
  10. # 标准化特征
  11. scaler = StandardScaler()
  12. X_std = scaler.fit_transform(X)

MiniBatchKMeans与KMeans的工作方式类似，有一个显着性差异：batch_size参数。 batch_size控制每批中随机选择的观测数。 批量越大，训练过程的计算成本就越高。

  1. # 创建 KMeans 对象
  2. clustering = MiniBatchKMeans(n_clusters=3, random_state=0, batch_size=100)
  4. # 训练模型
  5. model = clustering.fit(X_std)

KMeans 聚类

十七、聚类 - 图12

  1. # 加载库
  2. from sklearn import datasets
  3. from sklearn.preprocessing import StandardScaler
  4. from sklearn.cluster import KMeans
  6. # 加载数据
  7. iris = datasets.load_iris()
  8. X = iris.data
  10. # 标准化特征
  11. scaler = StandardScaler()
  12. X_std = scaler.fit_transform(X)
  14. # 创建 KMeans 对象
  15. clt = KMeans(n_clusters=3, random_state=0, n_jobs=-1)
  17. # 训练模型
  18. model = clt.fit(X_std)
  20. # 查看预测类别
  21. model.labels_
  23. '''
  24. array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  25.        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  26.        1, 1, 1, 1, 0, 0, 0, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 2, 2,
  27.        2, 0, 2, 2, 2, 2, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 0, 0, 2, 2, 2, 2, 2,
  28.        2, 2, 2, 2, 2, 2, 2, 2, 0, 2, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 2, 2,
  29.        0, 0, 0, 0, 2, 0, 2, 0, 2, 0, 0, 2, 0, 0, 0, 0, 0, 0, 2, 2, 0, 0, 0,
  30.        2, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 2], dtype=int32) 
  31. '''
  33. # 创建新的观测
  34. new_observation = [[0.8, 0.8, 0.8, 0.8]]
  36. # 预测观测的类别
  37. model.predict(new_observation)
  39. # array([0], dtype=int32) 
  41. # 查看簇中心
  42. model.cluster_centers_
  44. '''
  45. array([[ 1.13597027,  0.09659843,  0.996271  ,  1.01717187],
  46.        [-1.01457897,  0.84230679, -1.30487835, -1.25512862],
  47.        [-0.05021989, -0.88029181,  0.34753171,  0.28206327]]) 
  48. '''