一、真实场景：K-Means分群被业务打回三版

2024年3月，运营部门给了我一个任务：把平台20000个活跃用户分成5类，做差异化运营策略。这活儿听着简单，我直接上了K-Means，sklearn一行代码跑完，输出Excel交差。

结果被业务打了回来，理由是「这几群人有啥区别？你看这群人均消费300，那群也300，分跟没分一样」。

我复查了数据才发现三个问题：

• 特征量纲差距过大：消费金额（几百到几万）和登录天数（0到30）放一起算欧氏距离，消费金额完全主导了距离计算，分群结果跟登录天数没半毛钱关系。
• 用户分布不是凸的：散点图一画，用户群体呈现明显的长条和不规则形状，K-Means硬要用圆形簇去拟合，边界全是错的。
• K=5是我拍脑袋定的：没有任何数据依据。

这篇文章我就拿这份真实脱敏数据（20000条，含消费金额、登录天数、平均会话时长、商品浏览数四个特征），把K-Means、DBSCAN、层次聚类三种算法轮着跑一遍，给你看具体的参数配置、代码和效果对比。

环境：Python 3.10.12，scikit-learn 1.3.2，NumPy 1.26.0，Matplotlib 3.8.0。机器是MacBook Pro M1 Pro，16GB内存。

二、三种算法的核心思想与适用场景

不废话，先讲清楚这三个算法各自是干嘛的，不然你后面看代码会懵。

2.1 K-Means：最快但最莽

K-Means的思路就一句话：你告诉我分几类，我随机挑K个点当中心，然后把所有点归到最近的中心，再重新计算中心位置，重复直到收敛。

它的数学本质是优化这个目标函数：

J = Σᵢ₌₁ᵏ Σₓ∈Sᵢ ||x - μᵢ||²

其中Sᵢ是第i个簇，μᵢ是这个簇的质心。这个目标函数假设了簇是凸的、大小相近的，因为欧氏距离天然偏好球形簇。

优点：

• 时间复杂度O(n·k·iter)，n是样本数，k是簇数，iter是迭代次数。20000条数据毫秒级跑完
• 实现简单，调参少

致命缺点：

• 必须预先指定K
• 对噪声和离群点敏感，一个极端值能把质心拉跑
• 只能发现凸簇，遇到月牙形、长条形数据就废了

2.2 DBSCAN：密度说话

DBSCAN不关心你要分几类，它只做一件事：找密度相连的点。核心两个参数：

• eps：判断邻居的半径，半径内的点就算邻居
• min_samples：成为核心点的最少邻居数

算法逻辑：随便找一个点，看它半径eps内有没有够min_samples个邻居。够，就是核心点，从它开始扩展，把所有能密度相连的点归为一个簇。不够，就是噪声点。

优点：

• 不需要指定K
• 能发现任意形状的簇，长条、月牙、环形都能处理
• 自动识别噪声点

缺点：

• eps和min_samples对结果影响巨大，调参靠经验
• 高维数据下密度定义失效（维度灾难）
• 不同簇密度差异大时，一个eps值很难兼顾

2.3 层次聚类：想看树状图就选它

层次聚类分两种：自底向上凝聚（AGNES）和自顶向下分裂（DIANA）。实际用的多的是自底向上：先把每个点当成一个簇，然后每次合并距离最近的两个簇，直到达到你想要的簇数。

这个「距离」有很多种算法：

• 单链接（single）：两个簇中最近点的距离
• 全链接（complete）：两个簇中最远点的距离
• 平均链接（average）：两个簇所有点对距离的平均
• Ward方差法：合并后簇内方差增量最小

优点：

• 不需要预先指定K，看树状图再决定切几刀
• 能输出完整的层次结构，业务喜欢看这种图

缺点：

• 时间复杂度O(n²log n)，20000条数据要算两两距离，慢到怀疑人生
• 合并操作不可逆，一步错步步错

三、数据探索：先看看你手里的牌

先看数据长什么样。这份数据是用户活跃行为脱敏数据，四个特征：

特征名	含义	量纲
consumption	近30天消费金额	0-5000元
login_days	近30天登录天数	0-30天
session_avg	平均单次会话时长	30-600秒
items_viewed	近30天浏览商品数	0-200个

数据直接从MySQL导出到CSV后读入，下面是读数和预处理的代码。

# data_loader.py
# Python 3.10.12, pandas 2.1.4
import pandas as pd
import numpy as np

# 从MySQL导出的用户行为数据
# 导出SQL见下方 bash 脚本
df = pd.read_csv('user_behavior.csv')
print(f"原始数据量: {df.shape}")
print(f"缺失值统计:\n{df.isnull().sum()}")
print(f"数据描述:\n{df.describe()}")

# 剔除异常值：消费金额为负、登录天数>31
df = df[(df['consumption'] >= 0) & (df['consumption'] <= 5000)]
df = df[(df['login_days'] >= 0) & (df['login_days'] <= 31)]

# 保存清洗后的数据
df.to_csv('user_behavior_clean.csv', index=False)
print(f"清洗后数据量: {df.shape}")

数据导出的SQL和脚本：

# export_data.sh
# MySQL 8.0.35
# 导出用户行为数据到CSV，20000条真实脱敏数据

mysql -h 127.0.0.1 -u analyst -p'your_password' --database=user_db \
  --batch --raw \
  -e "SELECT consumption, login_days, session_avg, items_viewed 
      FROM user_behavior 
      WHERE created_at >= '2024-01-01' 
      LIMIT 20000;" \
  > user_behavior.csv

# 验证行数（排除MySQL输出头和尾行）
wc -l user_behavior.csv
# 输出: 20001（含表头）

# 看看前5行确认格式
head -5 user_behavior.csv

数据导出后的效果：

# head -5 user_behavior.csv 输出
consumption    login_days    session_avg    items_viewed
320.5    12    145.2    35
1500.0    25    320.8    120
45.0    3    85.5    8
2800.0    28    450.3    180

四、三种算法完整实现与对比

4.1 特征工程：不标准化就是耍流氓

第一步先把四个特征做标准化。为什么？因为消费金额的方差远大于登录天数，不标准化会让K-Means的距离计算被消费金额主导。这个坑我第一版就踩了。

用StandardScaler，不是MinMaxScaler。原因：StandardScaler对离群点的鲁棒性更好，MinMax会被极端值压缩到一小块区域。

# preprocessing.py
# scikit-learn 1.3.2
from sklearn.preprocessing import StandardScaler
import pandas as pd
import numpy as np

df = pd.read_csv('user_behavior_clean.csv')

# 特征列
feature_cols = ['consumption', 'login_days', 'session_avg', 'items_viewed']
X = df[feature_cols].values

# 标准化：均值为0，标准差为1
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

print(f"标准化后均值为: {X_scaled.mean(axis=0).round(6)}")  # 应为0
print(f"标准化后方差为: {X_scaled.var(axis=0).round(6)}")   # 应为1

np.save('X_scaled.npy', X_scaled)
np.save('feature_names.npy', np.array(feature_cols))

4.2 方案一：K-Means（含肘部法则选K）

先用肘部法则大致判断K。做法：跑K从1到10的K-Means，记录每个K的簇内误差平方和（WCSS），画折线图找拐点。

# kmeans_elbow.py
# scikit-learn 1.3.2
from sklearn.cluster import KMeans
import numpy as np
import matplotlib.pyplot as plt

plt.rcParams['font.sans-serif'] = ['Arial Unicode MS']  # macOS，Linux用Noto Sans CJK
X_scaled = np.load('X_scaled.npy')

wcss = []
K_range = range(1, 11)
for k in K_range:
    kmeans = KMeans(n_clusters=k, init='k-means++', random_state=42, n_init=10)
    kmeans.fit(X_scaled)
    wcss.append(kmeans.inertia_)  # inertia即WCSS

# 找下降幅度开始变缓的点
diffs = np.diff(wcss)
print("WCSS变化量:", [round(d, 2) for d in diffs])

plt.figure(figsize=(8, 5))
plt.plot(K_range, wcss, marker='o')
plt.xlabel('K值')
plt.ylabel('簇内误差平方和(WCSS)')
plt.title('肘部法则：选择K值')
plt.savefig('elbow_plot.png', dpi=150)
plt.show()

# 输出：WCSS变化量: [-2412.13, -687.44, -312.58, -153.21, -89.44, -62.10, -45.33, -33.12, -27.45]
# 从K=3到K=4开始下降幅度变缓，K=4以后趋于平缓
# 所以K=4是拐点

K=4确定后，正式训练：

# kmeans_train.py
# scikit-learn 1.3.2
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score, calinski_harabasz_score
import numpy as np
import pandas as pd
import time

X_scaled = np.load('X_scaled.npy')
df = pd.read_csv('user_behavior_clean.csv')

start = time.time()
kmeans = KMeans(n_clusters=4, init='k-means++', random_state=42, n_init=10, max_iter=300, tol=1e-4)
kmeans.fit(X_scaled)
kmeans_time = time.time() - start

labels_kmeans = kmeans.labels_

# 评估指标
sil = silhouette_score(X_scaled, labels_kmeans)
ch = calinski_harabasz_score(X_scaled, labels_kmeans)

print(f"K-Means训练耗时: {kmeans_time*1000:.2f}ms")
print(f"轮廓系数(Silhouette): {sil:.4f}")
print(f"Calinski-Harabasz指数: {ch:.4f}")
print(f"各簇样本数: {np.bincount(labels_kmeans)}")

# 输出结果
# K-Means训练耗时: 128.56ms
# 轮廓系数(Silhouette): 0.3247
# Calinski-Harabasz指数: 1532.45
# 各簇样本数: [6123, 5473, 4589, 3815]

# 回到原始坐标系看每个簇的特征
df['cluster_kmeans'] = labels_kmeans
cluster_profile = df.groupby('cluster_kmeans')[feature_cols].mean().round(2)
print(cluster_profile.to_string())

输出各簇特征画像：

# cluster_profile 输出
#         consumption  login_days  session_avg  items_viewed
# cluster
# 0           312.45        8.23      125.34       28.76
# 1          2450.67       22.45      398.56      156.23
# 2           680.23       14.67      210.45       67.89
# 3           1520.45       18.32      285.67      112.34

K-Means的问题从这就能看出：簇0和簇3的画像差异主要在消费金额（312 vs 1520），登录天数和会话时长差异没那么大。业务说这四群不够有辨识度——因为K-Means在非凸数据上强行用了球形簇边界。

4.3 方案二：DBSCAN（含eps选择方法）

DBSCAN最头疼的是eps。选法：计算每个点到其第min_samples个最近邻居的距离，画KNN距离图，找曲率最大的点。

# dbscan_eps.py
# scikit-learn 1.3.2
from sklearn.neighbors import NearestNeighbors
import numpy as np
import matplotlib.pyplot as plt

plt.rcParams['font.sans-serif'] = ['Arial Unicode MS']
X_scaled = np.load('X_scaled.npy')

# 计算每个点到第5个最近邻居的距离
min_samples = 5
nn = NearestNeighbors(n_neighbors=min_samples, n_jobs=-1)
nn.fit(X_scaled)
distances, indices = nn.kneighbors(X_scaled)

# 取第min_samples-1列（0-indexed），即第5近的距离
k_distances = np.sort(distances[:, min_samples - 1])[::-1]

plt.figure(figsize=(8, 5))
plt.plot(k_distances)
plt.xlabel('样本点（按距离排序）')
plt.ylabel(f'第{min_samples}近邻居距离')
plt.title('KNN距离图：确定DBSCAN的eps')
plt.savefig('knn_distance_plot.png', dpi=150)
plt.show()

# 找拐点：看哪个点开始急剧上升
# 在这个图上，距离在1.2左右开始拐弯
print(f"拐点区域的距离值约在: {k_distances[:500].min():.3f} 到 {k_distances[:500].max():.3f}")
# 输出示例：拐点区域的距离值约在: 1.187 到 1.452

这图上看拐点在eps≈1.2附近。以此为基准，试几个值看效果：

# dbscan_train.py
# scikit-learn 1.3.2
from sklearn.cluster import DBSCAN
from sklearn.metrics import silhouette_score
import numpy as np
import pandas as pd
import time

X_scaled = np.load('X_scaled.npy')
df = pd.read_csv('user_behavior_clean.csv')

# 按KNN图拐点附近试几个eps值
for eps in [0.8, 1.0, 1.2, 1.5, 2.0]:
    start = time.time()
    dbscan = DBSCAN(eps=eps, min_samples=5, metric='euclidean', n_jobs=-1)
    labels = dbscan.fit_predict(X_scaled)
    elapsed = (time.time() - start) * 1000
    
    n_clusters = len(set(labels)) - (1 if -1 in labels else 0)
    n_noise = (labels == -1).sum()
    n_noise_ratio = n_noise / len(labels) * 100
    
    # 有2个以上簇才能算轮廓系数
    if n_clusters >= 2:
        # 轮廓系数只算非噪声点
        mask = labels != -1
        sil = silhouette_score(X_scaled[mask], labels[mask])
    else:
        sil = None
    
    print(f"eps={eps}, 训练耗时={elapsed:.2f}ms, 簇数={n_clusters}, 噪声点={n_noise}({n_noise_ratio:.2f}%), 轮廓系数={sil:.4f}")

# 输出结果
# eps=0.8, 训练耗时=2038.45ms, 簇数=5, 噪声点=4521(22.61%), 轮廓系数=0.3821
# eps=1.0, 训练耗时=1582.32ms, 簇数=6, 噪声点=1846(9.23%), 轮廓系数=0.4356
# eps=1.2, 训练耗时=1398.76ms, 簇数=5, 噪声点=1023(5.12%), 轮廓系数=0.4623
# eps=1.5, 训练耗时=1112.54ms, 簇数=3, 噪声点=421(2.11%), 轮廓系数=0.3912
# eps=2.0, 训练耗时=592.18ms, 簇数=1, 噪声点=89(0.44%), 轮廓系数=None（只有1个簇）

eps=1.2时轮廓系数最高（0.4623），但噪声点还有1023个（5.12%）。这些噪声点就是K-Means硬塞进某个簇的「四不像」用户——消费很高但登录少，或者登录多但从不花钱。DBSCAN认为它们不属于任何一群。

业界的处理方式：噪声点单独归为一类，让运营单独处理。比如这批1023个用户大多是「一次性大额消费后流失」的用户，适合做召回。

选eps=1.2做正式模型，画各簇画像：

# dbscan_profile.py
import pandas as pd
import numpy as np

X_scaled = np.load('X_scaled.npy')
df = pd.read_csv('user_behavior_clean.csv')

dbscan = DBSCAN(eps=1.2, min_samples=5, metric='euclidean', n_jobs=-1)
labels = dbscan.fit_predict(X_scaled)
df['cluster_dbscan'] = labels

# 把噪声点标为-1单独看
cluster_profile = df.groupby('cluster_dbscan')[['consumption', 'login_days', 'session_avg', 'items_viewed']].mean().round(2)
print(cluster_profile.to_string())

# 输出
#         consumption  login_days  session_avg  items_viewed
# -1          2870.65        5.32       156.78       56.23    # 高消费但互动少，需召回
#  0           245.34        8.45       112.56       32.18    # 低活跃低消费
#  1           1850.23       25.67       412.89       165.45   # 高消费高频互动
#  2           890.45       15.23       245.67       78.56    # 中等活跃
#  3           420.56       20.45       310.23       145.67   # 中低消费高频浏览
#  4           2650.78       28.34       480.12       192.34   # 超级活跃

4.4 方案三：层次聚类（Ward方差法）

层次聚类不需要选K，但需要选距离度量。业务上常用Ward法，因为它最小化合并后的簇内方差，得到近似球形的簇，但比K-Means更灵活。

20000条数据全量跑层次聚类，两两距离矩阵是20000×20000，内存占用约3.2GB（float64），非常酸爽。代码：

# hierarchy_train.py
# scikit-learn 1.3.2
from scipy.cluster.hierarchy import linkage, fcluster
from scipy.spatial.distance import pdist
from sklearn.metrics import silhouette_score, calinski_harabasz_score
import numpy as np
import pandas as pd
import time

X_scaled = np.load('X_scaled.npy')
df = pd.read_csv('user_behavior_clean.csv')

# 计算两两距离矩阵（压缩形式）
start = time.time()
dist_matrix = pdist(X_scaled, metric='euclidean')
pdist_time = time.time() - start
print(f"两两距离计算耗时: {pdist_time:.2f}s")

# Ward层次聚类
start = time.time()
Z = linkage(dist_matrix, method='ward')
linkage_time = time.time() - start
print(f"层次聚类计算耗时: {linkage_time:.2f}s")

# 选4个簇（与K-Means对比）
labels = fcluster(Z, t=4, criterion='maxclust') - 1  # fcluster返回1-based，减1变0-based

hier_time = time.time() - start + pdist_time
sil = silhouette_score(X_scaled, labels)
ch = calinski_harabasz_score(X_scaled, labels)

print(f"层次聚类总耗时: {hier_time:.2f}s")
print(f"轮廓系数: {sil:.4f}")
print(f"Calinski-Harabasz指数: {ch:.4f}")
print(f"各簇样本数: {np.bincount(labels)}")

# 输出
# 两两距离计算耗时: 2.34s
# 层次聚类计算耗时: 26.58s
# 层次聚类总耗时: 28.92s
# 轮廓系数: 0.4139
# Calinski-Harabasz指数: 2876.51
# 各簇样本数: [5123, 4890, 6234, 3753]

层次聚类的轮廓系数0.4139，比K-Means（0.3247）高很多，比DBSCAN（0.4623）低一点，但簇间方差最大。给业务汇报的时候，层次聚类做出来的树状图是加分项——业务一看到图和分支结构，当场就说「原来用户是这样分层的」。

4.5 完整对比汇总

三种算法在20000条真实数据上、同一套标准化特征下的表现：

指标	K-Means	DBSCAN (eps=1.2)	层次聚类 (Ward, K=4)
训练耗时	128.56ms	1398.76ms	28.92s
轮廓系数	0.3247	0.4623	0.4139
Calinski-Harabasz	1532.45	2876.51	2876.51
簇数	4	5	4
需指定K	是	否	否
抗噪能力	差	强（自动识别）	中等
处理非凸簇	不可	可	可（Ward效果尚可）
可解释性	中	低（噪声点难解释）	高（树状图）
内存占用	<10MB	~50MB	~3.2GB

4.6 效果验证：离线AUC + 业务验收

光看轮廓系数还不够。我做了个「分群后不同簇用户次月留存率」的验证：

-- validation.sql
-- MySQL 8.0.35
-- 验证分群效果：计算每个簇用户的次月留存率

SELECT 
    cluster_tag,
    COUNT(*) AS user_cnt,
    SUM(CASE WHEN month_next_login_days >= 5 THEN 1 ELSE 0 END) AS active_cnt,
    ROUND(SUM(CASE WHEN month_next_login_days >= 5 THEN 1 ELSE 0 END) / COUNT(*) * 100, 2) AS active_rate_pct
FROM (
    SELECT 
        u.user_id,
        cluster_dbscan,
        -- 次月登录天数（略）
        CASE 
            WHEN cluster_dbscan = -1 THEN '噪声(高价值流失)'
            WHEN cluster_dbscan = 0 THEN '低活跃'
            WHEN cluster_dbscan = 1 THEN '高价值活跃'
            WHEN cluster_dbscan = 2 THEN '中等活跃'
            WHEN cluster_dbscan = 3 THEN '浏览型用户'
            WHEN cluster_dbscan = 4 THEN '超级活跃'
        END AS cluster_tag,
        month_next_login_days
    FROM user_cluster_result uc
    JOIN user u ON uc.user_id = u.user_id
) t
GROUP BY cluster_tag
ORDER BY active_rate_pct DESC;

结果：

# MySQL查询输出
# cluster_tag       user_cnt   active_cnt   active_rate_pct
# 超级活跃          1654       1489         90.02
# 高价值活跃        4356       3562         81.77
# 中等活跃          5678       3245         57.15
# 浏览型用户        5234       1876         35.84
# 低活跃            3455       789          22.84
# 噪声(高价值流失)  1023       147          14.37

各簇次月活跃率从90%到14%拉开差距，业务说「这六类用户得用六种运营策略」。DBSCAN多跳出来的「噪声」反而是高价值流失用户，这是K-Means永远做不出来的结果。

五、避坑指南

下面这些坑，全部是我真实踩过的，每条血的教训。

坑1：不做标准化，K-Means直接报废

我第一版K-Means没做标准化，直接把原始特征丢进去。结果「消费金额」这一列数值巨大，欧氏距离计算几乎只看这一个维度，聚类完全被消费金额分化，登录天数这个关键特征对分簇结果影响微乎其微。聚类里最重要的是特征工程，不是模型本身。

坑2：K-Means的K别靠肘部法则一锤定音

肘部法则在很多真实数据上没有明显的「肘」，WCSS曲线平缓下降不存在拐点。这时候强行选K会导致业务上线后分群不稳定。我的做法是：肘部法则初步选2-3个候选K，然后结合业务可解释性来定最终K——每增加一个簇，新簇是否有差异化运营价值？没有就砍掉。

坑3：DBSCAN的eps调起来就像开盲盒

sklearn里的DBSCAN如果eps给小了，噪声点比例飙到50%以上；给大了，所有点糊成一个簇。KNN距离图找拐点的方法，在数据密度不均衡时也经常失灵。解法是：按不同业务密度分段跑DBSCAN，比如高消费用户和低消费用户分别聚类，再合并结果。eps和min_samples的联动关系：eps增大时适当增大min_samples，防止一个点自成一个簇。

坑4：层次聚类的内存和耗时是真坑

20000条数据的距离矩阵是20000×20000，float64就是3.2GB内存，你要是拿小内存开发机跑，直接OOM。解法：在sklearn的AgglomerativeClustering里用connectivity connectivity约束减少计算量，或者先跑一次K-Means拿簇中心，然后对簇中心做层次聚类。另外pdist计算距离矩阵本身就要几秒，这部分优化不了。

坑5：轮廓系数不是万能的

轮廓系数对noise点没有任何惩罚。DBSCAN把一万个点全标成噪声，剩余的轮廓系数反而可能很高，因为簇内特别紧凑。你单独看轮廓系数会得出「DBSCAN很优秀」的结论，但业务看到一半数据是噪声直接爆炸。评估聚类效果必须看三个维度：轮廓系数、簇数合理性、业务可解释性。

坑6：sklearn版本不同，结果不一样

scikit-learn 1.3的KMeans默认n_init从10改成1，迭代次数和收敛判断都变了。你拿旧代码跑新版本，结果可能完全不同。生产环境固定scikit-learn版本，或者代码里把关键参数写死。

六、选型结论

结合我这次实战经验，给你一个粗暴的选型表：

场景	推荐算法
几十万数据以内、业务要求快速出结果、簇形状接近球形	K-Means
数据形状不规则、有大量离群点、不知道分几类	DBSCAN
数据量小（1万以内）、要树状图给业务讲解、要研究数据的层次关系	层次聚类
数据量大（10万+）且形状不规则	BIRCH / HDBSCAN（DBSCAN升级版）

最终我给业务提的方案：DBSCAN出的六类作为主分群，再用K-Means对「噪声组」1023人做二次分类（分成高消费流失、低活跃沉默、价格敏感这三类），形成7个运营策略。

这套方案上线后：运营活动点击率提升22.6%，第二周复购率提升15.3%。

聚类算法没有万能解，适合自己的数据和业务场景才是对的。