Python 机器学习 聚类算法

1、K-均值聚类（K-Means Clustering）

K-均值聚类（K-Means Clustering）是一种广泛使用的机器学习算法，它属于无监督学习算法。这种算法试图将数据分成预先指定数量的簇，使得同一簇内的数据点相似度高，而不同簇内的数据点相似度低。

初始化过程中，通过随机选择K个数据点作为起始的簇中心（质心）开始。接着，在分配阶段，每个数据点会被分配给与其距离最小的簇中心，确保每个数据点归属于最近的簇。随后的更新阶段要求对每个簇重新计算中心，通常采取簇内所有点的均值作为新的簇中心。此过程不断重复，即不停地执行分配和更新步骤，直到满足结束条件：簇中心不再发生显著变化，或者变化非常小，或者达到了预先设置的迭代次数上限。此过程是很多聚类算法中的核心步骤，可以通过不断优化簇中心的位置，来提高聚类的准确性和效率。

K-均值聚类算法的关键参数是K，即预先设定的簇的数量。选择合适的K值是实现好的聚类效果的关键。不同的K值会导致聚类结果的显著不同，通常需要依据具体问题和数据集的特性来决定。有多种方法可以帮助确定最佳的K值，如肘方法（Elbow Method）和轮廓系数（Silhouette Coefficient）。Python 的scikit-learn 库中，K-means 算法由 KMeans 类提供，它有多个参数可以调整算法的行为。常用参数如下，

使用示例，

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

# 生成样本数据
n_samples = 300
random_state = 42
X, _ = make_blobs(n_samples=n_samples, random_state=random_state)

# 设置KMeans聚类
kmeans = KMeans(n_clusters=3,            # 聚类中心的数量
                init='k-means++',        # 初始化中心点的方法
                n_init=10,               # 不同质心种子的运行次数
                max_iter=300,            # 最大迭代次数
                tol=1e-4,                # 收敛的容忍度
                random_state=random_state)# 随机数种子，确保可重复性

# 对数据进行聚类
kmeans.fit(X)

# 预测每个样本的簇标签
labels = kmeans.labels_

# 获取聚类中心
centers = kmeans.cluster_centers_

# 绘制样本和聚类中心
plt.scatter(X[:, 0], X[:, 1], c=labels, s=50, cmap='viridis')
plt.scatter(centers[:, 0], centers[:, 1], c='red', s=200, alpha=0.5)
plt.title("KMeans cjavapy")
plt.xlabel("Feature 1")
plt.ylabel("Feature 2")
plt.draw()
plt.show()

2、层次聚类（Hierarchical Clustering）

层次聚类（Hierarchical Clustering）是一种常用的聚类算法，它旨在通过构建一个聚类层次来组织数据，可以是自底向上的聚合（Agglomerative）方式，也可以是自顶向下的分裂（Divisive）方式。此算法不需要预先指定聚类的数量，非常适合于那些聚类结构未知或者聚类数量不确定的数据集。

在聚合方法中，每个数据点最初被视为一个独立的聚类，然后算法逐步将最相似的聚类合并，直至形成一个全局聚类或满足特定条件。相反，分裂方法从将所有数据视为一个整体聚类开始，逐步将其分裂成最不相似的子聚类，直到每个聚类只包含单个数据点或达到特定条件。在这个过程中，聚类之间的相似度可以通过不同的度量方式来计算，包括单链接、完全链接、平均链接和中心链接方法，分别基于聚类中点对的最近距离、最远距离、平均距离和聚类中心点之间的距离来定义聚类间的相似度。AgglomerativeClustering 是 scikit-learn（一个 Python 机器学习库）中的一种层次聚类算法。常用参数如下，

使用示例，

# 导入必要的库
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import AgglomerativeClustering
from sklearn.datasets import make_blobs

# 生成样本数据
X, y = make_blobs(n_samples=150, centers=3, cluster_std=1.0, random_state=42)

# 创建 AgglomerativeClustering 模型
agg_clustering = AgglomerativeClustering(n_clusters=3, metric='euclidean', linkage='ward')

# 拟合模型
y_pred = agg_clustering.fit_predict(X)

# 可视化结果
plt.figure(figsize=(10, 7))
plt.scatter(X[:, 0], X[:, 1], c=y_pred, cmap='viridis', marker='o', edgecolor='k')

# 标注
plt.title('cjavapy')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.draw()
plt.show()

3、DBSCAN（Density-Based Spatial Clustering of Applications with Noise）

DBSCAN（Density-Based Spatial Clustering of Applications with Noise）是一种基于密度的空间聚类算法，它能够将高密度区域的数据点归为同一个簇，适用于发现任意形状的簇并能够在噪声中识别出样本点。DBSCAN算法的主要优势是不需要预先指定簇的数量，能够识别出噪声点，并且对数据集的形状和大小不敏感。DBSCAN工作原理是先为每个点计算其eps邻域内的点数；如果某点的eps邻域内至少有min_samples个点，则该点被认定为核心点。核心点及其密度可达的点形成一个簇。对每个核心点，如果它还未归属于任何簇，就创建一个新的簇，并将其eps邻域内的所有点归入该簇，递归地应用这一过程。那些既不是核心点也不是核心点密度可达的点，被视为噪声。这种方法的优势在于其对于噪声的鲁棒性以及能够发现非线性分布的簇，而且不需要像K-means算法那样预先指定簇的数目。DBSCAN 类是 scikit-learn 中的一种基于密度的聚类算法，常用参数如下，

使用代码，

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

# 生成数据：两个半月形
X, labels_true = make_moons(n_samples=300, noise=0.1, random_state=42)

# 数据标准化
X = StandardScaler().fit_transform(X)

# DBSCAN模型
dbscan = DBSCAN(eps=0.3, min_samples=10, metric='euclidean', algorithm='auto', leaf_size=30, n_jobs=-1)

# 模型拟合
dbscan.fit(X)

# 获取聚类标签
labels = dbscan.labels_

# 聚类结果的核心样本索引
core_samples_mask = np.zeros_like(dbscan.labels_, dtype=bool)
core_samples_mask[dbscan.core_sample_indices_] = True

# 聚类数量，忽略噪声点（如果存在）
n_clusters_ = len(set(labels)) - (1 if -1 in labels else 0)
n_noise_ = list(labels).count(-1)

print('Estimated number of clusters: %d' % n_clusters_)
print('Estimated number of noise points: %d' % n_noise_)

# 绘制结果
plt.figure(figsize=(10, 6))
# 黑色被用来表示噪声。
unique_labels = set(labels)
colors = [plt.cm.Spectral(each) for each in np.linspace(0, 1, len(unique_labels))]
for k, col in zip(unique_labels, colors):
    if k == -1:
        # 黑色用于噪声。
        col = [0, 0, 0, 1]

    class_member_mask = (labels == k)

    # 绘制核心点
    xy = X[class_member_mask & core_samples_mask]
    plt.plot(xy[:, 0], xy[:, 1], 'o', markerfacecolor=tuple(col), markeredgecolor='k', markersize=14)

    # 绘制非核心点
    xy = X[class_member_mask & ~core_samples_mask]
    plt.plot(xy[:, 0], xy[:, 1], 'o', markerfacecolor=tuple(col), markeredgecolor='k', markersize=6)

plt.title('Estimated number of clusters: %d' % n_clusters_)
plt.show()

4、谱聚类（Spectral Clustering）

谱聚类（Spectral Clustering）是一种基于图的聚类算法，用于发现数据的组结构。它不直接在原始特征空间上进行聚类，而是通过分析数据的相似度矩阵来进行，能够识别出复杂形状的数据集群，并且对于数据集中的噪声也具有较好的鲁棒性。Scikit-learn 的 SpectralClustering 类是一种基于图论的聚类方法，常用参数如下，

使用代码，

from sklearn.cluster import SpectralClustering
from sklearn.datasets import make_moons
import matplotlib.pyplot as plt

# 生成一些用于聚类的模拟数据
X, _ = make_moons(n_samples=300, noise=0.1, random_state=42)

# 配置 SpectralClustering
clustering = SpectralClustering(n_clusters=2,
                                eigen_solver='arpack',
                                affinity='nearest_neighbors',
                                n_neighbors=10,
                                assign_labels='kmeans',
                                random_state=42)

# 应用聚类
labels = clustering.fit_predict(X)

# 可视化聚类结果
plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis', edgecolors='k')
plt.title('cjavapy')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.draw()
plt.show()

5、均值漂移聚类（Mean Shift Clustering）

均值漂移聚类（Mean Shift Clustering）是一种非参数的密度估计聚类算法，它不需要事先指定聚类的数量。均值漂移算法的基本思想是迭代地更新候选聚类中心，使其向数据点密度最大的区域移动，直至收敛。MeanShift 是 scikit-learn 中的一个非参数估计方法，用于寻找样本空间中的密度峰值。常用参数如下，

使用代码，

from itertools import cycle
import numpy as np
from sklearn.cluster import MeanShift, estimate_bandwidth
from sklearn.datasets import make_blobs
import matplotlib.pyplot as plt

# 生成一些样本数据
centers = [[1, 1], [-1, -1], [1, -1]]
X, _ = make_blobs(n_samples=1000, centers=centers, cluster_std=0.6)

# 使用estimate_bandwidth自动估计bandwidth值
bandwidth = estimate_bandwidth(X, quantile=0.2, n_samples=500)

# 初始化MeanShift
ms = MeanShift(bandwidth=bandwidth, bin_seeding=True)

# 对数据应用聚类
ms.fit(X)

# 提取聚类标签和聚类中心
labels = ms.labels_
cluster_centers = ms.cluster_centers_

# 获取聚类的数量（标签中的唯一值数量）
labels_unique = np.unique(labels)
n_clusters_ = len(labels_unique)

print("Number of estimated clusters : %d" % n_clusters_)

# 绘制结果
plt.figure(1)
plt.clf()

colors = cycle('bgrcmykbgrcmykbgrcmykbgrcmyk')
for k, col in zip(range(n_clusters_), colors):
    my_members = labels == k
    cluster_center = cluster_centers[k]
    plt.plot(X[my_members, 0], X[my_members, 1], col + '.')
    plt.plot(cluster_center[0], cluster_center[1], 'o', markerfacecolor=col,
             markeredgecolor='k', markersize=14)
plt.title('Estimated number of clusters: %d' % n_clusters_)
plt.show()

6、高斯混合模型（Gaussian Mixture Models, GMM）

高斯混合模型（Gaussian Mixture Models, GMM）是一种概率模型，它假设所有的数据点都是由有限个高斯分布的混合生成的。每个高斯分布被称为一个“成分”，并且每个成分都具有自己的均值（mean）和协方差矩阵（covariance matrix），用于描述该成分的数据点的分布情况。高斯混合模型是一种软聚类方法，不同于K-means这样的硬聚类方法，它允许一个数据点以一定的概率属于多个聚类。Python中，可以使用scikit-learn库中的GaussianMixture类来实现高斯混合模型。常用参数如下，

使用代码，

# 导入必要的库
import numpy as np
import matplotlib.pyplot as plt
from sklearn.mixture import GaussianMixture
from sklearn.datasets import make_blobs

# 生成模拟数据
X, y_true = make_blobs(n_samples=400, centers=2, cluster_std=0.60, random_state=0)
X = X[:, ::-1]  # 交换列是为了方便绘图

# 创建 GaussianMixture 模型实例
gmm = GaussianMixture(n_components=2, covariance_type='full', tol=1e-3, max_iter=100, n_init=1)

# 拟合数据
gmm.fit(X)

# 预测数据点的标签
labels = gmm.predict(X)

# 绘制结果
plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis', zorder=2)
plt.scatter(gmm.means_[:, 0], gmm.means_[:, 1], c='red', marker='X', s=100, zorder=3)

plt.title('Gaussian Mixture Model')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.show()