目录

• 引言
• 解答上期作业：K-Means实践
• 一、层次聚类（Hierarchical Clustering）
• 二、DBSCAN：基于密度的聚类
• 三、Mean Shift：均值漂移
• 四、高斯混合模型GMM
• 五、各种聚类算法对比总结
• 动手实践：不同算法对比实验
• 本期作业
• 总结
• 附录：核心知识点速查表

引言

上一篇我们学习了最经典的K-Means聚类，但K-Means也有缺点：需要指定K、对异常敏感、只能处理球形簇。所以还有很多其他聚类算法，各有各的适用场景。

本文我们介绍四种常见聚类算法：层次聚类、DBSCAN、Mean Shift、高斯混合模型GMM，每个都讲清楚原理、优缺点、适用场景，配可运行代码。读完这篇，你就知道什么场景用什么聚类算法了。

解答上期作业：K-Means实践

在上一篇 K-Means聚类 的尾声，我们留下了实践作业，现在让我们一起揭晓答案。

核心任务：4个簇模拟数据K-Means实践

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score

# 1. 生成4个簇的模拟数据
X, y_true = make_blobs(n_samples=500, centers=4, cluster_std=0.5, random_state=42)

# 2. 肘部法则找K
k_range = range(1, 11)
sse = []
for k in k_range:
    kmeans = KMeans(n_clusters=k, random_state=42, n_init=10)
    kmeans.fit(X)
    sse.append(kmeans.inertia_)

# 画肘部图
plt.figure(figsize=(8, 4))
plt.plot(k_range, sse, 'o-', linewidth=2)
plt.xlabel('K (簇数)')
plt.ylabel('SSE (簇内平方和)')
plt.title('Elbow Method on 4 Blobs')
plt.grid(True, alpha=0.3)
plt.show()

# 3. 轮廓系数
sil_scores = []
for k in k_range[1:]:
    kmeans = KMeans(n_clusters=k, random_state=42, n_init=10)
    labels = kmeans.fit_predict(X)
    sil_scores.append(silhouette_score(X, labels))

plt.figure(figsize=(8, 4))
plt.plot(k_range[1:], sil_scores, 'o-', linewidth=2)
plt.xlabel('K (簇数)')
plt.ylabel('Silhouette Score')
plt.title('Silhouette Score on 4 Blobs')
plt.grid(True, alpha=0.3)
plt.show()

# 4. 找出最佳K，可视化结果
best_k = k_range[1:][np.argmax(sil_scores)]
print(f"轮廓系数最大的K: {best_k}")

kmeans = KMeans(n_clusters=best_k, random_state=42, n_init=10)
labels = kmeans.fit_predict(X)
centers = kmeans.cluster_centers_

plt.figure(figsize=(8, 6))
plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis', alpha=0.7)
plt.scatter(centers[:, 0], centers[:, 1], c='red', marker='X', s=200, label='Centers')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.title(f'K-Means Clustering (K={best_k})')
plt.legend()
plt.show()

print(f"SSE: {kmeans.inertia_:.4f}")
print(f"轮廓系数: {silhouette_score(X, labels):.4f}")

结果分析：

• 肘部法则在K=4处有明显的拐点
• 轮廓系数在K=4处最大
• K-Means完美找到了4个簇，结果和真实一致

进阶任务：鸢尾花数据集K=2/3/4对比

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score, adjusted_rand_score
from sklearn.preprocessing import StandardScaler

# 加载数据
iris = load_iris()
X = iris.data
y_true = iris.target
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# 尝试K=2,3,4
for k in [2, 3, 4]:
    kmeans = KMeans(n_clusters=k, random_state=42, n_init=10)
    labels = kmeans.fit_predict(X_scaled)
    sil = silhouette_score(X_scaled, labels)
    ari = adjusted_rand_score(y_true, labels)
print(f"K={k}: 轮廓系数={sil:.4f}, ARI={ari:.4f}")

# 可视化
    plt.figure(figsize=(8, 6))
    plt.scatter(X_scaled[:, 0], X_scaled[:, 1], c=labels, cmap='viridis')
    plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1],
                c='red', marker='X', s=200)
    plt.xlabel(iris.feature_names[0])
    plt.ylabel(iris.feature_names[1])
    plt.title(f'K-Means Clustering on Iris (K={k})')
    plt.show()

典型结果：

K=2: 轮廓系数=0.4701, ARI=0.5631
K=3: 轮廓系数=0.4500, ARI=0.6589
K=4: 轮廓系数=0.4102, ARI=0.6307

结论：轮廓系数和ARI都在K=3时最好，和真实类别数一致。

一、层次聚类（Hierarchical Clustering）

原理简介

层次聚类就是一层一层地聚类，主要分两种：

• 自底向上（凝聚）
  一开始每个样本自己是一个簇，然后不断把最近的两个簇合并，直到得到想要的簇数。这是最常用的。
• 自顶向下（分裂）
  一开始所有样本是一个簇，然后不断分裂，直到每个样本自己是一个簇。很少用。

凝聚层次聚类步骤：

1. 每个样本初始化为一个簇
2. 计算所有簇之间的距离，找到距离最近的两个簇，合并它们
3. 重复步骤2，直到得到K个簇，停止

链接方式

两个簇之间的距离怎么算？常见三种：

代码实战

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs
from sklearn.cluster import AgglomerativeClustering
from scipy.cluster.hierarchy import dendrogram, linkage

# 生成数据
X, y_true = make_blobs(n_samples=50, centers=3, random_state=42)

# 层次聚类
agg = AgglomerativeClustering(n_clusters=3, linkage='average')
labels = agg.fit_predict(X)

# 可视化结果
plt.figure(figsize=(8, 6))
plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis')
plt.title('Hierarchical Clustering (Average Linkage, K=3)')
plt.show()

# 画树状图（dendrogram）
plt.figure(figsize=(10, 4))
Z = linkage(X, method='average')
dendrogram(Z)
plt.title('Dendrogram (Hierarchical Clustering)')
plt.xlabel('Sample Index')
plt.ylabel('Distance')
plt.show()

树状图能让你清晰看到聚类是怎么一层层合并的，在树状图上切断就能得到对应簇数。

优缺点总结

适用场景：

• 样本量不大（几千以内）
• 需要看到聚类的层次结构
• 不清楚有多少个簇，可以看树状图

二、DBSCAN：基于密度的聚类

原理简介

DBSCAN是基于密度的聚类，它不需要预先指定K，能自动发现任意形状的簇，还能自动识别噪声点。这是它比K-Means最大的优点。

核心概念

• ε邻域
  以某个点为中心，半径ε范围内的区域
• 核心点
  ε邻域内至少包含MinPts个样本 → 这个点在高密度区域
• 边界点
  ε邻域内样本数少于MinPts，但落在某个核心点的邻域内
• 噪声点
  既不是核心点也不是边界点 → 离群点/异常

算法步骤

1. 随机选一个未访问的点p
2. 如果p是核心点，找出所有从p密度可达的点，形成一个簇
3. 如果p是边界点，换一个点继续
4. 重复直到所有点都访问过

核心思想： "簇"是高密度连接区域，低密度区域把不同簇分开，低密度区域的点就是噪声。

代码实战

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_moons, make_blobs
from sklearn.cluster import DBSCAN
from sklearn.preprocessing import StandardScaler

# 例子1：月牙形数据（非凸，K-Means搞不定）
X, y_true = make_moons(n_samples=200, noise=0.05, random_state=42)
X = StandardScaler().fit_transform(X)

# DBSCAN
dbscan = DBSCAN(eps=0.3, min_samples=5)
labels = dbscan.fit_predict(X)

# 可视化
plt.figure(figsize=(8, 6))
unique_labels = set(labels)
colors = [plt.cm.viridis(each / (len(unique_labels) - 1)) for each in unique_labels]
for label, color inzip(unique_labels, colors):
if label == -1:
        color = (0, 0, 0, 1)  # 噪声点黑色
    mask = labels == label
    plt.scatter(X[mask, 0], X[mask, 1], color=color, label=f'Cluster {label}'if label != -1else'Noise')
plt.title('DBSCAN on Moons Data')
plt.legend()
plt.show()

print(f"发现簇数: {len(set(labels)) - (1if -1in labels else0)}")
print(f"噪声点数: {sum(labels == -1)}")

DBSCAN能完美把两个月牙分开，而K-Means在这个例子上会失败。

优缺点总结

适用场景：

• 簇形状不规则（非球形）
• 不知道K是多少
• 存在噪声/异常点需要自动识别

三、Mean Shift：均值漂移

原理简介

Mean Shift（均值漂移）是基于密度梯度上升的聚类算法：

核心思路：

1. 每个点朝着密度更高的方向移动
2. 最终，所有点都会收敛到密度峰值附近
3. 每个密度峰值就是一个簇中心

优点：

• 不需要预先指定K，自动发现簇
• 能处理任意形状簇
• 只有一个参数（带宽bandwidth）

缺点：

• 计算量大，大数据慢
• 对带宽参数敏感
• 高维数据效果不好

代码实战

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs
from sklearn.cluster import MeanShift

# 生成数据
X, y_true = make_blobs(n_samples=300, centers=4, cluster_std=0.6, random_state=42)

# Mean Shift聚类
ms = MeanShift(bandwidth=None)  # bandwidth自动估计
ms.fit(X)
labels = ms.labels_
centers = ms.cluster_centers_

print(f"自动发现簇数: {len(np.unique(labels))}")

# 可视化
plt.figure(figsize=(8, 6))
plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis', alpha=0.7)
plt.scatter(centers[:, 0], centers[:, 1], c='red', marker='X', s=200, label='Centers')
plt.title('Mean Shift Clustering')
plt.legend()
plt.show()

优缺点总结

适用场景：

• 不知道K
• 簇形状不规则
• 样本量不大

四、高斯混合模型GMM

原理简介

高斯混合模型（Gaussian Mixture Model，GMM）假设：所有数据是由多个高斯分布混合生成的，每个高斯分布就是一个簇。我们需要估计每个高斯分布的参数（均值、协方差），然后计算每个样本属于每个高斯分布的概率。

一句话：GMM假设每个簇服从高斯分布，用EM算法估计参数。

EM算法求解

GMM用EM算法迭代求解：

1. E步
   固定参数，计算每个样本属于每个成分的后验概率
2. M步
   固定后验概率，更新每个高斯成分的参数（均值、协方差、混合系数）
3. 重复E步和M步，直到收敛

硬聚类vs软聚类

GMM给出的是概率，你可以选概率最大的作为簇分配，也可以保留概率做后续分析。

代码实战

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs
from sklearn.mixture import GaussianMixture
from sklearn.preprocessing import StandardScaler

# 生成数据
X, y_true = make_blobs(n_samples=300, centers=3, random_state=42)
X = StandardScaler().fit_transform(X)

# GMM聚类
gmm = GaussianMixture(n_components=3, random_state=42)
gmm.fit(X)
labels = gmm.predict(X)
means = gmm.means_
probs = gmm.predict_proba(X)

print(f"混合系数: {gmm.weights_}")
print(f"均值:\n{means}")

# 可视化
plt.figure(figsize=(8, 6))
plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis', alpha=0.7)
plt.scatter(means[:, 0], means[:, 1], c='red', marker='X', s=200, label='Means')
plt.title('Gaussian Mixture Model Clustering (K=3)')
plt.legend()
plt.show()

# 输出第一个样本的概率
print(f"\n第一个样本属于各簇概率: {probs[0]}")

优缺点总结

适用场景：

• 需要概率输出
• 簇大致是椭圆形（高斯分布）
• 希望得到软分配

五、各种聚类算法对比总结

快速选择指南：

1. 大数据，球形簇，知道大概K
    → K-Means
2. 不知道K，形状不规则，有噪声
    → DBSCAN
3. 小数据，需要层次结构
    → 层次聚类
4. 需要概率输出，簇大致高斯
    → GMM
5. 不知道K，形状不规则，小数据
    → Mean Shift

动手实践：不同算法对比实验

我们用月牙形数据对比K-Means和DBSCAN：

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_moons
from sklearn.cluster import KMeans, DBSCAN, AgglomerativeClustering
from sklearn.mixture import GaussianMixture
from sklearn.preprocessing import StandardScaler

# 生成月牙数据
X, y_true = make_moons(n_samples=200, noise=0.05, random_state=42)
X = StandardScaler().fit_transform(X)

# 四种算法对比
algorithms = [
    ('K-Means (K=2)', KMeans(n_clusters=2, random_state=42, n_init=10)),
    ('DBSCAN', DBSCAN(eps=0.3, min_samples=5)),
    ('Hierarchical (K=2)', AgglomerativeClustering(n_clusters=2, linkage='average')),
    ('GMM (K=2)', GaussianMixture(n_components=2, random_state=42))
]

plt.figure(figsize=(16, 10))
for i, (name, algo) inenumerate(algorithms):
    labels = algo.fit_predict(X)
    plt.subplot(2, 2, i+1)
    unique_labels = set(labels)
for label in unique_labels:
if label == -1:
            color = (0, 0, 0, 1)
else:
            color = plt.cm.viridis(label / (len(unique_labels) - 1)) iflen(unique_labels) > 1else (0.5, 0.5, 0.5, 1)
        mask = labels == label
        plt.scatter(X[mask, 0], X[mask, 1], color=color, alpha=0.7)
    plt.title(name)
    plt.xlabel('Feature 1')
    plt.ylabel('Feature 2')

plt.tight_layout()
plt.show()

运行这段代码，你会清楚看到：

• K-Means把两个月牙错分成左右两块，因为它假设球形簇
• DBSCAN完美认出两个月牙，还能识别噪声
• 层次聚类和GMM在这个例子上也不如DBSCAN

本期作业

现在轮到你练习了，请完成以下任务：

核心任务

使用 make_blobs 生成有3个簇的数据，对比三种聚类算法：

1. K-Means（K=3）
2. DBSCAN（不指定K）
3. GMM（K=3）
4. 可视化结果，对比差异

进阶任务

1. 使用 make_moons 生成月牙数据
2. 分别用K-Means和DBSCAN聚类
3. 可视化结果，说说为什么K-Means效果差，DBSCAN效果好

思考题

1. 硬聚类和软聚类有什么区别？GMM为什么是软聚类？
2. DBSCAN怎么定义核心点、边界点、噪声点？
3. 层次聚类的自底向上和自顶向下有什么区别？
4. 什么场景下你会选择DBSCAN而不是K-Means？
5. 高斯混合模型和K-Means有什么联系和区别？

总结

我们介绍了四种常见的聚类算法，各有各的适用场景：

• 层次聚类
  小数据，需要层次结构，可以看树状图选K
• DBSCAN
  基于密度，不需要指定K，能处理任意形状，自动识别噪声，这是它最大的优点
• Mean Shift
  不需要指定K，基于密度峰值，对带宽敏感
• GMM
  概率模型，软聚类，给出样本属于每个簇的概率

记住一句话：没有最好的聚类算法，只有最适合你场景的聚类算法。先试试K-Means，不行再根据你的数据特点选其他算法。

提醒：请运行文中代码，完成本期作业，实践出真知。

附录：核心知识点速查表

关键概念：

选择口诀：

• 大数据球形簇知道K → K-Means
• 不知道K形状不规则 → DBSCAN
• 需要概率软分配 → GMM
• 小数据要层次 → 层次聚类