聚类算法：K-Means 聚类

最新推荐文章于 2025-03-01 19:55:52 发布

00&00

最新推荐文章于 2025-03-01 19:55:52 发布

阅读量3.3k

点赞数 26

分类专栏：人工智能文章标签：机器学习聚类 kmeans

本文链接：https://blog.csdn.net/Wei_sx/article/details/144703041

版权

人工智能专栏收录该内容

223 篇文章

订阅专栏

K-Means 聚类是一种广泛使用的无监督学习算法，旨在将数据集分成 K 个簇，使得同一簇内的数据点尽可能相似，而不同簇之间的数据点尽可能不同。它简单、高效，特别适合大规模数据集。下面将详细讨论 K-Means 的原理、实施步骤、优缺点、以及应用实例。

1. K-Means 聚类原理

K-Means 聚类核心思想是通过迭代优化簇心（centroid），逐步使得每个簇的内部紧凑度最优。算法主要依赖于距离度量（通常使用欧几里得距离）来度量数据点之间的相似度。

2. 关键步骤

K-Means 聚类的执行步骤如下：

步骤1 初始化：
随机选择 K 个初始簇心。这些簇心可以是从数据集中随机抽取的数据点，或者使用其他方法如 K-Means++ 进行更智能的初始化，以提高收敛速度。

        步骤2 分配步骤：
        对每个数据点，计算其与 K 个簇心之间的距离，将数据点分配给距离其最近的簇心，形成 K 个簇。
        公式：

$C_i = \{x_j \,|\, \text{argmin}_{k} \, \| x_j - \mu_k \|^2\}$

其中， $C_i$ 表示第 i 个簇， $x_j$ 是数据点， $\mu_k$ 是第 k 个簇心。

步骤3 更新步骤：

重新计算每个簇的簇心，新的簇心是当前簇中所有数据点的均值。
公式：

$\mu_k = \frac{1}{|C_k|} \sum_{x_j \in C_k} x_j$

步骤4 迭代：

重复步骤 2 和步骤 3，直到簇心不再发生显著变化（收敛），或者达到预设的最大迭代次数。

步骤5 结束：

算法停止，输出最终的簇心和数据点的簇分配。

展示 K-Means 聚类的关键步骤后，通过一个简单的计算示例来具体说明每一步是如何执行的。将使用一个小型数据集生成一些示例数据，以便更清晰地展示每个步骤。下面，将逐步进行 K-Means 的计算。

2.1. 示例数据点

假设我们有以下 6 个数据点，数据点为 2 维坐标：

        A: (1, 2)
        B: (1, 4)
        C: (1, 0)
        D: (4, 2)
        E: (4, 4)
        F: (4, 0)

目标把这些数据点分成 2 个簇 (`K=2`).

2.2 初始化簇心

随机选择 2 个初始簇心。假设选择：

簇心 1（C1）：(1, 2)
突心 2（C2）：(4, 4)

2.3 分配数据点到簇

计算每个数据点到两个簇心的欧几里得距离，并将每个数据点分配给最近的簇心。

计算距离公式：

$\text{distance} = \sqrt{(x_2 - x_1)^2 + (y_2 - y_1)^2}$

点计算：

A: (1, 2)
        到 C1 的距离： $\sqrt{(1 - 1)^2 + (2 - 2)^2} = \sqrt{0} = 0$
        到 C2 的距离： $\sqrt{(4 - 1)^2 + (4 - 2)^2} = \sqrt{9 + 4} = \sqrt{13} \approx 3.61$
        结果：A 属于簇心 1

B: (1, 4)
        到 C1 的距离： $\sqrt{(1 - 1)^2 + (4 - 2)^2} = \sqrt{0 + 4} = 2$
        到 C2 的距离： $\sqrt{(4 - 1)^2 + (4 - 4)^2} = \sqrt{9} = 3$
        结果：B 属于簇心 1

C: (1, 0)
        到 C1 的距离： $\sqrt{(1 - 1)^2 + (0 - 2)^2} = \sqrt{4} = 2$
        到 C2 的距离： $\sqrt{(4 - 1)^2 + (0 - 4)^2} = \sqrt{9 + 16} = \sqrt{25} = 5$
        结果：C 属于簇心 1

D: (4, 2)
        到 C1 的距离： $\sqrt{(4 - 1)^2 + (2 - 2)^2} = \sqrt{9} = 3$
        到 C2 的距离： $\sqrt{(4 - 4)^2 + (4 - 2)^2} = \sqrt{4} = 2$
        结果：D 属于簇心 2

E: (4, 4)
        到 C1 的距离： $\sqrt{(4 - 1)^2 + (4 - 2)^2} = \sqrt{9 + 4} = \sqrt{13} \approx 3.61$
        到 C2 的距离： $\sqrt{(4 - 4)^2 + (4 - 4)^2} = \sqrt{0} = 0$
        结果：E 属于簇心 2

F: (4, 0)
        到 C1 的距离： $\sqrt{(4 - 1)^2 + (0 - 2)^2} = \sqrt{9 + 4} = \sqrt{13} \approx 3.6$
        到 C2 的距离： $\sqrt{(4 - 4)^2 + (0 - 4)^2} = \sqrt{16} = 4$
        结果：F 属于簇心 2

2.4 结果分配

根据距离计算，数据点分配如下：

簇心 1 包含：A, B, C
簇心 2 包含：D, E, F

2.5 更新簇心

现在计算每个簇的新簇心。新簇心是各自簇中所有点的均值。

簇心 1（C1）:

$\mu_1 = \left( \frac{1 + 1 + 1}{3}, \frac{2 + 4 + 0}{3} \right) = \left( 1, \frac{6}{3} \right) = (1, 2)$

簇心 2（C2）:

$\mu_2 = \left( \frac{4 + 4 + 4}{3}, \frac{2 + 4 + 0}{3} \right) = \left( 4, \frac{6}{3} \right) = (4, 2)$

2.6 收敛检查

在此步骤中，新的簇心 (1, 2) 和 (4, 2) 与原来的簇心相同。因此，算法收敛，停止执行。

2.7 最终结果

最终的聚类结果为：

簇心 1 (1, 2)：包含数据点 A, B, C
簇心 2 (4, 2)：包含数据点 D, E, F

以上是 K-Means 聚类的关键步骤计算示例。从初始化到分配数据点，再到更新簇心，最后检查收敛情况，清楚地展示了 K-Means 聚类的基本过程。

3. K-Means 的优缺点

优点：

        简单易懂：K-Means 概念简单直观，易于理解和实现。
        计算效率高：时间复杂度通常为 $O(n \cdot k \cdot i)$ ，其中   $n$ 是样本数量， $k$ 是簇的数量， $i$ 是迭代次数。在大规模数据集上的表现良好。
        适用于大规模数据集：K-Means 可以有效处理大规模数据，适合在线学习和增量学习。

缺点：

        需要预先指定 K 值：在运行算法之前，需要对簇的数量 K 进行指定，缺乏自动确定簇数的机制。
        对初始值敏感：不同的初始簇心可能导致不同的收敛结果，且可能陷入局部最优解。
        对噪声和离群点敏感：离群点会显著影响簇心位置，从而影响聚类效果。
        假设簇呈球状：K-Means 假设簇数是同心球形的，对于非球形及不同密度的簇表现较差。

4. K-Means 的改进

为了解决 K-Means 的一些缺陷，出现了许多改进算法，如：

        K-Means++：通过智能初始化簇心，减少初始化对最终结果的影响。
        Bisecting K-Means：一种层次化的 K-Means 方法，逐步将大簇分割成小簇。
        模糊 K-Means：允许数据点同时属于多个簇，通过隶属度（membership degree）进行表示。

5. 应用场景

K-Means 聚类在很多领域有广泛的应用，包括：

        市场分析：根据客户的购买行为，将客户划分为不同的市场细分，以便进行精准营销。
        图像压缩：K-Means 可用于图像处理，通过将图像的颜色量化为 K 种颜色，降低图像文件大小。
        社交网络分析：分析用户的社交行为，将具有相似行为的用户进行分类。
        推荐系统：对用户偏好的相似性进行聚类，以生成个性化内容推荐。

6. K-Means 实现示例（Python）

以下是使用 `scikit-learn` 实现 K-Means 聚类的示例：

6.1 示例1

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

# 生成示例数据集  
X, y = make_blobs(n_samples=300, centers=4, cluster_std=0.60, random_state=0)  

# 选择簇的数量 K  
k = 4  
kmeans = KMeans(n_clusters=k)  
kmeans.fit(X)  

# 获取簇心和簇标签  
centers = kmeans.cluster_centers_  
labels = kmeans.labels_  

# 可视化结果  
plt.scatter(X[:, 0], X[:, 1], c=labels, s=30, cmap='viridis')  
plt.scatter(centers[:, 0], centers[:, 1], c='red', s=200, alpha=0.75, marker='X')  
plt.title('K-Means Clustering')  
plt.xlabel('Feature 1')  
plt.ylabel('Feature 2')  
plt.show()

6.2 示例2

import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs
from sklearn.cluster import KMeans

# 创建数据集
# X为样本特征，Y为样本簇类别， 共1000个样本，每个样本4个特征，共4个簇，
# 簇中心在[-1,-1], [0,0],[1,1], [2,2]， 簇方差分别为[0.4, 0.2, 0.2, 0.2]
X,y = make_blobs(n_samples=1000,n_features=2,centers=[[-1,1],[0,0],[1,1],[2,2]],cluster_std=[0.4,0.2,0.2,0.2],random_state=9)

# 使用k-means进行聚类
y_pred2 = KMeans(n_clusters=2,random_state=0).fit_predict(X)
y_pred3 = KMeans(n_clusters=3,random_state=0).fit_predict(X)
y_pred4 = KMeans(n_clusters=3,random_state=0).fit_predict(X)

# 可视化 K-Means 结果
y_pred2 = KMeans(n_clusters=2,random_state=0).fit_predict(X)
y_pred3 = KMeans(n_clusters=3,random_state=0).fit_predict(X)
y_pred4 = KMeans(n_clusters=4,random_state=0).fit_predict(X)

# 可视化 K-Means 结果
plt.figure(figsize=(20,8),dpi=80)
plt.subplot(1, 4, 1)  
plt.scatter(X[:,0],X[:,1],marker='o')
plt.title('raw data') 

plt.subplot(1, 4, 2)  
plt.scatter(X[:, 0], X[:, 1], c=y_pred2, s=30, cmap='viridis')  
plt.title('K-Means Clustering 2') 

plt.subplot(1, 4, 3)  
plt.scatter(X[:, 0], X[:, 1], c=y_pred3, s=30, cmap='viridis')  
plt.title('K-Means Clustering 3') 

plt.subplot(1, 4, 4)  
plt.scatter(X[:, 0], X[:, 1], c=y_pred4, s=30, cmap='viridis')  
plt.title('K-Means Clustering 4') 
# 数据集可视化

7. K 值的选择

选择合适的 K 值通常是 K-Means 聚类中最大的挑战之一。一些常用的方法包括：

        肘部法则（Elbow Method）：通过绘制不同 K 值的总平方误差（SSE）并寻找拐点来选择 K 值。
        轮廓系数（Silhouette Score）：评估每个数据点与自身簇和其他簇的相似度，选择轮廓系数较大的 K 值。
        交叉验证：使用不同的 K 值进行交叉验证，选择最佳的聚类效果。