无监督学习探索：聚类与降维技术

原创 于 2025-08-27 00:29:37 发布 · 405 阅读 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

无监督学习探索：聚类与降维技术

本文深入探讨了无监督学习中的核心聚类算法，包括k-Means聚类、层次聚类（凝聚式聚类）和DBSCAN密度聚类。详细解析了每种算法的原理、实现方法、参数调优策略以及实际应用场景。同时介绍了聚类评估的有监督和无监督指标，为选择合适的聚类算法和评估聚类质量提供了全面指导。

k-Means聚类算法原理与实战应用

k-Means算法是机器学习中最经典的无监督学习算法之一，它通过迭代优化将数据点分配到k个簇中，使得同一簇内的数据点相似度高，不同簇间的数据点相似度低。该算法因其简单高效、易于理解和实现的特性，在数据挖掘、图像分割、客户细分等领域有着广泛应用。

算法核心原理

k-Means算法的核心思想是通过最小化簇内平方和（Within-Cluster Sum of Squares, WCSS）来实现数据聚类。算法的工作流程可以分为四个主要步骤：

初始化阶段：随机选择k个数据点作为初始聚类中心

分配阶段：将每个数据点分配到距离最近的聚类中心所在的簇

更新阶段：重新计算每个簇的质心作为新的聚类中心

收敛判断：重复分配和更新步骤，直到聚类中心不再发生变化或达到最大迭代次数

mermaid

数学表达式与距离度量

k-Means算法的目标函数定义为：

$$ J = \sum_{i=1}^{k} \sum_{x \in C_i} |x - \mu_i|^2 $$

其中：

  • $C_i$ 表示第i个簇
  • $\mu_i$ 表示第i个簇的质心
  • $|x - \mu_i|$ 表示数据点x到质心$\mu_i$的欧几里得距离

常用的距离度量方法包括：

距离度量公式适用场景
欧几里得距离$\sqrt{\sum_{i=1}^{n}(x_i - y_i)^2}$连续数值数据
曼哈顿距离$\sum_{i=1}^{n}x_i - y_i$高维稀疏数据
余弦相似度$\frac{x \cdot y}{|x| |y|}$文本数据

scikit-learn中的k-Means实现

在Python的scikit-learn库中，k-Means算法的使用非常简单：

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

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

# 创建k-Means模型
kmeans = KMeans(n_clusters=4, random_state=42)

# 训练模型
kmeans.fit(X)

# 获取聚类结果
labels = kmeans.labels_
centers = kmeans.cluster_centers_

print("聚类标签:", labels[:10])
print("聚类中心:\n", centers)
算法参数详解

k-Means算法在scikit-learn中有多个重要参数需要配置：

KMeans(
    n_clusters=8,           # 聚类数量，最重要的参数
    init='k-means++',       # 初始化方法：'k-means++'或'random'
    n_init=10,              # 不同初始化的运行次数
    max_iter=300,           # 最大迭代次数
    tol=1e-4,               # 收敛阈值
    random_state=None       # 随机种子
)

n_clusters选择策略：确定最佳聚类数量是k-Means算法的关键挑战。常用的方法包括：

  1. 肘部法则（Elbow Method）：通过绘制不同k值对应的WCSS曲线，选择拐点位置
  2. 轮廓系数（Silhouette Score）：衡量聚类质量的指标，值越接近1表示聚类效果越好
  3. Gap统计量：比较实际数据与参考分布的聚类质量差异

实战应用案例

案例1：客户细分分析
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import silhouette_score

# 数据预处理
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# 使用肘部法则确定最佳k值
wcss = []
silhouette_scores = []
k_range = range(2, 11)

for k in k_range:
    kmeans = KMeans(n_clusters=k, random_state=42)
    kmeans.fit(X_scaled)
    wcss.append(kmeans.inertia_)
    silhouette_scores.append(silhouette_score(X_scaled, kmeans.labels_))

# 绘制结果
plt.figure(figsize=(12, 4))
plt.subplot(1, 2, 1)
plt.plot(k_range, wcss, 'bo-')
plt.xlabel('Number of clusters')
plt.ylabel('WCSS')
plt.title('Elbow Method')

plt.subplot(1, 2, 2)
plt.plot(k_range, silhouette_scores, 'ro-')
plt.xlabel('Number of clusters')
plt.ylabel('Silhouette Score')
plt.title('Silhouette Analysis')
plt.tight_layout()
plt.show()
案例2：图像颜色量化

k-Means在图像处理中可用于颜色量化，减少图像中的颜色数量：

from sklearn.utils import shuffle
from PIL import Image
import numpy as np

# 加载图像
image = Image.open('example.jpg')
image = np.array(image, dtype=np.float64) / 255

# 将图像转换为二维数组
w, h, d = original_shape = tuple(image.shape)
image_array = np.reshape(image, (w * h, d))

# 使用k-Means进行颜色量化
n_colors = 16
image_array_sample = shuffle(image_array, random_state=0)[:1000]
kmeans = KMeans(n_clusters=n_colors, random_state=0).fit(image_array_sample)
labels = kmeans.predict(image_array)
compressed_image = kmeans.cluster_centers_[labels]
compressed_image = np.reshape(compressed_image, (w, h, d))

算法优缺点分析

优点：

  • 算法简单，易于理解和实现
  • 计算效率高，适合处理大规模数据集
  • 聚类结果的可解释性强

缺点：

  • 需要预先指定聚类数量k
  • 对初始聚类中心敏感，可能收敛到局部最优
  • 对噪声和异常值敏感
  • 假设簇为凸形且大小相似，对非球形簇效果不佳

性能优化技巧

  1. 数据预处理：对数据进行标准化或归一化处理
  2. 多次运行：使用不同的随机种子多次运行算法，选择最佳结果
  3. k-means++初始化：改进的初始化方法，能获得更好的初始聚类中心
  4. Mini-Batch k-Means：适用于大规模数据集的变种算法
from sklearn.cluster import MiniBatchKMeans

# 使用Mini-Batch k-Means处理大数据集
minibatch_kmeans = MiniBatchKMeans(n_clusters=4, random_state=42, batch_size=100)
minibatch_kmeans.fit(X_large)

与其他聚类算法的比较

算法优点缺点适用场景
k-Means简单高效，可扩展性好需要指定k值，对异常值敏感大规模数值数据聚类
DBSCAN不需要指定簇数，能发现任意形状的簇对参数敏感，高维数据效果差密度不均匀的数据集
层次聚类不需要指定簇数，可可视化树状图计算复杂度高，不适合大数据集小规模数据，需要层次结构

通过深入理解k-Means算法的原理和实践应用，我们能够更好地利用这一强大工具解决实际的数据聚类问题。在实际应用中，需要根据具体的数据特性和业务需求，选择合适的参数配置和优化策略。

层次聚类：凝聚式聚类算法详解

层次聚类是机器学习领域中一种强大的无监督学习技术，它通过构建数据的层次结构来揭示数据的内在关系。凝聚式聚类（Agglomerative Clustering）作为层次聚类的主要方法之一，以其直观的树状结构和无需预先指定聚类数量的优势，在数据分析和模式识别中得到了广泛应用。

算法原理与工作流程

凝聚式聚类采用自底向上的策略，将每个数据点视为一个初始簇，然后逐步合并最相似的簇，直到所有数据点都合并为一个簇或达到预设的终止条件。整个过程形成了一个层次化的树状结构，称为树状图（Dendrogram）。

mermaid

距离度量与链接准则

凝聚式聚类的核心在于如何定义簇间的距离，不同的链接准则会产生不同的聚类效果：

链接方法距离定义优点缺点
单链接两个簇中最近点之间的距离能发现非球形簇对噪声敏感，容易形成链式结构
全链接两个簇中最远点之间的距离对噪声相对鲁棒倾向于产生紧凑的球形簇
平均链接两个簇中所有点对距离的平均值平衡单链接和全链接的特性计算复杂度较高
Ward方法合并后簇内方差增加最小产生大小相近的簇对异常值敏感

Scikit-learn实现示例

在Python中，我们可以使用scikit-learn库的AgglomerativeClustering类来实现凝聚式聚类：

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

# 生成示例数据
X, y = make_blobs(n_samples=150, centers=3, cluster_std=0.6, random_state=0)

# 创建凝聚式聚类模型
agg_clustering = AgglomerativeClustering(
    n_clusters=3,          # 指定最终聚类数量
    linkage='ward',        # 使用Ward链接方法
    affinity='euclidean'   # 使用欧几里得距离
)

# 执行聚类
labels = agg_clustering.fit_predict(X)

# 可视化聚类结果
plt.figure(figsize=(10, 6))
plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis', s=50, alpha=0.8)
plt.title('凝聚式聚类结果 - Ward方法')
plt.xlabel('特征1')
plt.ylabel('特征2')
plt.colorbar()
plt.show()

树状图分析与剪枝策略

树状图是层次聚类的可视化工具，它展示了数据点如何逐步合并的过程。通过分析树状图，我们可以确定最佳的聚类数量：

from scipy.cluster.hierarchy import dendrogram, linkage
from scipy.spatial.distance import pdist

# 计算链接矩阵
Z = linkage(X, method='ward')

# 绘制树状图
plt.figure(figsize=(12, 6))
dendrogram(Z, truncate_mode='level', p=3)
plt.title('层次聚类树状图')
plt.xlabel('样本索引')
plt.ylabel('距离')
plt.axhline(y=15, color='r', linestyle='--')
plt.show()

算法复杂度与优化

凝聚式聚类的时间复杂度为O(n³)，空间复杂度为O(n²)，这限制了其在大规模数据集上的应用。为了优化性能，可以考虑以下策略：

  1. 使用更高效的距离计算：如KD树或球树加速最近邻搜索
  2. 采样技术：先对数据进行采样，再应用层次聚类
  3. 增量聚类：适用于流式数据场景
  4. 并行计算：利用多核处理器加速距离矩阵计算

实际应用场景

凝聚式聚类在多个领域都有广泛应用：

生物信息学：基因表达数据分析，发现功能相似的基因簇 社交网络分析：识别社区结构和用户群体 图像分割：将图像分成有意义的区域 文档聚类：对文本文档进行主题分类

参数调优与最佳实践

为了获得最佳的聚类效果，需要注意以下参数调优策略：

# 参数调优示例
best_score = -1
best_params = {}

for linkage_method in ['ward', 'complete', 'average', 'single']:
    for n_clusters in range(2, 10):
        model = AgglomerativeClustering(
            n_clusters=n_clusters,
            linkage=linkage_method,
            affinity='euclidean'
        )
        labels = model.fit_predict(X)
        
        # 使用轮廓系数评估聚类质量
        from sklearn.metrics import silhouette_score
        score = silhouette_score(X, labels)
        
        if score > best_score:
            best_score = score
            best_params = {
                'n_clusters': n_clusters,
                'linkage': linkage_method,
                'score': score
            }

print(f"最佳参数: {best_params}")

与其他聚类算法的比较

mermaid

凝聚式聚类以其独特的层次结构和无需预设聚类数量的优势，在探索性数据分析和模式发现中发挥着重要作用。通过合理选择链接准则和距离度量，结合树状图分析，可以获得有意义的聚类结果，为后续的数据理解和决策提供有力支持。

DBSCAN：基于密度的聚类方法

在无监督学习领域，DBSCAN（Density-Based Spatial Clustering of Applications with Noise）是一种基于密度的强大聚类算法，它能够发现任意形状的簇，并有效识别噪声点。与传统的基于距离的聚类方法（如K-means）不同，DBSCAN通过分析数据点的密度分布来识别簇结构，这使得它在处理复杂形状的数据集时表现出色。

DBSCAN的核心概念

DBSCAN算法基于两个关键参数：eps（邻域半径）和min_samples（最小样本数）。算法的工作原理如下：

mermaid

算法参数详解
参数描述默认值影响
eps邻域半径，定义点的邻域范围0.5值越大，簇越容易合并
min_samples核心点所需的最小邻域点数5值越大，对噪声越敏感

DBSCAN算法实现

在scikit-learn中，DBSCAN的实现非常简单：

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

# 生成示例数据
X, y = make_blobs(random_state=0, n_samples=12)

# 创建DBSCAN模型
dbscan = DBSCAN(eps=1.5, min_samples=2)
clusters = dbscan.fit_predict(X)

print("聚类结果:", clusters)

参数调优与可视化

DBSCAN对参数非常敏感，不同的参数组合会产生截然不同的聚类效果：

import numpy as np
from sklearn.cluster import DBSCAN

# 测试不同参数组合
param_grid = {
    'eps': [1.0, 1.5, 2.0, 3.0],
    'min_samples': [2, 3, 5]
}

results = {}
for min_samples in param_grid['min_samples']:
    for eps in param_grid['eps']:
        dbscan = DBSCAN(min_samples=min_samples, eps=eps)
        clusters = dbscan.fit_predict(X)
        results[f'min_samples={min_samples}, eps={eps}'] = clusters
        print(f"min_samples: {min_samples} eps: {eps}  cluster: {clusters}")

DBSCAN的优势与局限

优势：
  • 发现任意形状簇：不受球形假设限制
  • 自动确定簇数量：无需预先指定簇数
  • 鲁棒的噪声处理：能够有效识别和排除噪声点
  • 处理密度变化：适应不同密度的簇结构
局限：
  • 参数敏感性：对eps和min_samples参数敏感
  • 高维数据挑战：在高维空间中密度定义变得困难
  • 密度差异处理：难以处理密度差异过大的簇

实际应用示例

在人脸数据集上的DBSCAN应用：

from sklearn.decomposition import PCA
from sklearn.cluster import DBSCAN

# 使用PCA降维
pca = PCA(n_components=100, whiten=True, random_state=0)
X_pca = pca.fit_transform(X_face_data)

# 应用DBSCAN聚类
dbscan = DBSCAN(min_samples=3, eps=7)
labels = dbscan.fit_predict(X_pca)

# 分析聚类结果
n_clusters = len(set(labels)) - (1 if -1 in labels else 0)
n_noise = list(labels).count(-1)
print(f"发现簇数: {n_clusters}")
print(f"噪声点数: {n_noise}")

性能优化技巧

  1. 数据预处理：对数据进行标准化处理，确保特征尺度一致
  2. 参数网格搜索：使用网格搜索寻找最优参数组合
  3. 降维处理：在高维数据上使用PCA等降维技术
  4. 并行处理：利用多核CPU加速大规模数据处理
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import ParameterGrid

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

# 参数优化搜索
best_params = None
best_score = -1

for params in ParameterGrid({'eps': np.linspace(0.1, 2.0, 20), 'min_samples': [2, 3, 5, 10]}):
    dbscan = DBSCAN(**params)
    labels = dbscan.fit_predict(X_scaled)
    # 使用轮廓系数评估聚类质量
    if len(set(labels)) > 1:
        score = silhouette_score(X_scaled, labels)
        if score > best_score:
            best_score = score
            best_params = params

DBSCAN作为一种强大的密度聚类算法，在现实世界的许多应用中表现出色，特别是在需要发现非球形簇和处理噪声数据的场景中。通过合理的参数调优和数据预处理，DBSCAN能够提供高质量的聚类结果。

聚类评估指标：有监督与无监督评估

在机器学习实践中，聚类算法的评估是一个关键但具有挑战性的任务。与监督学习不同，聚类算法没有明确的标签来直接评估性能，因此需要专门的评估指标。本文将深入探讨聚类评估的两大类别：有监督评估和无监督评估，并通过实际代码示例展示如何在Python中应用这些指标。

有监督评估指标

有监督评估指标在已知真实标签的情况下使用，主要用于验证聚类结果与真实分类的一致性。这类指标虽然需要标签信息，但在研究和算法比较中非常重要。

调整兰德指数（Adjusted Rand Index, ARI）

调整兰德指数是衡量两个数据分配之间相似度的指标，它考虑了随机分配的可能性。ARI的取值范围为[-1, 1]，值越接近1表示聚类结果与真实标签越一致。

from sklearn.metrics.cluster import adjusted_rand_score
from sklearn.datasets import make_blobs
from sklearn.cluster import KMeans

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

# 应用K-means聚类
kmeans = KMeans(n_clusters=3, random_state=42)
clusters = kmeans.fit_predict(X)

# 计算调整兰德指数
ari_score = adjusted_rand_score(y, clusters)
print(f"调整兰德指数 (ARI): {ari_score:.3f}")

ARI的计算基于以下公式：

$$ARI = \frac{RI - E[RI]}{\max(RI) - E[RI]}$$

其中RI是兰德指数，E[RI]是随机分配的期望值。

同质性、完整性和V-measure

这三个指标从不同角度评估聚类质量：

  • 同质性（Homogeneity）：每个簇只包含单个类的成员
  • 完整性（Completeness）：给定类的所有成员都分配到同一个簇
  • V-measure：同质性和完整性的调和平均
from sklearn.metrics import homogeneity_score, completeness_score, v_measure_score

homogeneity = homogeneity_score(y, clusters)
completeness = completeness_score(y, clusters)
v_measure = v_measure_score(y, clusters)

print(f"同质性: {homogeneity:.3f}")
print(f"完整性: {completeness:.3f}")
print(f"V-measure: {v_measure:.3f}")

无监督评估指标

无监督评估指标不需要真实标签，仅基于数据本身的特征来评估聚类质量，这使得它们在实际应用中更加实用。

轮廓系数（Silhouette Coefficient）

轮廓系数衡量每个样本与其所属簇的相似度相对于其他簇的相似度。取值范围为[-1, 1]，值越接近1表示聚类效果越好。

from sklearn.metrics import silhouette_score
from sklearn.preprocessing import StandardScaler

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

# 计算轮廓系数
silhouette_avg = silhouette_score(X_scaled, clusters)
print(f"轮廓系数: {silhouette_avg:.3f}")

# 计算每个样本的轮廓系数
from sklearn.metrics import silhouette_samples
sample_silhouette_values = silhouette_samples(X_scaled, clusters)

轮廓系数的计算公式为：

$$s(i) = \frac{b(i) - a(i)}{\max{a(i), b(i)}}$$

其中$a(i)$是样本$i$到同簇其他样本的平均距离，$b(i)$是样本$i$到最近其他簇所有样本的平均距离。

Calinski-Harabasz指数

也称为方差比标准，通过计算簇间离散度与簇内离散度的比值来评估聚类质量。值越大表示聚类效果越好。

from sklearn.metrics import calinski_harabasz_score

ch_score = calinski_harabasz_score(X_scaled, clusters)
print(f"Calinski-Harabasz指数: {ch_score:.3f}")
Davies-Bouldin指数

该指数基于簇内距离和簇间距离的比值，值越小表示聚类效果越好。

from sklearn.metrics import davies_bouldin_score

db_score = davies_bouldin_score(X_scaled, clusters)
print(f"Davies-Bouldin指数: {db_score:.3f}")

评估指标选择指南

不同的评估指标适用于不同的场景，选择合适的指标至关重要：

指标类型适用场景优点局限性
有监督指标算法研究、模型比较提供客观的量化评估需要真实标签
无监督指标实际应用、无标签数据不需要标签信息可能产生误导性结果
轮廓系数各种聚类算法考虑簇内和簇间距离计算复杂度较高
Calinski-Harabasz凸形簇计算快速对非凸形簇效果差
Davies-Bouldin各种形状的簇对异常值不敏感需要预先指定簇数

实际应用示例

下面通过一个完整的示例展示如何综合使用多种评估指标：

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_moons
from sklearn.cluster import DBSCAN, KMeans
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import silhouette_score, calinski_harabasz_score

# 生成非线性可分数据
X, y = make_moons(n_samples=300, noise=0.05, random_state=42)
X_scaled = StandardScaler().fit_transform(X)

# 应用不同聚类算法
kmeans = KMeans(n_clusters=2, random_state=42)
dbscan = DBSCAN(eps=0.3, min_samples=5)

kmeans_clusters = kmeans.fit_predict(X_scaled)
dbscan_clusters = dbscan.fit_predict(X_scaled)

# 计算评估指标（仅对有效聚类）
def evaluate_clustering(X, clusters, algorithm_name):
    valid_mask = clusters != -1  # 排除噪声点（对于DBSCAN）
    if np.sum(valid_mask) > 1:  # 需要至少两个样本才能计算
        X_valid = X[valid_mask]
        clusters_valid = clusters[valid_mask]
        
        silhouette = silhouette_score(X_valid, clusters_valid)
        calinski = calinski_harabasz_score(X_valid, clusters_valid)
        
        print(f"{algorithm_name}:")
        print(f"  轮廓系数: {silhouette:.3f}")
        print(f"  Calinski-Harabasz: {calinski:.3f}")
        print(f"  聚类数量: {len(np.unique(clusters_valid))}")
    else:
        print(f"{algorithm_name}: 聚类无效")

evaluate_clustering(X_scaled, kmeans_clusters, "K-means")
evaluate_clustering(X_scaled, dbscan_clusters, "DBSCAN")

评估指标的可视化分析

为了更好地理解聚类质量，我们可以通过可视化来辅助分析：

def plot_cluster_evaluation(X, clusters, title):
    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))
    
    # 绘制聚类结果
    ax1.scatter(X[:, 0], X[:, 1], c=clusters, cmap='viridis', s=50)
    ax1.set_title(f'{title} - 聚类结果')
    
    # 绘制轮廓图
    from sklearn.metrics import silhouette_samples
    sample_silhouette_values = silhouette_samples(X, clusters)
    
    y_lower = 10
    for i in range(len(np.unique(clusters))):
        ith_cluster_silhouette_values = sample_silhouette_values[clusters == i]
        ith_cluster_silhouette_values.sort()
        
        size_cluster_i = ith_cluster_silhouette_values.shape[0]
        y_upper = y_lower + size_cluster_i
        
        ax2.fill_betweenx(np.arange(y_lower, y_upper),
                          0, ith_cluster_silhouette_values,
                          alpha=0.7)
        ax2.text(-0.05, y_lower + 0.5 * size_cluster_i, str(i))
        y_lower = y_upper + 10
    
    ax2.set_title("轮廓图")
    ax2.set_xlabel("轮廓系数值")
    ax2.set_ylabel("簇标签")
    ax2.axvline(x=silhouette_score(X, clusters), color="red", linestyle="--")
    
    plt.tight_layout()
    plt.show()

# 对K-means结果进行可视化
plot_cluster_evaluation(X_scaled, kmeans_clusters, "K-means")

高级评估技术

对于复杂的聚类场景，还可以使用更高级的评估技术：

稳定性分析

通过多次运行聚类算法并比较结果的一致性来评估稳定性：

from sklearn.utils import resample

def evaluate_cluster_stability(X, n_iterations=10):
    stability_scores = []
    
    for i in range(n_iterations):
        # 自助采样
        X_sample = resample(X, random_state=i)
        
        # 应用聚类
        kmeans = KMeans(n_clusters=2, random_state=42)
        clusters = kmeans.fit_predict(X_sample)
        
        # 计算轮廓系数
        score = silhouette_score(X_sample, clusters)
        stability_scores.append(score)
    
    return np.mean(stability_scores), np.std(stability_scores)

mean_score, std_score = evaluate_cluster_stability(X_scaled)
print(f"稳定性评估 - 平均轮廓系数: {mean_score:.3f}, 标准差: {std_score:.3f}")
聚类数量的确定

使用肘部法则和轮廓分析来确定最优聚类数量：

def find_optimal_clusters(X, max_clusters=10):
    silhouette_scores = []
    calinski_scores = []
    
    for n_clusters in range(2, max_clusters + 1):
        kmeans = KMeans(n_clusters=n_clusters, random_state=42)
        clusters = kmeans.fit_predict(X)
        
        silhouette = silhouette_score(X, clusters)
        calinski = calinski_harabasz_score(X, clusters)
        
        silhouette_scores.append(silhouette)
        calinski_scores.append(calinski)
    
    return silhouette_scores, calinski_scores

silhouette_scores, calinski_scores = find_optimal_clusters(X_scaled)

plt.figure(figsize=(12, 5))
plt.subplot(1, 2, 1)
plt.plot(range(2, 11), silhouette_scores, 'bo-')
plt.xlabel('聚类数量')
plt.ylabel('轮廓系数')
plt.title('轮廓系数 vs 聚类数量')

plt.subplot(1, 2, 2)
plt.plot(range(2, 11), calinski_scores, 'ro-')
plt.xlabel('聚类数量')
plt.ylabel('Calinski-Harabasz指数')
plt.title('Calinski-Harabasz指数 vs 聚类数量')

plt.tight_layout()
plt.show()

通过综合运用这些评估技术，我们可以全面了解聚类算法的性能，选择最适合特定数据集的聚类方法和参数配置。在实际应用中，建议同时使用多种评估指标，并结合领域知识进行综合判断。

总结

聚类算法作为无监督学习的重要组成部分，为数据分析和模式发现提供了强大工具。k-Means以其简单高效著称，层次聚类能够揭示数据层次结构，而DBSCAN则擅长处理任意形状的簇和噪声数据。在实际应用中，需要根据数据特性、业务需求选择合适的算法，并综合运用多种评估指标来验证聚类效果。通过合理的数据预处理、参数调优和算法组合，可以充分发挥聚类技术在数据挖掘中的价值，为后续的数据理解和决策提供有力支持。

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值