机器学习之聚类算法——聚类效果评估可视化

忘是亡心i 2023-06-28 04:55 68阅读 0赞

我曾在机器学习之聚类算法应用篇中介绍过，聚类算法常使用轮廓系数来评估聚类效果，不过有时候并不是轮廓系数越大越好，如下面两幅图所示，图中的红色虚线表示聚类系数分数：

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2ODIyMDI5_size_16_color_FFFFFF_t_70

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2ODIyMDI5_size_16_color_FFFFFF_t_70 1

显然将簇数据设置为2的时候得到的轮廓系数最高，达到了0.705分，但是这并不一定是最好的聚类结果，显然在这个测试集中，我们有4个簇。为了将各个簇的轮廓系数以可视化的形式展现出来，辅助决策聚类参数，【机器学习】菜菜的sklearn课堂06 - 聚类算法与KMeans 中提供了对应的代码，能够绘制上面的可视化图，带有详细注释的代码见最后。

另外我已经将两份聚类可视化的代码封装，方便调参以及调用。

cluster_algos.py

第一份代码是做各个聚类算法对比的cluster_algos.py:

  1. # 不同聚类算法结果对比
  2. from sklearn.datasets import make_circles
  3. import matplotlib.pyplot as plt
  4. import numpy as np
  5. from sklearn.cluster import KMeans, DBSCAN, SpectralClustering, Birch, MeanShift, AgglomerativeClustering
  6. from sklearn.metrics import silhouette_score, silhouette_samples
  7. from sklearn.decomposition import PCA
  8. import pandas as pd
  9. import time
  10. import functools
  13. def time_cost(func):
  14.     @functools.wraps(func)
  15.     def wrapper(*args, **kwargs):
  16.         t0 = time.time()
  17.         func(*args, **kwargs)
  18.         t1 = time.time()
  19.         print(args[0],'：%.2fs' % (t1 - t0))
  20.         return func(*args, **kwargs), t1 - t0
  22.     return wrapper
  25. def load_data(file):
  26.     assert file != ''
  27.     df = pd.read_csv(file)
  28.     x = df.values
  29.     pca = PCA(n_components=2)
  30.     pca_result = pca.fit_transform(x)
  31.     return x, pca_result
  34. @time_cost
  35. def cluster_function(model_name, model, data):
  36.     y_pred = model.fit_predict(data)
  37.     return y_pred
  40. if __name__ == '__main__':
  42.     model_list = {
  43.         "AgglomerativeClustering": AgglomerativeClustering(n_clusters = 4),
  44.         "KMeans": KMeans(n_clusters = 4, random_state=10),
  45.         "DBSCAN": DBSCAN(eps=0.1),
  46.         "Birch": Birch(n_clusters=4),
  47.         "SpectralClustering": SpectralClustering(n_clusters = 4, random_state=10),
  48.         "MeanShift": MeanShift()
  49.     }
  51.     x, pca_result = load_data('./data.csv')
  53.     i = 1
  54.     fig = plt.figure(figsize=(15,10))
  55.     for model in model_list:
  56.         fig.add_subplot(2,3,i)
  57.         result = cluster_function(model, model_list[model], x)
  58.         plt.scatter(pca_result[:,0], pca_result[:,1], marker='.', c=result[0])
  59.         plt.title("{}({})".format(model, silhouette_score(x, result[0])))
  60.         plt.text(.99, .01, ('%.2fs' % (result[1])).lstrip('0'), transform=plt.gca().transAxes, horizontalalignment='right')
  61.         i += 1
  62.     plt.show()

其生成结果如下图所示：

watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI2ODIyMDI5_size_16_color_FFFFFF_t_70 2

clusters_test

第二份代码用于测试给定聚类算法情况下簇的个数的选择对结果的影响

  1. # 不同簇个数聚类结果对比
  2. from sklearn.datasets import make_circles
  3. import matplotlib.pyplot as plt
  4. import numpy as np
  5. from sklearn.cluster import KMeans, DBSCAN, SpectralClustering, Birch, MeanShift, AgglomerativeClustering
  6. from sklearn.metrics import silhouette_score, silhouette_samples
  7. from sklearn.decomposition import PCA
  8. import pandas as pd
  9. import time
  10. import functools
  11. import matplotlib.cm as cm
  14. def cluster_test(model_name, model, X, clusters_list = [2,3,4,5,6,7]):
  15.     for n_clusters in clusters_list:
  16.         if hasattr(model, "n_clusters"):
  17.             model.set_params(n_clusters = n_clusters)
  18.         elif len(clusters_list) >= 2 and n_clusters == clusters_list[1]:
  19.             print("{} do not have parameter 'n_clusters', return automatically.".format(model_name))
  20.             return
  22.         fig, (ax1, ax2) = plt.subplots(1, 2)
  23.         fig.set_size_inches(18, 7)
  25.         ax1.set_xlim([-0.1, 1])
  26.         ax1.set_ylim([0, X.shape[0] + (n_clusters + 1) * 10])
  28.         clusterer, t = cluster_function(model_name, model, X)
  29.         cluster_labels = clusterer.labels_
  30.         silhouette_avg = silhouette_score(X, cluster_labels)
  31.         print("For n_clusters = ", n_clusters, " the average silhoutte_score is ", silhouette_avg)
  32.         sample_silhouette_values = silhouette_samples(X, cluster_labels)
  34.         y_lower = 10
  35.         for i in range(n_clusters):
  36.             ith_cluster_silhouette_values = sample_silhouette_values[cluster_labels == i]
  37.             ith_cluster_silhouette_values.sort()
  38.             size_cluster_i = ith_cluster_silhouette_values.shape[0]
  39.             y_upper = y_lower + size_cluster_i
  40.             color = cm.nipy_spectral(float(i) / n_clusters)
  42.             ax1.fill_betweenx(np.arange(y_lower, y_upper), ith_cluster_silhouette_values, facecolor = color, alpha = 0.7)
  43.             ax1.text(-0.05, y_lower + 0.5 * size_cluster_i, str(i))
  44.             y_lower = y_upper + 10
  46.         ax1.set_title("The silhouette plot for the various clusters")
  47.         ax1.set_xlabel("The silhouette coefficient values")
  48.         ax1.set_ylabel("Cluster label")
  49.         ax1.axvline(x = silhouette_avg, color = 'red', linestyle = "--")
  50.         ax1.set_yticks([])
  51.         ax1.set_xticks([-0.1, 0, 0.2, 0.4, 0.6, 0.8, 1])
  53.         colors = cm.nipy_spectral(cluster_labels.astype(float) / n_clusters)
  54.         ax2.scatter(pca_result[:,0], pca_result[:,1], marker = 'o', s = 8, c = colors)
  55.         if hasattr(clusterer, 'cluster_centers_'):
  56.             centers = clusterer.cluster_centers_
  57.             ax2.scatter(centers[:, 0], centers[:, 1], marker = 'x', c = 'red', alpha = 1, s = 200)
  58.         ax2.text(.99, .01, ('%.2fs' % (t)).lstrip('0'), transform=plt.gca().transAxes, size=12,horizontalalignment='right')
  59.         ax2.set_title("The visualization of the clustered data")
  60.         ax2.set_xlabel("Feature space for the 1st feature")
  61.         ax2.set_ylabel("Feature space for the 2nd feature")
  63.         plt.suptitle("Silhouette analysis for {} clustering on sample data with n_clusters = {} ({})".format(model_name, n_clusters, silhouette_avg), fontsize = 14, fontweight="bold")
  64.         plt.show()
  67. def time_cost(func):
  68.     @functools.wraps(func)
  69.     def wrapper(*args, **kwargs):
  70.         t0 = time.time()
  71.         func(*args, **kwargs)
  72.         t1 = time.time()
  73.         return func(*args, **kwargs), t1 - t0
  74.     return wrapper
  77. @time_cost
  78. def cluster_function(model_name, model, data):
  79.     model = model.fit(data)
  80.     return model
  83. def load_data(file):
  84.     assert file != ''
  85.     df = pd.read_csv(file)
  86.     x = df.values
  87.     pca = PCA(n_components=2)
  88.     pca_result = pca.fit_transform(x)
  89.     return x, pca_result
  92. # 加载数据
  93. x, pca_result = load_data('data.csv')
  95. cluster_test("AgglomerativeClustering", AgglomerativeClustering(), x)

绘图代码详细解释

此原始代码来自【机器学习】菜菜的sklearn课堂06 - 聚类算法与KMeans

  1. import numpy as np
  2. import matplotlib.cm as cm
  3. from sklearn.metrics import silhouette_score, silhouette_samples
  4. from sklearn.datasets import make_blobs
  5. from sklearn.cluster import KMeans
  7. X, y = make_blobs(n_samples=500, n_features=2, centers=4, random_state = 1)
  9. for n_clusters in [2,3,4,5,6,7]:
  10.     n_clusters = n_clusters
  12.     # 创建画布，画布上共有一行两列两个子图
  13.     fig, (ax1, ax2) = plt.subplots(1, 2)
  15.     # 画布尺寸
  16.     fig.set_size_inches(18, 7)
  18.     ax1.set_xlim([-0.1, 1])
  19.     ax1.set_ylim([0, X.shape[0] + (n_clusters + 1) * 10])
  21.     # 聚类
  22.     clusterer = KMeans(n_clusters = n_clusters, random_state = 10).fit(X)
  23.     cluster_labels = clusterer.labels_
  25.     # 使用轮廓系数分数
  26.     silhouette_avg = silhouette_score(X, cluster_labels)
  27.     print("For n_clusters = ", n_clusters, " the average silhoutte_score is ", silhouette_avg)
  29.     # 调用silhouette_samples，返回每个样本点的轮廓系数，这就是我们的横坐标
  30.     sample_silhouette_values = silhouette_samples(X, cluster_labels)
  32.     # 设定y轴上的初始取值
  33.     y_lower = 10
  35.     # 对每一个簇进行循环
  36.     for i in range(n_clusters):
  37.         # 从每个样本的轮廓系数中抽取出第i个簇的轮廓系数，并对他进行排序
  38.         ith_cluster_silhouette_values = sample_silhouette_values[cluster_labels == i]
  40.         # 排序
  41.         ith_cluster_silhouette_values.sort()
  43.         # 查看这个簇中有多少个样本
  44.         size_cluster_i = ith_cluster_silhouette_values.shape[0]
  46.         # 这一个簇在y轴上从上往下画图的起点
  47.         y_upper = y_lower + size_cluster_i
  49.         # colormap库中的，使用小数来调用颜色的函数
  50.         color = cm.nipy_spectral(float(i) / n_clusters)
  52.         ax1.fill_betweenx(np.arange(y_lower, y_upper), ith_cluster_silhouette_values, facecolor = color, alpha = 0.7)
  54.         # 为每个簇的轮廓系数写上簇的编号
  55.         ax1.text(-0.05, y_lower + 0.5 * size_cluster_i, str(i))
  57.         # 为下一个簇计算新的y周上的初始值
  58.         y_lower = y_upper + 10
  60.     # 给图1加上标题
  61.     ax1.set_title("The silhouette plot for the various clusters")
  62.     ax1.set_xlabel("The silhouette coefficient values")
  63.     ax1.set_ylabel("Cluster label")
  65.     # 把整个数据集上的轮廓系数的均值以虚线的形式放入我们的图中
  66.     ax1.axvline(x = silhouette_avg, color = 'red', linestyle = "--")
  68.     # 让y轴不显示任何刻度
  69.     ax1.set_yticks([])
  71.     # 设置x轴刻度
  72.     ax1.set_xticks([-0.1, 0, 0.2, 0.4, 0.6, 0.8, 1])
  74.     # 开始对第二个图进行处理
  75.     colors = cm.nipy_spectral(cluster_labels.astype(float) / n_clusters)
  77.     ax2.scatter(X[:,0], X[:,1], marker = 'o', s = 8, c = colors)
  79.     # 把生成的质心放到图像中去
  80.     centers = clusterer.cluster_centers_
  81.     ax2.scatter(centers[:, 0], centers[:, 1], marker = 'x', c = 'red', alpha = 1, s = 200)
  83.     # 为图二设置标题
  84.     ax2.set_title("The visualization of the clustered data")
  85.     ax2.set_xlabel("Feature space for the 1st feature")
  86.     ax2.set_ylabel("Feature space for the 2nd feature")
  88.     # 为整个图设置标题
  89.     plt.suptitle("Silhouette analysis for KMeans clustering on sample data with n_clusters = {}".format(n_clusters), fontsize = 14, fontweight="bold")
  90.     plt.show()

（完）

发表评论

表情：
评论列表 （有 0 条评论，68人围观）

还没有评论，来说两句吧...

相关阅读

    相关 机器学习算法之KMeans聚类

    算法原理 聚类指的是把集合，分组成多个类，每个类中的对象都是彼此相似的。K-means是聚类中最常用的方法之一，它是基于点与点距离的相似度来计算最佳类别归属。 在使用该

    以你之姓@以你之姓@/ 0 赞/ 114 阅读

    相关 聚类效果评估指标总结

    前言 实际工作中经常会用到一些聚类算法对一些数据进行聚类处理，如何评估每次聚类效果的好坏？可选的方法有1、根据一些聚类效果的指标来评估；2、直接打点。今天就主要总结下这段

    小灰灰小灰灰/ 0 赞/ 2030 阅读