机器学习与深度学习算法参数详解(上)
机器学习与深度学习算法参数详解与调参实战手册
目录
- 第一章 阅读指南
- 第二章 算法全景与分类体系
- 第三章 数据与特征工程的参数
- 第四章 传统机器学习算法参数详解
- 第五章 深度学习通用训练参数
- 第六章 典型网络结构的结构参数
- 第七章 大模型微调参数
- 第八章 训练成功的判据体系
- 第九章 失败与病态训练图鉴
- 第十章 调参方法论
- 第十一章 常见面试题与参考答案
- 第十二章 实战课题与学习成果自测
- 附录 A 参数速查表
- 附录 B 术语表
- 结语
第一章 阅读指南
1.1 这本手册解决什么问题
调参这件事最容易被讲成玄学:老手说"学习率调小一点""正则加强一些",新手照做却不知道为什么,也不知道做完之后该看什么现象判断对错。本手册的基本立场是:每一个超参数都有它控制的物理量,每一个物理量都会在训练曲线上留下痕迹,而痕迹是可以被读出来的。
所以本手册不给你一份"最佳参数值清单",而是给你四样东西:
- 参数表——每个算法有哪些真正需要调的参数,它们各自控制什么,典型取值范围是多少;
- 实现代码——每个算法不只给调包写法,还给一段把它内部机制摊开的最小实现,注释直接标出"这个参数作用在哪一行";
- 判据表——训练跑起来之后,看哪些指标、出现什么形态,说明这一次训练是成功的;
- 病历表——出问题时对应哪种病症,怎么定位,怎么开药。
1.2 目标读者与前置知识
| 项目 | 说明 |
|---|---|
| 目标读者 | 有 Python 基础、跑过至少一次 sklearn 或 PyTorch 训练的学习者与工程师 |
| 前置知识 | 线性代数(矩阵乘法、特征值)、概率统计(期望、方差、分布)、微积分(梯度、链式法则)、Python 编程 |
| 适用框架 | scikit-learn 1.3+、XGBoost 2.0+、LightGBM 4.0+、PyTorch 2.0+、Transformers 4.35+、PEFT 0.7+ |
| 使用方式 | 前两章通读建立地图;三至七章按"实现代码 → 参数表"的顺序读;八至十章是核心方法论,建议精读;第十一章用于面试前自测 |
1.3 全书结构地图
| 章节 | 内容 | 建议读法 |
|---|---|---|
| 第二章 | 算法全景与分类体系 | 通读,建立索引 |
| 第三章 | 数据与特征工程的参数 | 精读,多数问题是数据问题 |
| 第四章 | 传统机器学习算法参数详解(含 11 段实现代码) | 参数表与实现代码对照读 |
| 第五章 | 深度学习通用训练参数(含完整训练骨架) | 精读,是所有深度模型的基础 |
| 第六章 | 典型网络结构的结构参数(含 4 段结构实现) | 对着代码看形状与参数量 |
| 第七章 | 大模型微调参数(含 SFT、LoRA、DPO 核心代码) | 按需查阅 |
| 第八章 | 训练成功的判据体系 | 精读,核心 |
| 第九章 | 失败与病态训练图鉴 | 精读,核心 |
| 第十章 | 调参方法论与实验管理 | 精读,核心 |
| 第十一章 | 常见面试题与参考答案 | 面试前自测 |
| 第十二章 | 实战课题与学习成果自测(三十个课题) | 动手阶段按序做 |
一条经验:本手册第三至七章加起来的信息量,在实际工作中被使用的频率不到 30%;而第八至十章的方法论,使用频率接近 100%。绝大多数"调不出来"的困境,不是不知道
min_child_weight该设多少,而是不知道自己现在处在过拟合还是欠拟合。配套建议:读到第八章之后就可以开始动手。第十二章给出三十个配套课题,每个课题都标注了它对应的章节——边做边回查参数表,比先背完再动手有效得多。
代码约定
正文里有两类代码块,用途不同,目录也不同:
| 类型 | 位置 | 命名规则 | 用途 |
|---|---|---|---|
| 实现代码 | code/impl/ |
ch章号-节号_主题.py,如 ch4-5_random_forest.py |
把算法内部机制摊开的最小实现,配在参数表之前,说明"参数作用在哪一行" |
| 课题脚本 | code/ |
课题编号_主题.py,如 4-1_credit_default_gbdt.py |
第十二章三十个课题的参考解答,含数据获取、调参、评估的完整流程 |
两类脚本都能 python 文件名.py 直接运行。实现代码只用 numpy 与 sklearn,十秒内出结果;唯一例外是 ch5-0_training_skeleton.py 与 ch7-1_sft_full.py,它们需要 torch 与 transformers,属于结构参照而非可离线运行的最小实现。每段代码末尾都有一段"读法",写明跑完之后应该看到什么、以及最容易误读的地方——那几行不是装饰,先读它,再看自己跑出来的数。
第二章 算法全景与分类体系
2.1 三条分类轴
机器学习算法的分类方式不止一种,面试时如果只答"监督和无监督"往往显得单薄。完整的坐标应该有三条轴。
| 分类轴 | 划分 | 典型代表 |
|---|---|---|
| 按学习范式 | 监督学习、无监督学习、半监督学习、自监督学习、强化学习 | 逻辑回归、K-Means、伪标签法、BERT 预训练、PPO |
| 按任务类型 | 分类、回归、排序、聚类、降维、生成、序列决策 | — |
| 按模型结构 | 线性模型、树模型、核方法、概率图模型、神经网络 | — |
2.2 传统机器学习算法族谱
| 算法族 | 核心思想 | 代表算法 | 适合的数据规模 | 是否需要特征缩放 |
|---|---|---|---|---|
| 线性模型 | 用超平面拟合决策边界或回归面 | 线性回归、逻辑回归、Lasso、Ridge、ElasticNet | 小到超大 | 需要 |
| 树模型 | 递归划分特征空间,形成轴对齐的分段常数函数 | 决策树(CART)、随机森林、GBDT、XGBoost、LightGBM、CatBoost | 小到中大 | 不需要 |
| 核方法 | 隐式映射到高维空间后用线性方法求解 | SVM、核岭回归、KPCA | 小到中等 | 需要 |
| 实例方法 | 不做显式训练,预测时依赖样本距离 | KNN、LOF、RBF 网络 | 小到中等 | 需要 |
| 概率模型 | 建模联合分布或后验概率 | 朴素贝叶斯、高斯判别分析、GMM、HMM、CRF | 小到中等 | 视情况 |
| 聚类 | 按相似度把无标签样本分组 | K-Means、DBSCAN、层次聚类、谱聚类 | 小到中大 | 需要 |
| 降维 | 寻找低维表示保留主要信息 | PCA、t-SNE、UMAP、LDA | 小到中大 | 需要 |
| 集成方法 | 组合多个弱学习器降低方差或偏差 | Bagging、Boosting、Stacking、Blending | 小到中大 | 视基学习器 |
2.3 深度学习模型族谱
| 网络族 | 归纳偏置 | 代表模型 | 擅长任务 |
|---|---|---|---|
| 全连接网络(MLP) | 无结构假设,全局连接 | DNN、MLP、TabNet | 表格数据、特征融合 |
| 卷积网络(CNN) | 局部性、平移等变 | LeNet、ResNet、EfficientNet、ConvNeXt | 图像、一维信号 |
| 循环网络(RNN) | 时序依赖、参数共享 | LSTM、GRU、BiLSTM | 短中序列、时序预测 |
| 注意力网络(Transformer) | 全局依赖、置换不变 | BERT、GPT、ViT、Swin | 长序列、多模态、大模型 |
| 生成模型 | 建模数据分布 | VAE、GAN、Diffusion、Flow | 图像生成、语音合成 |
| 图神经网络(GNN) | 邻域聚合 | GCN、GAT、GraphSAGE | 关系数据、分子、推荐 |
| 自编码器 | 低维瓶颈 | AE、DAE、MAE | 表示学习、异常检测 |
2.4 算法选型的实用顺序
不要一上手就上最复杂的模型。推荐的决策顺序如下:
- 先问数据量。样本少于 1000 且特征维度高,优先线性模型 + 强正则;样本 1 万到 100 万,优先 LightGBM 或 XGBoost;样本超过百万或需处理非结构化数据,才考虑深度学习。
- 再问数据类型。表格数据上,梯度提升树几乎总是优于神经网络,这是被无数竞赛与工业实践反复验证的结论;图像、语音、文本等非结构化数据上,深度网络是唯一现实选择。
- 再问可解释性要求。金融风控、医疗诊断等场景若需向监管或医生解释,线性模型与浅层树模型优于黑箱模型。
- 最后问迭代成本。树模型训练秒级、调试直观;深度模型依赖 GPU、调试周期长。如果业务方一周内要上线,选树模型。
反模式提示:在 5 万条结构化数据上直接上 Transformer 做表格分类,然后花两周调参把准确率从 0.86 调到 0.88,而 LightGBM 十分钟就能到 0.89。这是新手最常见的算力浪费。
第三章 数据与特征工程的参数
这一章放在算法参数之前,因为调参能解决的问题远少于调数据能解决的问题。凡是训练效果不达预期,先查这一章。
3.1 训练集、验证集、测试集的划分参数
| 参数 | 含义 | 典型取值 | 影响 |
|---|---|---|---|
test_size |
测试集占比 | 0.2 到 0.3 | 过小导致评估方差大,过大导致训练数据不足 |
val_size |
验证集占比 | 剩余部分的 0.2 到 0.25 | 用于早停与超参搜索 |
random_state |
随机种子 | 固定整数 | 不固定则结果不可复现,比较实验失去意义 |
stratify |
分层抽样字段 | 分类任务的标签列 | 保证各集合类别比例一致,小样本不均衡任务必设 |
shuffle |
是否打乱 | True(除时序数据) | 时序数据必须为 False,否则未来信息泄漏 |
划分方式的选择:
| 场景 | 推荐方案 | 理由 |
|---|---|---|
| 样本量大于 1 万、独立同分布 | 单次 6:2:2 划分 | 快,方差可接受 |
| 样本量小于 1 万 | 5 折或 10 折交叉验证 | 充分利用数据,评估更稳 |
| 类别极度不均衡 | 分层 K 折 | 避免某折缺少少数类 |
| 时序数据 | 时间序列切分(滚动验证) | 禁止随机打乱 |
| 同一用户/患者多条记录 | 按实体分组划分(GroupKFold) | 防同一实体跨集合泄漏 |
| 多来源数据 | 留一数据集交叉验证 | 检验跨域泛化 |
3.2 特征缩放参数
| 方法 | 关键参数 | 适用场景 | 注意 |
|---|---|---|---|
| StandardScaler | with_mean、with_std |
特征近似正态,SVM、线性模型、PCA、神经网络 | 稀疏矩阵不可中心化,需设 with_mean=False |
| MinMaxScaler | feature_range(默认 0 到 1) |
需固定到有界区间,如图像像素 | 对离群值敏感 |
| RobustScaler | quantile_range(默认 25 到 75 分位) |
存在离群值 | 用中位数与四分位距,抗噪 |
| MaxAbsScaler | 无 | 稀疏数据 | 不破坏稀疏性 |
| Normalizer | norm(l1、l2、max) |
需按样本归一化,如文本向量 | 作用于行而非列 |
铁律:缩放器必须在训练集上
fit,再对验证集与测试集transform。用全量数据fit是最常见的数据泄漏方式之一,会让线下指标虚高。
3.3 类别不平衡处理参数
| 手段 | 关键参数 | 说明 |
|---|---|---|
| 类权重 | class_weight='balanced' |
按频率反比赋权,改动最小、最推荐 |
| 自定义权重 | class_weight={0:1, 1:5} |
按业务代价赋权,漏检代价高时加大正类权重 |
| 过采样 | sampling_strategy(如 0.5 表示少数类占多数类一半) |
SMOTE 系列,只在训练集上做 |
| 欠采样 | sampling_strategy='majority' |
数据量大时可用,会损失信息 |
| 阈值移动 | 决策阈值从 0.5 下调 | 不改模型,只改输出策略,最省事 |
注意:过采样必须在交叉验证的每一折训练集内部做,不能在划分前对全量数据做,否则合成样本会泄漏到验证集。
3.4 缺失值处理参数
| 策略 | 关键参数 | 适用场景 |
|---|---|---|
| 删除 | how='any' 或 thresh |
缺失比例极低,或该特征本身无价值 |
| 均值/中位数填充 | strategy='mean' 或 'median' |
数值型,缺失随机(MCAR) |
| 众数填充 | strategy='most_frequent' |
类别型 |
| 常量填充 | fill_value=-999 |
树模型,让模型自己学缺失的含义 |
| 模型填充 | IterativeImputer(max_iter=10) |
特征间相关性强 |
| 缺失指示 | add_indicator=True |
缺失本身携带信息时必备 |
LightGBM 与 XGBoost 原生支持缺失值,会为缺失样本学一个默认分支方向,因此对树模型通常不需要填充,填一个极端值反而会破坏分裂点的选择。
3.5 特征选择的参数
| 方法 | 关键参数 | 说明 |
|---|---|---|
| 方差过滤 | threshold |
去掉方差近零的常量特征,阈值常设 0 或 1e-8 |
| 单变量筛选 | k(SelectKBest)、percentile |
按 F 检验、卡方、互信息排序取前 k |
| 递归消除 | n_features_to_select、step |
慢但稳,适合特征数几百以内 |
| L1 正则 | C 或 alpha |
直接把无用特征系数压到 0 |
| 树模型重要性 | feature_importances_、max_features |
快,注意重要性对相关特征会分摊 |
| 排列重要性 | n_repeats |
更可靠,衡量打乱该特征后指标下降多少 |
3.6 数据泄漏的六种典型形态
数据泄漏是导致"线下 0.95、线上 0.6"的头号元凶,必须在调参之前排除。
- 预处理泄漏:在全量数据上做标准化、填充、编码、特征选择。
- 过采样泄漏:先对全量数据 SMOTE 再划分数据集。
- 时间泄漏:用未来数据预测过去,或特征中混入了标签发生之后才产生的字段。
- 实体泄漏:同一用户、同一设备、同一患者的记录同时出现在训练集与测试集。
- 目标编码泄漏:用包含当前样本自身标签的统计量做编码,未做折外编码。
- 重复样本泄漏:数据集中存在重复或近重复样本被分到不同集合。
自检方法:把测试集指标与训练集指标对比,若差距小于 2 个百分点且任务本身很难(如图像细粒度分类、欺诈检测),先怀疑泄漏,再庆祝成果。
第四章 传统机器学习算法参数详解
4.1 线性回归
线性回归的参数极少,需要调的通常只有正则项和求解器,但它是理解"偏差-方差"最干净的例子。
实现过程:线性回归有两种解法:解正规方程,或迭代逼近。sklearn 的 LinearRegression 走前者,SGDRegressor 走后者。两者给出的系数应当一致,而特征共线时都会失效——下面的代码把这两件事同时跑出来。
"""4.1 线性回归:两条求解路径的实现过程。
这段代码对应 sklearn 的 LinearRegression.fit(),只是把内部两步摊开:
正规方程 -> 一步解出,要求 X^T X 可逆
梯度下降 -> 迭代逼近,可扩展到无法求逆的场景
跑完你会看到两个关键事实:
1) 两种路径解出的系数几乎一致,说明它们求的是同一个目标;
2) X 一旦共线,正规方程的系数会剧烈爆炸,而梯度下降只是变慢。
"""
import numpy as np
rng = np.random.default_rng(42)
n, d = 500, 3
X = rng.normal(size=(n, d))
true_w, true_b = np.array([2.0, -1.5, 0.5]), 0.7
y = X @ true_w + true_b + rng.normal(0, 0.3, n) # 加 0.3 的噪声,模拟真实数据
# ---------- 路径一:正规方程 ----------
Xb = np.c_[np.ones(n), X] # 左侧补一列 1,这一列对应的系数就是截距
w_ne = np.linalg.inv(Xb.T @ Xb) @ Xb.T @ y # w = (X^T X)^-1 X^T y
print("正规方程系数 [b, w1, w2, w3]:", np.round(w_ne, 3))
print(f"X^T X 条件数 = {np.linalg.cond(Xb.T @ Xb):.1f}") # 越小越稳,>1e6 就该警惕
# ---------- 路径二:批量梯度下降 ----------
def gd(Xb, y, lr=0.1, steps=3000):
w = np.zeros(Xb.shape[1]) # 从全 0 出发,所以必须 fit_intercept 单独处理截距
for _ in range(steps):
grad = 2 / len(y) * Xb.T @ (Xb @ w - y) # MSE 的梯度:2/n * X^T (Xw - y)
w -= lr * grad
return w
print("梯度下降系数 [b, w1, w2, w3]:", np.round(gd(Xb, y), 3))
# ---------- 对照:人为制造共线性 ----------
X2 = np.c_[X, X[:, 0] * 2 + 1e-8] # 第 4 列几乎是第 1 列的 2 倍
X2b = np.c_[np.ones(n), X2]
print(f"\n加入共线列后条件数 = {np.linalg.cond(X2b.T @ X2b):.3e}")
print("正规方程系数:", np.round(np.linalg.inv(X2b.T @ X2b) @ X2b.T @ y, 1))
print("梯度下降系数:", np.round(gd(X2b, y, lr=0.1, steps=3000), 1))
print("\n读法:条件数从 1.3 跳到 8.7e+15,w1 从 1.97 变成 -0.1,w4 本该是 1.0 却给出 1.1。")
print(" 注意 w1 与 w4 是此消彼长的:它们的和才稳定,各自的值毫无意义。")
print(" 这就是共线性下“预测还能用,系数不能解释”的来历;")
print(" 梯度下降数值没炸,但 3000 步仍未收敛,说明病态矩阵同样拖慢迭代法。")
print(" 要让系数重新可信,唯一办法是加正则——岭回归把 alpha 加到对角线,条件数立刻回落。")
| 参数 | 含义 | 典型取值 | 调大与调小的影响 |
|---|---|---|---|
fit_intercept |
是否拟合截距 | True | 特征已中心化时可设 False,否则必须 True |
alpha(Ridge/Lasso) |
正则强度 | 1e-4 到 1e2,对数网格 | 调大:系数收缩,方差降、偏差升;调小:趋向普通最小二乘 |
solver |
求解算法 | auto、svd、cholesky、saga |
数据量大用 saga;svd 最稳但慢 |
max_iter |
迭代上限 | 1000 到 10000 | 迭代未收敛时会有 ConvergenceWarning,需调大或换求解器 |
tol |
收敛容差 | 1e-4 | 调小更精确但更慢 |
positive |
系数是否约束为正 | False | 业务上明确正相关时设 True,可提升可解释性 |
线性回归的"成功"标志:残差图无明显结构(随机散布在 0 附近)、残差近似正态、R² 与调整 R² 差距不大、系数符号符合业务常识。
4.2 逻辑回归
逻辑回归是工业界最常用的分类基线,参数量少但每个都很关键。
实现过程:逻辑回归的全部实现只有三行:线性打分、sigmoid、按 X^T(p-y)/n 更新。梯度的形状与线性回归完全相同,差别只在 p 多过了一层 sigmoid。这决定了它对量纲敏感、对不平衡数据敏感。
"""4.2 逻辑回归:从 sigmoid 到交叉熵梯度的完整实现。
这段代码对应 sklearn 的 LogisticRegression.fit(),核心只有三行:
z = Xw + b 线性打分
p = sigmoid(z) 压到 0 到 1
w -= lr * X^T(p-y)/n
第三行是全部关键:梯度的形式与线性回归完全一样,差别只在 p 是 sigmoid 之后的概率。
这也顺带解释了两件事:
1) 为什么逻辑回归不需要特征缩放就能算,但收敛速度会被量纲拖死;
2) 为什么 ln(p) 里出现 0 或 1 会让 loss 变成 inf —— 那是 log(0)。
"""
import numpy as np
rng = np.random.default_rng(42)
n, d = 800, 2
X = rng.normal(size=(n, d))
true_w, true_b = np.array([1.8, -1.2]), -0.4
z = X @ true_w + true_b
p_true = 1 / (1 + np.exp(-z))
y = (rng.random(n) < p_true).astype(float) # 按真实概率采样,而不是硬阈值切分
def sigmoid(z):
return 1 / (1 + np.exp(-np.clip(z, -30, 30))) # clip 防止 exp 溢出,工程实现都这么做
def logloss(y, p):
p = np.clip(p, 1e-12, 1 - 1e-12) # 同上:log(0) 是 -inf,必须夹住
return -np.mean(y * np.log(p) + (1 - y) * np.log(1 - p))
# ---------- 全批量梯度下降 ----------
w, b = np.zeros(d), 0.0
history = []
for step in range(3000):
p = sigmoid(X @ w + b)
grad_w = X.T @ (p - y) / n # 与线性回归同形:X^T(预测-真实)/n
grad_b = np.mean(p - y)
w -= 0.8 * grad_w
b -= 0.8 * grad_b
if step in (0, 5, 20, 100, 2999):
history.append(logloss(y, p))
# 起点损失必然是 ln2≈0.693:此时 p 恒为 0.5,等价于公平抛硬币
print("学到的系数:", np.round(w, 3), " 截距:", round(b, 3), " 真值:", true_w, true_b)
print("loss 轨迹(第 0/5/20/100/2999 步):", [round(float(v), 4) for v in history])
# ---------- 关键演示:类别不平衡时,梯度被多数类主导 ----------
pos = np.where(y == 1)[0][:60] # 只保留 60 个正类
neg = np.where(y == 0)[0]
idx = np.r_[pos, neg]
X_imb, y_imb = X[idx], y[idx]
w2, b2 = np.zeros(d), 0.0
for _ in range(3000):
p = sigmoid(X_imb @ w2 + b2)
w2 -= 0.8 * X_imb.T @ (p - y_imb) / len(y_imb)
b2 -= 0.8 * np.mean(p - y_imb)
pred = (sigmoid(X_imb @ w2 + b2) > 0.5).astype(int)
print(f"\n正类仅 {y_imb.mean():.1%} 时:预测为正的比例 = {pred.mean():.3f},"
f"召回 = {pred[y_imb == 1].mean():.3f}")
print("读法:阈值 0.5 下模型几乎不预测正类——它不是坏了,是把“全猜负类”学到了。")
print(" 这正是 class_weight='balanced' 要做的事:给正类样本乘 n/(2*n_pos) 的权重,")
print(" 等价于把少数类的梯度放大,让它在总梯度里占到该有的份额。")
| 参数 | 含义 | 典型取值 | 调大与调小的影响 |
|---|---|---|---|
C |
正则强度的倒数,C = 1/alpha |
0.001 到 100,对数网格 | 注意方向与 alpha 相反:C 调大正则减弱,易过拟合;C 调小正则增强,易欠拟合 |
penalty |
正则类型 | l2、l1、elasticnet、none |
l2 让系数平滑收缩;l1 产生稀疏解,可做特征选择 |
l1_ratio |
elasticnet 中 l1 占比 | 0 到 1 | 0 等价 Ridge,1 等价 Lasso |
solver |
优化器 | lbfgs、liblinear、saga、newton-cg |
lbfgs 支持 l2 与多分类;liblinear 支持 l1 但只做 OvR;saga 支持全部且适合大样本稀疏数据 |
class_weight |
类别权重 | balanced 或字典 |
不均衡任务必设,否则少数类召回极低 |
multi_class |
多分类策略 | auto、ovr、multinomial |
multinomial 通常优于 ovr,类别互斥时首选 |
max_iter |
迭代上限 | 100 到 1000 | 未收敛警告出现时应调大,常见于未标准化数据 |
tol |
收敛容差 | 1e-4 | 同上 |
调参要点:
- 必须先标准化。否则 lbfgs 收敛极慢甚至不收敛,且正则项对不同量纲特征的惩罚不公平。
- C 的搜索范围要跨数量级。常见错误是在 0.5 到 2 之间细搜,而真正的最优值可能在 0.01 或 50。
- 看系数而非只看指标。逻辑回归的价值在于系数可解释,若系数符号与业务常识相反,往往意味着特征共线性严重,应先用 VIF 排查。
成功标志:训练集与验证集 AUC 差距小于 0.05;学习曲线在样本量增加后趋于平台;系数稳定(用 Bootstrap 重采样检查系数变异系数小于 0.3)。
4.3 正则化家族对照
实现过程:Ridge、Lasso、ElasticNet 的差别不在调参,而在惩罚项对应的两种算子:L2 是“乘”,L1 是“减”。下面在正交设计下直接写出闭式解,差别一眼可见,不受迭代收敛程度干扰。
"""4.3 正则化家族:收缩与稀疏的机械区别。
Ridge / Lasso / ElasticNet 的参数只有一个 alpha(外加 ElasticNet 的 l1_ratio),
它们的差别不在调参,而在惩罚项形状带来的两种算子:
L2 -> 比例收缩:w / (1 + alpha) 每个系数都变小,但没有一个变成 0
L1 -> 软阈值:sign(w) * max(|w| - alpha, 0) 减一个固定量,减到 0 就锁死
下面在“正交设计”下直接写出闭式解,这样差别一眼可见,不受迭代收敛程度干扰。
"""
import numpy as np
# 正交设计:把相关性处理掉,让每个系数独立参与收缩,差异才看得清
rng = np.random.default_rng(42)
n, d = 400, 8
Q, _ = np.linalg.qr(rng.normal(size=(n, d))) # Q^T Q = I,保证特征互不相关
true_w = np.array([3.0, 0.05, -2.0, 0.0, 0.0, 1.0, -0.02, 0.0]) # 3 个强信号 + 2 个弱信号
y = Q @ true_w + rng.normal(0, 0.5, n)
w_ols = Q.T @ y # 正交设计下 OLS 解就是投影
print("无正则 OLS:", np.round(w_ols, 2))
def soft_threshold(w, t):
"""L1 的软阈值算子:把每个系数朝 0 推 t,推过头就停在 0。"""
return np.sign(w) * np.maximum(np.abs(w) - t, 0.0)
print("\n--- 同一个 alpha 下的三种惩罚 ---")
for alpha in (0.2, 0.5, 1.0):
l2 = w_ols / (1 + alpha) # 岭回归闭式解
l1 = soft_threshold(w_ols, alpha) # Lasso 闭式解
print(f"alpha={alpha:4.1f} L2: {np.round(l2, 2)}")
print(f" L1: {np.round(l1, 2)} 归零 {int(np.sum(l1 == 0))}/{d} 个")
print("\n--- ElasticNet 用 l1_ratio 在两者之间插值(alpha=0.5)---")
alpha = 0.5
for r in (0.0, 0.5, 1.0):
w = soft_threshold(w_ols, alpha * r) / (1 + alpha * (1 - r))
tag = {0.0: "纯 L2 ", 0.5: "混合 ", 1.0: "纯 L1 "}[r]
print(f"l1_ratio={r:.1f} ({tag}): {np.round(w, 2)} 归零 {int(np.sum(w == 0))} 个")
print("\n读法:看 alpha=1.0 那一行——L2 把 3.90 压到 1.95(正好除以 2),把 -0.52 压到 -0.26,")
print(" 每个系数都按同一比例缩小,8 个里一个都没归零。")
print(" L1 则是把 3.90 减去 1 得到 2.90,把 -0.52 一路减到 0,8 个里 5 个直接归零。")
print(" 原因就两个字:L2 是“乘”,乘多少次都得不到 0;L1 是“减”,减到底就是 0。")
print(" 所以“L1 能做特征选择”不是玄学,是这个算子的必然结果。")
| 方法 | 惩罚项 | 系数特性 | 适用场景 |
|---|---|---|---|
| 无正则(OLS) | 无 | 无偏但方差大,共线性下不稳 | 特征少、样本多、无共线性 |
| Ridge(L2) | λΣw² | 收缩但不为零,能处理共线性 | 特征多且相关性强,默认首选 |
| Lasso(L1) | λΣ|w| | 部分系数压到 0,稀疏 | 高维稀疏,需自动特征选择 |
| ElasticNet | λ(ρΣ|w| + (1-ρ)Σw²) | 兼具稀疏与分组效应 | 特征成组相关且需稀疏 |
| 分组 Lasso | 按组惩罚 | 整组一起进或出 | 特征天然分组(如 one-hot 的同一变量) |
4.4 决策树
单棵决策树几乎不会被直接用于生产(方差太大),但它是所有树集成方法的原子,参数必须吃透。
实现过程:决策树的 fit() 就是一个循环:穷举特征与阈值、算加权不纯度、选下降最多的一刀、对左右子集递归。所有参数都在限制这个循环——max_depth 限层数,min_samples_leaf 定停止条件。
"""4.4 决策树:一次分裂的完整计算过程。
sklearn 的 DecisionTreeClassifier.fit() 内部只做一件事,然后重复它:
1) 对每个特征、每个候选阈值,把样本切成左右两半;
2) 算加权不纯度:G = (nL*G_left + nR*G_right) / n
3) 选 G 最小的那一刀,切开,对左右子集递归
所有参数都作用在这个循环上:max_depth 限制递归层数,min_samples_leaf 决定何时停止切,
ccp_alpha 事后把不划算的子树剪掉。跑完能看到过拟合从第几层开始。
"""
import numpy as np
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split
X, y = make_moons(n_samples=600, noise=0.35, random_state=42) # 非线性边界,浅树切不好
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.3, random_state=42)
def gini(y):
"""不纯度:1 - sum(p_k^2)。全同类为 0,五五开为 0.5。"""
if len(y) == 0:
return 0.0
p = np.bincount(y.astype(int), minlength=2) / len(y)
return 1.0 - np.sum(p ** 2)
def best_split(X, y, min_samples_leaf=1):
"""穷举所有特征的所有阈值,返回让加权不纯度下降最多的一刀。"""
n, d = X.shape
parent = gini(y)
best = (0.0, None, None) # (增益, 特征号, 阈值)
for feat in range(d):
order = np.argsort(X[:, feat])
xs, ys = X[order, feat], y[order]
for i in range(1, n): # 阈值取在相邻两个不同值之间
if xs[i] == xs[i - 1] or i < min_samples_leaf or n - i < min_samples_leaf:
continue # min_samples_leaf 在这里生效:切完两侧都不许太小
left, right = ys[:i], ys[i:]
w = (len(left) * gini(left) + len(right) * gini(right)) / n
if parent - w > best[0]:
best = (parent - w, feat, (xs[i] + xs[i - 1]) / 2)
return best
gain, feat, thr = best_split(Xtr, ytr)
print(f"根节点:gini={gini(ytr):.4f},最佳切分 = 特征{feat} 阈值{thr:.3f},"
f"增益={gain:.4f},切后 gini={gini(ytr) - gain:.4f}")
def build(X, y, depth=0, max_depth=3, min_samples_leaf=1):
"""递归建树,返回嵌套字典;叶子节点存多数类。"""
if depth >= max_depth or len(y) < 2 * min_samples_leaf or gini(y) == 0:
return {"leaf": np.bincount(y.astype(int), minlength=2).argmax()}
gain, feat, thr = best_split(X, y, min_samples_leaf)
if feat is None: # 找不到有效切分,退化为叶子
return {"leaf": np.bincount(y.astype(int), minlength=2).argmax()}
mask = X[:, feat] <= thr
return {"feat": feat, "thr": thr,
"left": build(X[mask], y[mask], depth + 1, max_depth, min_samples_leaf),
"right": build(X[~mask], y[~mask], depth + 1, max_depth, min_samples_leaf)}
def predict_one(node, x):
while "leaf" not in node:
node = node["left"] if x[node["feat"]] <= node["thr"] else node["right"]
return node["leaf"]
print("\n--- max_depth 从小到大:训练集越来越准,测试集在某一层开始变差 ---")
for depth in (1, 2, 3, 5, 8, 15):
tree = build(Xtr, ytr, max_depth=depth)
tr = np.mean([predict_one(tree, x) == t for x, t in zip(Xtr, ytr)])
te = np.mean([predict_one(tree, x) == t for x, t in zip(Xte, yte)])
print(f"max_depth={depth:2d} 训练准确率={tr:.3f} 测试准确率={te:.3f} "
f"差距={tr - te:+.3f}")
print("\n读法:训练准确率单调上升到 1.000,测试准确率却在 depth=3 附近见顶然后回落——")
print(" 这就是“树越深越好”的错觉。min_samples_leaf 的作用同理:它限制叶子最小样本数,")
print(" 相当于提前设了“再切也没意义”的门槛,比事后剪枝更省事。")
| 参数 | 含义 | 典型取值 | 调大与调小的影响 |
|---|---|---|---|
max_depth |
树最大深度 | 3 到 15,或不限 | 调大:拟合能力增强,易过拟合;调小:易欠拟合。这是控制复杂度最直接的旋钮 |
min_samples_split |
内部节点分裂所需最小样本数 | 2 到 100 | 调大:抑制分裂,正则化;调小:允许切出极小叶子 |
min_samples_leaf |
叶子节点最小样本数 | 1 到 50 | 调大:叶子更平滑,泛化更好,对不均衡数据尤其重要 |
max_features |
每次分裂考虑的特征数 | sqrt、log2、0.3 到 0.8 |
调小:增加随机性,降方差;调大:单树更强但整体相关性上升 |
max_leaf_nodes |
最大叶子数 | 不限,或 20 到 200 | 与 max_depth 二者选一控制,同时设则取更严格者 |
min_impurity_decrease |
分裂带来的最小不纯度下降 | 0 到 0.01 | 调大可剪掉收益微弱的分裂 |
criterion |
分裂准则 | gini、entropy、log_loss(分类);squared_error、absolute_error、friedman_mse(回归) |
分类上 gini 与 entropy 差别通常小于 1%;回归上 absolute_error 对离群值更鲁棒但慢 |
ccp_alpha |
代价复杂度剪枝强度 | 1e-5 到 1e-2 | 调大剪枝更狠,从 0 开始按对数网格递增 |
class_weight |
类别权重 | balanced |
不均衡分类必设 |
调参顺序建议:先定 max_depth 或 max_leaf_nodes 二者之一给出粗容量,再调 min_samples_leaf 抑制过拟合,最后用 ccp_alpha 做后剪枝。
成功标志(单树):训练集与验证集准确率差距小于 5 个百分点;树深度不超过 10 层时已能解释主要规则;叶子样本数分布不过度倾斜(无大量样本数小于 5 的叶子)。
4.5 随机森林
随机森林靠"样本扰动 + 特征扰动"降低方差,因此参数的核心是增加随机性与控制单树强度之间的平衡。
实现过程:随机森林的 fit() 是三件事的循环:bootstrap 抽样、特征子采样、训练一棵不剪枝的深树。下面手写一遍,并把 OOB 分数与“树间相关性”一起算出来——后者才是随机森林第一参数的真正解释。
"""4.5 随机森林:把 fit() 拆成三个动作。
RandomForestClassifier.fit() 内部就是一个循环,每轮做三件事:
1) bootstrap:有放回地抽 n 个样本,约 63.2% 的样本被抽到,剩下的是袋外样本(OOB)
2) 特征子采样:每次分裂只在随机挑的 max_features 个特征里找最优点
3) 训练一棵不剪枝的深树,存起来
预测时把所有树的输出投票(分类)或平均(回归)。
下面手写这个循环,用 sklearn 的单棵树当零件,这样 max_features 就是看得见的一行代码。
"""
import numpy as np
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
X, y = make_classification(n_samples=1200, n_features=20, n_informative=8,
n_redundant=5, flip_y=0.03, random_state=42)
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.3, random_state=42)
n, d = Xtr.shape
def my_forest(X, y, n_trees=300, max_features="sqrt", seed=0, use_feature_subset=True):
"""返回 (树列表, 每棵树的特征子集, OOB 概率)。"""
rng = np.random.default_rng(seed)
mf = max(1, int(np.sqrt(X.shape[1]))) if max_features == "sqrt" else int(max_features)
trees, feats, oob_sum, oob_cnt = [], [], np.zeros(len(y)), np.zeros(len(y))
for _ in range(n_trees):
idx = rng.integers(0, len(y), len(y)) # 步骤 1:bootstrap,有放回抽同样多的样本
feat = np.sort(rng.choice(X.shape[1], mf, replace=False)) if use_feature_subset \
else np.arange(X.shape[1]) # 步骤 2:每次分裂只看 mf 个特征
tree = DecisionTreeClassifier(random_state=seed).fit(X[np.ix_(idx, feat)], y[idx])
trees.append(tree)
feats.append(feat)
oob = np.setdiff1d(np.arange(len(y)), idx) # 袋外样本:这一轮没被抽到的
if len(oob): # 步骤 3 的副产品:OOB 预测
oob_sum[oob] += tree.predict_proba(X[np.ix_(oob, feat)])[:, 1]
oob_cnt[oob] += 1
oob_prob = np.divide(oob_sum, oob_cnt, out=np.full_like(oob_sum, 0.5), where=oob_cnt > 0)
return trees, feats, oob_prob
def forest_predict(trees, feats, X, threshold=0.5):
"""投票:把每棵树的概率平均,再按阈值判定。"""
prob = np.mean([t.predict_proba(X[:, f])[:, 1] for t, f in zip(trees, feats)], axis=0)
return (prob > threshold).astype(int), prob
def avg_tree_corr(trees, feats, X):
"""树间平均相关系数:集成能不能降方差,全看这个数。"""
P = np.array([t.predict_proba(X[:, f])[:, 1] for t, f in zip(trees, feats)])
C = np.corrcoef(P)
n = len(C)
return (C.sum() - n) / (n * (n - 1)) # 减去对角线上的 1 再取平均
# ---------- 对照实验 ----------
single = DecisionTreeClassifier(random_state=0).fit(Xtr, ytr)
print(f"单棵深树:训练 {single.score(Xtr, ytr):.3f} 测试 {single.score(Xte, yte):.3f}")
for mf in ("sqrt", 8, 20):
trees, feats, oob_prob = my_forest(Xtr, ytr, n_trees=300, max_features=mf)
acc, _ = forest_predict(trees, feats, Xte)
oob_acc = np.mean((oob_prob > 0.5).astype(int) == ytr)
print(f"森林 max_features={str(mf):>4}:测试 {(acc == yte).mean():.3f} "
f"OOB {oob_acc:.3f} 树间相关性 {avg_tree_corr(trees, feats, Xte):.3f}")
print("\n读法:max_features 越小,树间相关性越低——这就是它成为随机森林第一参数的原因。")
print(" 集成的方差约等于 rho*sigma^2 + (1-rho)*sigma^2/T,rho 是树间相关性、T 是树数:")
print(" 树数 T 再怎么加,也只能消掉后面那一项;真正决定下限的是 rho,而 rho 由 max_features 决定。")
print(" 所以“把 n_estimators 调到 5000”救不了相关性高的森林,调小 max_features 才是正解。")
| 参数 | 含义 | 典型取值 | 调大与调小的影响 |
|---|---|---|---|
n_estimators |
树的数量 | 100 到 1000 | 单调不降指标,到某点后收益饱和。不存在过拟合风险,只增加计算成本 |
max_features |
每次分裂的候选特征数 | 分类 sqrt,回归 1/3 |
调小:树更不相关,集成方差更低,但单树更弱;这是随机森林最重要的参数 |
max_depth |
单树深度 | 不限,或 10 到 30 | 随机森林通常让树充分生长,靠集成降方差,不必强剪 |
min_samples_leaf |
叶子最小样本数 | 1 到 10 | 调大:平滑噪声,回归任务上尤其有效 |
min_samples_split |
内部节点最小样本数 | 2 到 20 | 与上一条类似,优先调 min_samples_leaf |
bootstrap |
是否有放回抽样 | True | 设 False 则失去 Bagging 的样本扰动,只剩特征扰动,不推荐 |
oob_score |
是否计算袋外得分 | True | 设为 True 可免费获得一个近似验证集指标,是小数据集的实用技巧 |
class_weight |
类别权重 | balanced、balanced_subsample |
后者按每棵树的 bootstrap 样本计算权重,不均衡时更稳 |
n_jobs |
并行核数 | -1 | 不影响结果,只影响速度 |
调参要点:
n_estimators先设大(如 500),后面调其他参数时不必反复动它。- 随机森林对
max_features最敏感,建议在sqrt到 0.6 之间搜索。 - 若 OOB 分数与交叉验证分数接近(差距小于 0.01),说明模型稳定,可信任 OOB 作为快速评估。
成功标志:OOB 分数与 5 折交叉验证分数差距小于 0.01;增加树数量后指标曲线已走平;特征重要性排序在多次随机种子下基本一致(前 5 名重叠率高于 80%)。
4.6 梯度提升树:XGBoost、LightGBM、CatBoost
梯度提升树是表格数据上的王者,也是面试中参数问题最密集的地方。三个实现的参数体系高度相通,先讲通用逻辑再讲差异。
通用参数分组
实现过程:梯度提升每一轮只做一件事:用浅树拟合上一轮的残差,乘 learning_rate 再累加。lr 与 n_estimators 的反比关系就是从这个循环直接长出来的,不是调参经验。
"""4.6 梯度提升:每一轮都在拟合"上一轮错在哪"。
XGBoost / LightGBM / CatBoost 的骨架完全一样,只差工程细节:
1) 初始化一个常数预测 F0(分类用对数几率,回归用均值)
2) 每轮算负梯度(二分类下就是 y - p,即残差)
3) 用一棵浅树去拟合这个残差
4) 把树的输出乘以 learning_rate 累加到 F 上
learning_rate 与 n_estimators 的反比关系,从这个循环里一眼能看出来:
每轮的贡献被 lr 缩小,所以要达到同样的拟合程度就得多跑几轮。
"""
import numpy as np
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeRegressor
X, y = make_classification(n_samples=2000, n_features=15, n_informative=6,
flip_y=0.12, random_state=42) # 12% 标签噪声,模拟真实脏数据
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.3, random_state=42)
def sigmoid(z):
return 1 / (1 + np.exp(-np.clip(z, -30, 30)))
def logloss(y, p):
p = np.clip(p, 1e-12, 1 - 1e-12)
return -np.mean(y * np.log(p) + (1 - y) * np.log(1 - p))
def gbdt(Xtr, ytr, Xte, yte, lr=0.1, n_trees=100, depth=3):
"""最简 GBDT:二分类 + 对数几率 + 回归树拟合残差。"""
p0 = np.clip(ytr.mean(), 1e-6, 1 - 1e-6)
F_tr = np.full(len(ytr), np.log(p0 / (1 - p0))) # 步骤 1:常数初始化,等价于“全猜先验”
F_te = np.full(len(yte), np.log(p0 / (1 - p0)))
for _ in range(n_trees):
p = sigmoid(F_tr)
resid = ytr - p # 步骤 2:负梯度 = 残差
tree = DecisionTreeRegressor(max_depth=depth, random_state=0)
tree.fit(Xtr, resid) # 步骤 3:用浅树拟合残差
F_tr += lr * tree.predict(Xtr) # 步骤 4:乘以 lr 再累加(shrinkage)
F_te += lr * tree.predict(Xte)
return logloss(yte, sigmoid(F_te))
print("--- learning_rate 与 n_estimators 的反比关系 ---")
for lr, n in [(0.3, 30), (0.3, 100), (0.1, 100), (0.1, 300), (0.03, 300), (0.03, 1000)]:
loss = gbdt(Xtr, ytr, Xte, yte, lr=lr, n_trees=n)
print(f"lr={lr:<5} n_trees={n:<5} 测试 logloss={loss:.4f}")
print("\n--- 树深度的作用:depth 越大,单棵树越强,也越容易过拟合 ---")
for depth in (1, 2, 3, 6, 10):
loss = gbdt(Xtr, ytr, Xte, yte, lr=0.1, n_trees=300, depth=depth)
print(f"max_depth={depth} 测试 logloss={loss:.4f}")
print("\n读法:lr=0.3/30 棵与 lr=0.03/300 棵的 logloss 会落在同一个量级——")
print(" 它们的“总步长” lr 乘 n_trees 接近,只是后者步子小、走得更细,通常略好一点。")
print(" 这就是调参时“先定 n_estimators 上限,再调 lr”的依据:lr 减半,树数大约要翻倍。")
print(" depth 那一组是标准 U 形:1 到 3 提升明显,6 以后回退,10 回到 0.4408,比 depth=1 的 0.4403 还差——")
print(" 因为单棵树太强会把噪声也学进去,而 GBDT 是串行的,学错的部分后面还会接着放大。")
| 组别 | 参数 | 作用 |
|---|---|---|
| 容量控制 | max_depth、num_leaves、max_leaf_nodes |
决定单棵树的复杂度 |
| 正则控制 | min_child_weight、min_child_samples、reg_lambda、reg_alpha、gamma |
抑制过拟合 |
| 随机性 | subsample、colsample_bytree、colsample_bylevel |
行采样与列采样 |
| 学习过程 | learning_rate、n_estimators |
二者强耦合,需联合搜索 |
| 效率 | n_jobs、max_bin、tree_method |
影响速度与内存 |
XGBoost 参数表
| 参数 | 含义 | 典型取值 | 调大与调小的影响 |
|---|---|---|---|
n_estimators |
提升轮数 | 100 到 5000 | 与 learning_rate 反向耦合;配合早停使用 |
learning_rate(eta) |
每棵树的收缩步长 | 0.01 到 0.3 | 调小:需要更多树,泛化通常更好;调大:收敛快但易过拟合 |
max_depth |
单树最大深度 | 3 到 10 | 调大容量增强,超过 10 层收益极小且内存暴涨 |
min_child_weight |
叶子节点最小样本权重和(回归即样本数,分类为 hessian 和) | 1 到 20 | 最重要的正则参数之一,调大显著抑制过拟合 |
gamma(min_split_loss) |
分裂所需最小损失下降 | 0 到 5 | 调大则分裂更保守,相当于预剪枝 |
subsample |
行采样比例 | 0.6 到 1.0 | 调小增加随机性,降方差 |
colsample_bytree |
建每棵树时的列采样比例 | 0.6 到 1.0 | 同上,高维特征时尤其有效 |
colsample_bylevel |
每层分裂的列采样比例 | 0.6 到 1.0 | 更细粒度的随机性 |
reg_lambda |
L2 正则系数 | 0 到 10 | 调大抑制叶子权重过大 |
reg_alpha |
L1 正则系数 | 0 到 10 | 调大产生稀疏,可做特征筛选 |
scale_pos_weight |
正负样本权重比 | 负样本数/正样本数 | 不均衡分类的关键参数 |
objective |
目标函数 | binary:logistic、multi:softprob、reg:squarederror |
必须与任务匹配,分类用平方误差是常见错误 |
eval_metric |
评估指标 | auc、logloss、rmse、mae |
与 objective 可以不同,用于早停判断 |
tree_method |
建树算法 | hist、approx、exact、gpu_hist |
大数据用 hist,GPU 用 gpu_hist |
early_stopping_rounds |
早停耐心轮数 | 20 到 100 | 设为 0 则关闭早停;过小会过早停止 |
max_bin |
特征离散化桶数 | 128 到 512 | 调大精度更高但更慢、更易过拟合 |
LightGBM 特有参数
| 参数 | 含义 | 典型取值 | 说明 |
|---|---|---|---|
num_leaves |
单树最大叶子数 | 31 到 255 | LightGBM 按叶子生长,它比 max_depth 更能代表容量。经验关系:num_leaves <= 2^max_depth |
min_data_in_leaf |
叶子最小样本数 | 20 到 200 | 大数据集必调大,默认 20 在小数据上易过拟合 |
min_sum_hessian_in_leaf |
叶子最小 hessian 和 | 1e-3 到 10 | 与 min_data_in_leaf 配合 |
feature_fraction |
列采样比例 | 0.6 到 1.0 | 等价于 colsample_bytree |
bagging_fraction |
行采样比例 | 0.6 到 1.0 | 等价于 subsample |
bagging_freq |
行采样频率 | 1 到 5 | 设为 0 则 bagging_fraction 失效,这是最常见的配置疏漏 |
lambda_l1、lambda_l2 |
L1 与 L2 正则 | 0 到 10 | 对应 XGBoost 的 reg_alpha、reg_lambda |
cat_smooth、cat_l2 |
类别特征平滑与正则 | 10、10 | 类别特征基数大时必须调大,否则严重过拟合 |
max_cat_threshold |
类别特征分裂的最大阈值数 | 32 | 高基数类别特征的上限 |
boosting_type |
提升类型 | gbdt、dart、goss |
dart 抗过拟合但慢;goss 省样本但需关闭 bagging |
CatBoost 特有参数
| 参数 | 含义 | 典型取值 | 说明 |
|---|---|---|---|
iterations |
迭代轮数 | 500 到 5000 | 等价于 n_estimators |
depth |
树深度 | 4 到 10 | CatBoost 默认 6,对称树结构使其不宜过深 |
l2_leaf_reg |
L2 正则 | 1 到 10 | 默认 3 |
one_hot_max_size |
低于该基数的类别做 one-hot | 2 到 255 | 高于该值走目标统计编码 |
random_strength |
分裂打分的随机扰动强度 | 0 到 10 | 调大增加随机性,抗过拟合 |
bagging_temperature |
贝叶斯 bootstrap 温度 | 0 到 1 | 调大增加采样随机性 |
border_count |
数值特征分桶数 | 128 到 254 | 与 max_bin 同义 |
grow_policy |
生长策略 | SymmetricTree、Depthwise、Lossguide |
默认对称树,速度最快且抗过拟合 |
梯度提升树的调参决策路径
| 步骤 | 动作 | 判断依据 |
|---|---|---|
| 1 | 固定 learning_rate=0.1,用早停确定 n_estimators |
验证集指标连续 50 轮不提升 |
| 2 | 调 max_depth(XGB)或 num_leaves 加 min_data_in_leaf(LGB) |
验证集与训练集指标差距是否收敛到 3 个百分点内 |
| 3 | 调 min_child_weight 或 min_data_in_leaf |
同上,这是抑制过拟合最有效的一步 |
| 4 | 调 subsample、colsample_bytree |
在 0.6 到 0.9 之间搜索,通常取中间值 |
| 5 | 调 reg_lambda、reg_alpha、gamma |
前述步骤仍有过拟合才需要 |
| 6 | 最后降低 learning_rate 到 0.02 到 0.05,重新确定树数 |
通常再涨 0.5 到 1 个百分点,代价是训练时间成倍 |
三个实现的取舍:数据量中等、需要极致精度与成熟生态,选 XGBoost;数据量大、特征维度高、训练时间敏感,选 LightGBM;类别特征多、想少做预处理,选 CatBoost。LightGBM 在小数据上默认参数最易过拟合,务必调大
min_data_in_leaf。
4.7 支持向量机
实现过程:SVM 的目标函数只有两项:间隔项与合页损失。C 是这两项的兑换率。代码用次梯度下降手写一遍,再用核技巧推到非线性,最后对照真实 SMO 求解器的稀疏性。
"""4.7 支持向量机:合页损失 + 间隔的完整实现。
SVC 的目标函数只有两项,写成代码就是这么直白:
损失 = 0.5 * ||w||^2 + C * sum(max(0, 1 - y_i * (w·x_i + b)))
~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
间隔越大越好 分类错了、或离边界太近就要罚
C 就是这两项的兑换率:C 越大,越不容忍违反间隔(容易过拟合);C 越小,间隔越宽(容易欠拟合)。
下面用次梯度下降手写这个优化,再用核技巧把它推到非线性情形。
"""
import numpy as np
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
X, y = make_moons(n_samples=600, noise=0.25, random_state=42)
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.3, random_state=42)
sc = StandardScaler().fit(Xtr) # SVM 对尺度敏感,先标准化是必须的
Xtr, Xte = sc.transform(Xtr), sc.transform(Xte)
ys = np.where(ytr == 1, 1.0, -1.0) # SVM 用 ±1 标签,方便写间隔
def linear_svm(X, y, C=1.0, lr=0.5, epochs=500):
"""合页损失的次梯度下降。sklearn 的 C 对应 lam = 1/(C*n),lam 就是 L2 项的系数。"""
n, d = X.shape
lam = 1.0 / (C * n) # C 越大 lam 越小,正则越弱,间隔越窄
w, b = np.zeros(d), 0.0
for _ in range(epochs):
margins = y * (X @ w + b)
active = margins < 1 # 只有“违反间隔”的样本产生梯度
grad_w = lam * w - (X[active] * y[active, None]).mean(axis=0)
grad_b = -y[active].mean()
w -= lr * grad_w
b -= lr * grad_b
return w, b
print("--- C 的作用:间隔宽度与容错量的兑换 ---")
for C in (0.001, 0.01, 1.0, 100.0):
w, b = linear_svm(Xtr, ys, C=C)
margin_width = 2 / (np.linalg.norm(w) + 1e-12) # 间隔宽度 = 2/||w||
acc_tr = np.mean(np.sign(Xtr @ w + b) == ys)
acc_te = np.mean(np.sign(Xte @ w + b) == np.where(yte == 1, 1.0, -1.0))
n_sv = np.sum(ys * (Xtr @ w + b) < 1.0) # 支持向量 = 落在间隔内或分错的点
print(f"C={C:<7} ||w||={np.linalg.norm(w):.3f} 间隔宽={margin_width:.3f} "
f"支持向量={n_sv:3d} 训练 {acc_tr:.3f} 测试 {acc_te:.3f}")
def rbf_kernel(A, B, gamma):
"""K(x,z) = exp(-gamma * ||x-z||^2)。核技巧的作用是:不用显式升维,也能在高维空间做内积。"""
d2 = ((A[:, None, :] - B[None, :, :]) ** 2).sum(-1)
return np.exp(-gamma * d2)
print("\n--- 换 RBF 核:线性分不开的月牙数据 ---")
Ktr = rbf_kernel(Xtr, Xtr, gamma=2.0)
Kte = rbf_kernel(Xte, Xtr, gamma=2.0)
# 在对偶空间里,模型只需存 alpha(每个训练样本一个系数),预测时用核函数加权
alpha = np.zeros(len(ytr))
for _ in range(600):
margin = ys * (Ktr @ alpha)
active = margin < 1
alpha += 0.05 * (ys * active - 0.01 * alpha) # 合页损失的对偶次梯度
pred_te = np.sign(Kte @ alpha)
print(f"RBF 核(gamma=2)测试准确率 = {np.mean(pred_te == np.where(yte == 1, 1.0, -1.0)):.3f}")
print(f"手写次梯度得到的 alpha 非零数 = {int(np.sum(np.abs(alpha) > 1e-6))} / {len(alpha)}")
from sklearn.svm import SVC # 对照:真实 SMO 求解器的稀疏性
svc = SVC(kernel="rbf", gamma=2.0, C=1.0).fit(Xtr, ytr)
print(f"sklearn SVC 的支持向量 = {len(svc.support_)} / {len(ytr)},"
f"测试准确率 = {svc.score(Xte, yte):.3f}")
print("\n读法:C 从 0.001 涨到 100,||w|| 单调上升、间隔单调变窄、支持向量单调变少,")
print(" 训练准确率一路走高而测试准确率在 C=1 附近见顶——这就是“C 是正则强度的倒数”。")
print(" gamma 反过来控制单点的影响力半径:gamma 越大,每个支持向量的影响范围越小,边界越弯曲。")
print(" 最后两行是个诚实的对照:手写次梯度法给出的是稠密 alpha,一个都没归零;")
print(" 真实 SVC 用 SMO 坐标下降,只有支持向量的 alpha 非零。稀疏性是求解算法给的,不是模型定义给的。")
| 参数 | 含义 | 典型取值 | 调大与调小的影响 |
|---|---|---|---|
C |
惩罚系数,权衡间隔与误分类 | 0.1 到 1000,对数网格 | 调大:容忍更少误分类,间隔变窄,易过拟合;调小:间隔变宽,更平滑,易欠拟合 |
kernel |
核函数 | rbf、linear、poly、sigmoid |
特征数远大于样本数时用 linear;非线性边界用 rbf |
gamma |
RBF 核的宽度参数 | scale(默认)、auto、1e-3 到 10 |
调大:单个样本影响范围变小,边界更弯曲,易过拟合;调小:边界趋于平直,易欠拟合 |
degree |
多项式核阶数 | 2 到 5 | 仅 poly 核有效,阶数过高易过拟合 |
coef0 |
核函数常数项 | 0 | 仅 poly 与 sigmoid 有效 |
class_weight |
类别权重 | balanced |
不均衡任务必设 |
probability |
是否输出概率 | True | 开启后用 Platt 缩放,会显著变慢,但能拿到概率与 AUC |
调参要点:
C与gamma必须联合网格搜索,单独调任一个都会得到误导性结论。推荐C取 10 的幂次、gamma取 10 的负幂次做二维网格。- SVM 对量纲极度敏感,不标准化时 RBF 核几乎必然失效。
- 样本超过 10 万时训练时间不可接受,改用线性 SVM(
LinearSVC)或树模型。
成功标志:支持向量占比在 10% 到 50% 之间(占比过高说明 C 太小或数据不可分,接近 100% 说明严重欠拟合);训练与验证指标差距小于 5 个百分点。
4.8 K 近邻
实现过程:KNN 没有训练过程,predict() 才是全部:算距离、排序、取前 k 个、投票。四个参数全作用在这四步上,而“必须标准化”是第一步的数学后果,不是使用建议。
"""4.8 K 近邻:整个模型就是一次距离排序。
KNeighborsClassifier 没有训练过程,fit() 只是把训练集存下来,predict() 才做四件事:
1) 算测试样本到所有训练样本的距离
2) 排序,取前 k 个
3) 按距离倒数加权投票(weights="distance")或直接投票(weights="uniform")
4) 返回票数最多的类
四个参数全部作用在这四步上:k 决定第 2 步取几个,weights 决定第 3 步怎么算,p 决定第 1 步用哪种距离。
下面特别加了一组"未标准化"的对照——这是 KNN 最致命的实践陷阱。
"""
import numpy as np
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
X, y = make_classification(n_samples=700, n_features=10, n_informative=3, n_redundant=2,
class_sep=0.9, flip_y=0.12, random_state=42) # 带 12% 噪声,边界不干净
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.3, random_state=42)
def knn_predict(Xtr, ytr, Xte, k=5, weights="uniform", p=2):
"""p=2 欧氏距离,p=1 曼哈顿距离;weights 决定近邻的投票权重。"""
# 第 1 步:向量化算距离,避免双重循环
if p == 2:
D = np.sqrt(((Xte[:, None, :] - Xtr[None, :, :]) ** 2).sum(-1))
else:
D = np.abs(Xte[:, None, :] - Xtr[None, :, :]).sum(-1)
# 第 2 步:取前 k 个最近邻的下标
nn = np.argsort(D, axis=1)[:, :k]
preds = []
for row, d in zip(nn, np.take_along_axis(D, nn, axis=1)):
labels = ytr[row]
# 第 3 步:投票。distance 加权用 1/(d+eps),避免除零
w = np.ones(k) if weights == "uniform" else 1.0 / (d + 1e-9)
score = np.bincount(labels, weights=w, minlength=2)
preds.append(score.argmax()) # 第 4 步:取票数最高的类
return np.array(preds)
print("--- k 的影响(weights=uniform)---")
for k in (1, 3, 5, 11, 21, 51, 101):
acc = np.mean(knn_predict(Xtr, ytr, Xte, k=k) == yte)
print(f"k={k:<3} 测试准确率={acc:.4f}")
print("\n--- 同样 k=11,换权重与距离 ---")
for w in ("uniform", "distance"):
for p in (1, 2):
acc = np.mean(knn_predict(Xtr, ytr, Xte, k=11, weights=w, p=p) == yte)
print(f"weights={w:<9} p={p} 测试准确率={acc:.4f}")
# ---------- 致命陷阱:不标准化 ----------
Xtr_bad, Xte_bad = Xtr.copy(), Xte.copy()
Xtr_bad[:, 0] *= 1000 # 只把一个特征的量纲放大 1000 倍
Xte_bad[:, 0] *= 1000
acc_bad = np.mean(knn_predict(Xtr_bad, ytr, Xte_bad, k=11) == yte)
acc_ok = np.mean(knn_predict(Xtr, ytr, Xte, k=11) == yte)
print(f"\n未标准化(第 1 个特征乘 1000):准确率 {acc_bad:.4f}")
print(f"已标准化(原始尺度) :准确率 {acc_ok:.4f}")
print("\n读法:k=1 准确率最低(0.738),k=3 到 11 最好(0.80 上下),之后逐档回落——")
print(" k=1 等于把每个噪声点都当真(过拟合),k 太大则把远处不相干的类也拉来投票(欠拟合)。")
print(" k 的经验起点是 sqrt(n),本例 sqrt(490) 约 22,但实测最优点在 3 到 11,")
print(" 说明这个经验值只是起点,必须真搜——它取决于噪声水平与样本密度。")
print(" weights 与 p 的差异只有半个点,属正常:它们只影响边界附近的少数样本。")
print(" 真正致命的是最后两行:一个特征放大 1000 倍就等于让它独占全部权重,")
print(" 准确率从 0.79 掉到 0.71。所以“KNN 必须标准化”不是建议,是前提。")
| 参数 | 含义 | 典型取值 | 调大与调小的影响 |
|---|---|---|---|
n_neighbors |
邻居数 | 3 到 50,奇数 | 调大:决策边界更平滑,方差降、偏差升,极端情况退化为多数类;调小:边界贴合噪声,易过拟合 |
weights |
邻居权重 | uniform、distance |
distance 让近邻权重更高,通常小幅提升,但对噪声敏感 |
metric |
距离度量 | euclidean、manhattan、cosine |
高维稀疏文本用 cosine;特征量纲差异大用 manhattan |
p |
明可夫斯基距离阶数 | 1 或 2 | 1 等价曼哈顿,2 等价欧氏 |
algorithm |
近邻搜索算法 | auto、kd_tree、ball_tree、brute |
低维用树,高维(超过 20 维)树结构退化,用 brute |
leaf_size |
树结构叶子大小 | 20 到 40 | 影响搜索速度不影响结果 |
成功标志:n_neighbors 扫描曲线上有明显最小值(通常落在 5 到 20 之间);交叉验证方差随 k 增大而下降;k 取 1 时训练集准确率为 100%(这是正常现象,可作为实现正确性的自检)。
4.9 朴素贝叶斯
实现过程:朴素贝叶斯的实现就是“数词 + 取对数 + 加平滑”,没有迭代、没有梯度。参数只有 alpha,而它解决的是训练集没见过的词概率为 0 这个致命问题。
"""4.9 朴素贝叶斯:条件独立假设下的"数词 + 加平滑"。
MultinomialNB 的 fit() 只做两件事:
1) 数每个类里每个词出现了多少次,除以该类总词数,得到 P(词|类)
2) 取对数存起来
predict() 就是把该样本出现的每个词的 log P(词|类) 加上先验 log P(类),比大小。
所以参数远少于其他算法:真正起作用的只有 alpha(平滑)和 fit_prior(先验)。
alpha 是这一段代码里唯一需要调的东西,它解决的是"训练集没见过的词概率为 0"的问题。
"""
import numpy as np
from sklearn.feature_extraction.text import CountVectorizer
# 极简语料:两类邮件,词表刻意留了几个只在某一类出现的词
docs = [
"发票 报销 流程 财务", "发票 抬头 财务 报销", "报销 单据 财务 审核",
"发票 财务 报销 流程", "报销 流程 财务 单据",
"会议 纪要 项目 进度", "会议 安排 项目 讨论", "项目 进度 会议 纪要",
"会议 讨论 项目 安排", "项目 纪要 讨论 进度",
]
labels = np.array([0, 0, 0, 0, 0, 1, 1, 1, 1, 1])
vec = CountVectorizer(token_pattern=r"(?u)\b\w+\b")
Xtr = vec.fit_transform(docs).toarray()
vocab = vec.get_feature_names_out()
print("词表:", " ".join(vocab))
def fit_naive_bayes(X, y, alpha=1.0, fit_prior=True):
"""返回 log 先验与 log 条件概率矩阵,形状 (类别数, 词数)。"""
classes = np.unique(y)
log_prior, log_lik = [], []
for c in classes:
Xc = X[y == c]
# 先验:该类样本占比。fit_prior=False 时退化为均匀分布
log_prior.append(np.log(len(Xc) / len(X)) if fit_prior else np.log(1 / len(classes)))
# 条件概率:加 alpha 平滑后取对数。alpha=1 就是拉普拉斯平滑
counts = Xc.sum(axis=0) + alpha
with np.errstate(divide="ignore"): # alpha=0 时必然出现 log(0),这里故意不拦
log_lik.append(np.log(counts / counts.sum()))
return np.array(log_prior), np.array(log_lik)
def predict(X, log_prior, log_lik):
"""对数域相加,避免连乘下溢;这一步也是"为什么朴素贝叶斯不怕高维"的答案。"""
score = X @ log_lik.T + log_prior
return score.argmax(axis=1), score
def predict_one(x, log_prior, log_lik):
"""单个样本:只对本样本出现的词求和,这样 -inf 不会被 0 乘成 nan。"""
nz = x > 0
return x[nz] @ log_lik[:, nz].T + log_prior
print("\n--- alpha 的影响:看一个两类词各半的模糊样本 ---")
probe = "发票 会议" # 类 0 认识“发票”,类 1 认识“会议”
x_probe = np.zeros(len(vocab))
for w in probe.split():
x_probe[list(vocab).index(w)] = 1
for alpha in (0.001, 0.1, 1.0, 10.0):
lp, ll = fit_naive_bayes(Xtr, labels, alpha=alpha)
s = predict_one(x_probe, lp, ll)
print(f"alpha={alpha:<6} 得分={np.round(s, 2)} 判定=类{s.argmax()} "
f"两类分差={abs(s[0] - s[1]):.2f}")
# ---------- alpha=0 会发生什么 ----------
lp, ll = fit_naive_bayes(Xtr, labels, alpha=0.0)
new_doc = "发票 报销 会议" # 其中“会议”在类 0 中从未出现
x_new = np.zeros(len(vocab))
for w in new_doc.split():
x_new[list(vocab).index(w)] = 1
score = predict_one(x_new, lp, ll)
print(f"\nalpha=0 时,新样本“{new_doc}”的对数得分:{np.round(score, 2)}")
print(f"两类得分都是 {score[0]}:-inf 就是 log(0)。类 0 没见过“会议”,类 1 没见过“报销”,")
print("于是每条得分都被一个缺失词拉成了负无穷——无论其他词多支持它,都救不回来。")
print("这就是 add-one 平滑存在的理由:把 0 换成 alpha,让没见过的词只扣一点分,而不是一票否决。")
print("\n--- alpha 调大,概率被拉平 ---")
for alpha in (0.001, 1.0, 100.0):
_, ll = fit_naive_bayes(Xtr, labels, alpha=alpha)
spread = ll.max(axis=1) - ll.min(axis=1) # 每类内部概率的极差
print(f"alpha={alpha:<6} 各类 log 概率极差 = {np.round(spread, 2)}"
f" (极差越小,说明概率被平滑得越平)")
print("\n读法:alpha 太小会过拟合到训练集里偶发的词,太大则把所有词的概率拉平、失去区分力。")
print(" 文本任务常用 0.1 到 1.0;样本越少、词表越大,越应往大取。")
print(" 注意最后一段:alpha 增大时类内概率极差在缩小,这正是“平滑”的字面含义。")
| 变体 | 关键参数 | 适用数据 |
|---|---|---|
| GaussianNB | var_smoothing(默认 1e-9) |
连续特征,近似正态 |
| MultinomialNB | alpha(拉普拉斯平滑,默认 1.0)、fit_prior |
词频、计数特征 |
| BernoulliNB | alpha、binarize(二值化阈值) |
二值特征 |
| ComplementNB | alpha、norm |
不平衡文本分类 |
alpha 的影响:调大平滑更强,缓解零概率问题但削弱区分度;调小趋向最大似然,稀疏特征下易出现零概率。文本分类常用 0.1 到 1.0。
成功标志:作为基线,若复杂模型无法显著超越朴素贝叶斯(提升小于 2 个百分点),说明特征的信息量已接近饱和,应转去补数据而非换模型。
4.10 聚类算法
K-Means
实现过程:KMeans 是 E/M 两步的交替迭代,DBSCAN 是沿密度向外生长。前者怕初始化(所以要 n_init),后者怕 eps。下面把两种算法都手写一遍,顺便验证 n_init 到底在防什么。
"""4.10 聚类:KMeans 的两个步骤,与 DBSCAN 的区域生长。
KMeans 的 fit() 是一个交替优化的死循环,直到中心不再移动:
E 步:把每个点分给最近的中心(argmin)
M 步:把每个中心移到其成员的均值(mean)
所谓"初始化敏感",是因为 E 步第一次分配完全由初始中心决定,分错了后面只是在其附近收敛。
所谓"必须标准化",是因为距离会被大量纲特征支配,和 KNN 同病。
DBSCAN 完全不同:它不预设簇数,而是沿密度连通区域"长"过去,参数只有 eps 与 min_samples。
"""
import numpy as np
from sklearn.datasets import make_blobs
X, y_true = make_blobs(n_samples=600, centers=4, cluster_std=0.9, random_state=42)
def kmeans(X, k, seed=0, max_iter=100):
"""返回 (标签, 中心, 惯性)。初始化用 k-means++:让初始中心尽量互相远离。"""
rng = np.random.default_rng(seed)
centers = [X[rng.integers(len(X))]] # 第一个中心随机取
for _ in range(k - 1): # k-means++:后续中心按 D^2 概率采样
d2 = np.min(((X[:, None, :] - np.array(centers)[None, :, :]) ** 2).sum(-1), axis=1)
centers.append(X[rng.choice(len(X), p=d2 / d2.sum())])
C = np.array(centers)
for _ in range(max_iter):
# E 步:每个点归给最近的中心
labels = ((X[:, None, :] - C[None, :, :]) ** 2).sum(-1).argmin(axis=1)
# M 步:中心 = 成员均值(空簇则保留原位)
newC = np.array([X[labels == j].mean(axis=0) if np.any(labels == j) else C[j]
for j in range(k)])
if np.allclose(newC, C): # 收敛判据:中心不再移动
break
C = newC
inertia = ((X - C[labels]) ** 2).sum() # 惯性 = 所有点到所属中心的平方距离和
return labels, C, inertia
print("--- n_clusters 的影响:惯性单调降,拐点才是真簇数 ---")
prev = None
for k in (1, 2, 3, 4, 5, 6, 8):
_, _, inertia = kmeans(X, k, seed=0)
drop = "-" if prev is None else f"{prev - inertia:.0f}"
print(f"k={k} 惯性={inertia:8.1f} 比上一档减少 {drop}")
prev = inertia
def dbscan(X, eps, min_samples):
"""区域生长:核心点的 eps 邻域内所有点归为同簇,边界点归入可达的簇。"""
n = len(X)
D = np.sqrt(((X[:, None, :] - X[None, :, :]) ** 2).sum(-1))
neighbors = [np.where(D[i] <= eps)[0] for i in range(n)]
core = np.array([len(nb) >= min_samples for nb in neighbors]) # 核心点:邻域样本数够多
labels = np.full(n, -1) # -1 表示噪声
cid = 0
for i in range(n):
if not core[i] or labels[i] != -1: # 非核心点、或已被访问,跳过
continue
stack, labels[i] = [i], cid # 从核心点出发,向外扩散
while stack:
p = stack.pop()
for q in neighbors[p]:
if labels[q] == -1: # 未访问的邻居纳入本簇
labels[q] = cid
if core[q]: # 邻居也是核心点,继续向外扩
stack.append(q)
cid += 1
return labels, core
print("\n--- DBSCAN:eps 决定多近才算邻居 ---")
for eps in (0.3, 0.6, 1.0, 1.8):
labels, core = dbscan(X, eps=eps, min_samples=8)
n_clu = len(set(labels) - {-1})
n_noise = int(np.sum(labels == -1))
print(f"eps={eps:<4} 簇数={n_clu} 噪声点={n_noise:3d} 核心点={int(core.sum()):3d}")
print("\n--- 同一个 k、换 5 个随机种子:这就是 n_init 要解决的问题 ---")
for k in (3, 4):
vals = [kmeans(X, k, seed=s)[2] for s in range(5)]
print(f"k={k}:惯性 {np.round(vals, 0)} 最差/最好 = {max(vals) / min(vals):.2f} 倍")
print("\n读法:KMeans 的惯性永远随 k 增大而下降,所以不能用惯性选 k——要看下降曲线的拐点,")
print(" 或者用轮廓系数。本例真值是 4 簇,惯性从 k=4 的 941.9 之后几乎不再下降,拐点很清晰。")
print(" 注意 k=3 那一档惯性高达 16583:不是“3 个簇本来就分不好”,而是 k-means++ 只在开局起作用,")
print(" 它保证初始中心分散,不保证收敛到全局最优。下面那组换种子的实验就是证据——")
print(" 同一个 k 的惯性最差与最好能差几倍。所以 sklearn 的 n_init 默认要跑 10 次取最优,")
print(" 不是为了稳妥,是因为单次结果真的不可靠。")
print(" DBSCAN 的 eps 太小会把整片数据打成噪声(eps=0.3 时 345 个噪声点、9 个碎簇),")
print(" 太大则所有簇被连成一个(eps=1.8 只剩 3 簇)。它没有簇数参数,簇数是被密度决定的。")
| 参数 | 含义 | 典型取值 | 说明 |
|---|---|---|---|
n_clusters |
簇数 | 2 到 50 | 用肘部法(SSE 曲线拐点)或轮廓系数确定 |
init |
初始化方式 | k-means++ |
必选 k-means++,随机初始化结果不稳定 |
n_init |
重启次数 | 10 到 50 | 取最优 inertia,缓解局部最优 |
max_iter |
单次迭代上限 | 300 到 1000 | 出现未收敛警告时调大 |
tol |
收敛容差 | 1e-4 | — |
random_state |
随机种子 | 固定整数 | 不固定则每次结果不同 |
DBSCAN
| 参数 | 含义 | 典型取值 | 说明 |
|---|---|---|---|
eps |
邻域半径 | 由 k 距离图拐点确定 | 调小簇更多更碎,大量点被标为噪声;调大簇合并 |
min_samples |
核心点的最小邻居数 | 特征数 + 1 到 2 倍特征数 | 调大更严格,噪声更多 |
metric |
距离度量 | euclidean |
— |
层次聚类
| 参数 | 含义 | 典型取值 | 说明 |
|---|---|---|---|
n_clusters |
切割的簇数 | 由树状图决定 | 也可用 distance_threshold 代替 |
linkage |
连接准则 | ward、average、complete、single |
ward 倾向球形等大小簇;single 会产生链式长簇 |
distance_threshold |
切割高度 | 由树状图决定 | 与 n_clusters 二选一 |
高斯混合模型
| 参数 | 含义 | 典型取值 | 说明 |
|---|---|---|---|
n_components |
高斯成分数 | 2 到 20 | 用 BIC 或 AIC 最小化选择 |
covariance_type |
协方差形式 | full、tied、diag、spherical |
参数数量依次减少,样本少时用 diag |
reg_covar |
协方差对角正则 | 1e-6 到 1e-3 | 防止奇异协方差导致似然为负无穷 |
init_params |
初始化方式 | kmeans |
优于随机初始化 |
聚类"成功"的标志与监督学习不同,不能看准确率:
- 轮廓系数大于 0.5(0.25 到 0.5 说明结构弱,低于 0.25 基本无结构);
- 簇大小不极端失衡(最大簇与最小簇样本比小于 10);
- 业务可解释:每个簇能用两三个特征描述出清晰画像,否则聚类结果无法落地;
- 稳定性:换随机种子或自助采样后,用 ARI 衡量两次结果的相似度,应大于 0.7。
4.11 降维算法
PCA
实现过程:PCA 只有四步:中心化、算协方差、特征分解、投影。n_components 决定取几个特征向量,explained_variance_ratio_ 就是特征值占比。代码同时给出不中心化的对照。
"""4.11 降维:PCA 就是一次协方差矩阵的特征分解。
PCA 的全部计算只有四步:
1) 中心化:每个特征减去均值(不中心化,第一主成分会指向均值方向,结果毫无意义)
2) 算协方差矩阵:C = X^T X / (n-1)
3) 对 C 做特征分解,特征值从大到小排序
4) 取前 k 个特征向量,把数据投影上去
n_components 决定第 4 步取几个;explained_variance_ratio_ 就是特征值占比。
下面同时给出"不标准化"的对照——这是 PCA 最容易被忽略的陷阱。
"""
import numpy as np
from sklearn.datasets import load_digits
from sklearn.manifold import TSNE
X, y = load_digits(return_X_y=True)
X = X / 16.0 # 像素值归一到 0 到 1
print(f"原始数据:{X.shape[0]} 个样本,{X.shape[1]} 维")
# 步骤 1 到 3:中心化、协方差、特征分解
Xc = X - X.mean(axis=0)
cov = Xc.T @ Xc / (len(X) - 1)
eigvals, eigvecs = np.linalg.eigh(cov) # eigh 用于对称矩阵,比 eig 快且稳
order = np.argsort(eigvals)[::-1] # 从大到小排
eigvals, eigvecs = eigvals[order], eigvecs[:, order]
explained = eigvals / eigvals.sum() # 每个主成分解释的方差比例
cum = np.cumsum(explained)
print(f"前 10 个主成分的方差占比:{np.round(explained[:10], 3)}")
# 步骤 4:投影到 k 维
print("\n--- n_components 与保留信息量 ---")
for k in (2, 5, 10, 20, 40):
Z = Xc @ eigvecs[:, :k]
print(f"n_components={k:2d} 累计解释方差={cum[k - 1]:.3f} "
f"维度压缩比={X.shape[1] / k:.1f} 倍")
# ---------- 陷阱:不中心化直接分解 ----------
U, S, _ = np.linalg.svd(X, full_matrices=False) # sklearn 内部用 SVD,不用协方差,数值更稳
ratio_raw = S ** 2 / (S ** 2).sum()
U2, S2, _ = np.linalg.svd(Xc, full_matrices=False)
ratio_c = S2 ** 2 / (S2 ** 2).sum()
print(f"\n不中心化的第一主成分方差占比 = {ratio_raw[0]:.3f}")
print(f"已中心化的第一主成分方差占比 = {ratio_c[0]:.3f}")
print("(不中心化时,第一主成分主要指向均值方向,也就是把所有样本的亮度差异当成了结构)")
# ---------- t-SNE:perplexity 是什么 ----------
print("\n--- t-SNE 的 perplexity:每个点效仿多少个邻居 ---")
sub = np.random.default_rng(42).choice(len(X), 500, replace=False) # 500 点足够看趋势
Z_pca = Xc[sub] @ eigvecs[:, :20] # 先 PCA 到 20 维再 t-SNE,是标准做法
D_orig = np.sqrt(((Z_pca[:, None, :] - Z_pca[None, :, :]) ** 2).sum(-1))
knn_orig = np.argsort(D_orig, axis=1)[:, 1:11] # 原始空间的 10 个最近邻
def neighbor_preservation(emb, knn_ref, k=10):
"""2D 嵌入里的 k 近邻,有多大比例与原始空间的 k 近邻重合。"""
D = np.sqrt(((emb[:, None, :] - emb[None, :, :]) ** 2).sum(-1))
knn_2d = np.argsort(D, axis=1)[:, 1:k + 1]
return np.mean([len(set(a) & set(b)) / k for a, b in zip(knn_2d, knn_ref)])
for perp in (5, 30, 80):
emb = TSNE(n_components=2, perplexity=perp, init="pca", random_state=42,
max_iter=500).fit_transform(Z_pca)
print(f"perplexity={perp:2d} 近邻保持率={neighbor_preservation(emb, knn_orig):.3f}")
print("\n读法:累计解释方差告诉你丢了多少信息,但它只衡量方差、不衡量类别可分性——")
print(" 本手册课题 9-2 就是一个反例:按方差降维反而让分类变差。")
print(" perplexity 小,t-SNE 只看极近邻,图会碎成许多小团;perplexity 大,全局结构更明显但细节糊掉。")
print(" 经验取值 5 到 50,且必须小于样本数。这里近邻保持率随 perplexity 变化不大,")
print(" 正说明它主要影响图的形状、而非保住了多少邻居,别把 t-SNE 图当聚类结果读。")
| 参数 | 含义 | 典型取值 | 说明 |
|---|---|---|---|
n_components |
保留主成分数 | 0 到 1 的浮点表示方差保留比,或整数 | 常用 0.95,即保留 95% 方差 |
whiten |
是否白化 | False | 设为 True 使各成分方差为 1,下游用 GMM 或 KNN 时可考虑 |
t-SNE
| 参数 | 含义 | 典型取值 | 说明 |
|---|---|---|---|
perplexity |
有效近邻数 | 5 到 50,小于样本数的 1/3 | 调大保留全局结构,调小突出局部团簇;这是最需要调且最易误解的参数 |
learning_rate |
学习率 | 10 到 1000(建议 200 起) | 过大导致点呈球状均匀分布 |
n_iter |
迭代数 | 1000 到 5000 | 不足则未收敛 |
init |
初始化 | pca |
优于随机初始化,结果更稳 |
metric |
距离 | euclidean、cosine |
— |
UMAP
| 参数 | 含义 | 典型取值 | 说明 |
|---|---|---|---|
n_neighbors |
局部邻域大小 | 5 到 50 | 调小保留局部细节,调大保留全局结构 |
min_dist |
嵌入空间最小距离 | 0.0 到 0.5 | 调小点更聚集,适合看簇;调大布局更舒展 |
n_components |
输出维度 | 2 或 3 | 可视化通常取 2 |
重要认知:t-SNE 与 UMAP 的坐标没有物理意义,簇间距离不可解释,簇大小也不代表真实比例。它们只用于可视化探索,不能作为特征喂给下游模型。
第五章 深度学习通用训练参数
深度学习的参数可以分成两层:结构参数决定模型的表达能力上限,训练参数决定模型能否真正走到那个上限。绝大多数训练失败都发生在第二层。
5.0 先看一遍完整的训练代码
在逐条讲参数之前,先看一遍完整的训练骨架。原因很实际:第五章后面的几十个参数,全部挂在这五段代码的某一行上;脱离代码去背参数表,记住的只是名字,不是位置。
骨架按「数据 → 结构 → 前向 → 反向 → 更新」五段组织,注释里标了每个参数对应哪一节。这段代码本身可直接运行(需 torch),用的是随机生成的十类数据,只为验证骨架跑得通。
训练骨架(五段式):
"""5.0 深度学习训练的完整骨架:五段式。
任何一个深度学习训练脚本,无论多复杂,都能拆成这五段:
① 数据 -> Dataset / DataLoader(决定 batch_size、num_workers、是否打乱)
② 结构 -> nn.Module(决定层数、隐藏维度、激活函数)
③ 前向 -> forward + loss(决定用什么损失、是否 label smoothing)
④ 反向 -> loss.backward()(决定梯度裁剪、混合精度)
⑤ 更新 -> optimizer.step() + scheduler.step()(决定 lr、weight_decay、调度策略)
代码刻意写成"每一行都能对应到后面某个参数"的形式,注释里标了对应节号。
运行需要 torch(pip install torch)。这份文件本身可直接 python 运行,验证骨架无语法与形状错误。
"""
import numpy as np
import torch
import torch.nn as nn
from torch.utils.data import DataLoader, TensorDataset
DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
USE_AMP = DEVICE == "cuda" # CPU 上不做混合精度,否则报错
BATCH_SIZE = 64 # -> 5.5 batch_size
EPOCHS = 5
def get_data(n=3000, dim=784, n_class=10, seed=0):
"""用随机数据代替真实数据,只为验证骨架能跑通。真实任务换成自己的 Dataset 即可。"""
rng = np.random.default_rng(seed)
centers = rng.normal(0, 1, (n_class, dim))
y = rng.integers(0, n_class, n)
X = centers[y] + rng.normal(0, 3.0, (n, dim)) # 类中心 + 噪声,保证任务可学
cut = int(n * 0.8)
return (X[:cut], y[:cut]), (X[cut:], y[cut:])
(X_train, y_train), (X_val, y_val) = get_data()
# ---------- ① 数据 ----------
def make_loader(X, y, train=True):
ds = TensorDataset(torch.as_tensor(X, dtype=torch.float32),
torch.as_tensor(y, dtype=torch.long))
return DataLoader(ds, batch_size=BATCH_SIZE,
shuffle=train, # 训练集必须打乱;验证集不要打乱,否则指标不可比
num_workers=0, # Windows 上先设 0,稳定后再加
pin_memory=(DEVICE == "cuda"))
# ---------- ② 结构 ----------
class MLP(nn.Module):
def __init__(self, in_dim, hidden=256, n_layers=3, n_class=10, dropout=0.3):
super().__init__() # -> 5.1 hidden_size / num_layers
layers, d = [], in_dim
for _ in range(n_layers):
layers += [nn.Linear(d, hidden),
nn.BatchNorm1d(hidden), # -> 5.4 momentum / eps
nn.ReLU(inplace=True), # -> 5.1 激活函数
nn.Dropout(dropout)] # -> 5.4 dropout 的 p
d = hidden
layers += [nn.Linear(d, n_class)]
self.net = nn.Sequential(*layers)
def forward(self, x): # ---------- ③ 前向 ----------
return self.net(x)
model = MLP(in_dim=784).to(DEVICE)
criterion = nn.CrossEntropyLoss(label_smoothing=0.05) # -> 5.4 label smoothing
optimizer = torch.optim.AdamW(model.parameters(), lr=3e-4, betas=(0.9, 0.999),
weight_decay=0.01, eps=1e-8) # -> 5.2 优化器参数
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=EPOCHS) # -> 5.3
# torch 2.x 写法;torch 1.x 请换成 torch.cuda.amp.GradScaler / autocast
scaler = torch.amp.GradScaler("cuda", enabled=USE_AMP)
def evaluate(model, loader):
model.eval() # 切评估模式:关 dropout、固定 BN 统计量
total, correct = 0, 0
with torch.no_grad():
for xb, yb in loader:
pred = model(xb.to(DEVICE)).argmax(1).cpu()
correct += (pred == yb).sum().item()
total += len(yb)
return correct / total
for epoch in range(EPOCHS):
model.train()
for xb, yb in make_loader(X_train, y_train):
xb, yb = xb.to(DEVICE), yb.to(DEVICE)
optimizer.zero_grad(set_to_none=True) # 清梯度,比 zero_grad() 省一点显存
with torch.amp.autocast("cuda", enabled=USE_AMP):
loss = criterion(model(xb), yb) # ---------- ③ 前向 + 损失
scaler.scale(loss).backward() # ---------- ④ 反向(自动混合精度放大梯度)
scaler.unscale_(optimizer) # 裁剪前必须先反缩放,否则阈值失去意义
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0) # -> 5.4 梯度裁剪
scaler.step(optimizer) # ---------- ⑤ 更新
scaler.update()
scheduler.step() # 每个 epoch 调一次,不是每个 batch
print(f"epoch {epoch} train_loss={loss.item():.4f} "
f"val_acc={evaluate(model, make_loader(X_val, y_val, train=False)):.4f} "
f"lr={optimizer.param_groups[0]['lr']:.2e}")
# 三处最常见的错误,都能在上面的骨架里找到位置:
# 1) 忘了 model.train() / model.eval() 切换 -> dropout 在推理时仍然生效,同一输入两次结果不同
# 2) 在 unscale_ 之前裁剪梯度 -> 阈值实际被放大了 65536 倍,等于没裁
# 3) scheduler.step() 写在 batch 循环里 -> 学习率衰减快了 batch 数那么多倍
这五段里只有第二段属于 5.1 的讨论范围,其余四段分别对应 5.2 到 5.5。所以下一节从结构开始,然后按训练时真正执行的顺序往下走。
5.1 结构层参数
结构参数决定“模型能表达多复杂的函数”,它不参与训练,但一旦定错,后面所有训练参数都补不回来——学习率调得再好,也救不了一个容量不足的网络。看起来参数很多,其实只有三个自由变量:
| 变量 | 典型名称 | 决定什么 | 与其他两个的关系 |
|---|---|---|---|
| 深度 | num_layers、n_layers |
抽象层级的数量 | 加深可补偿宽度不足,但必须有残差与归一化才训得动 |
| 宽度 | hidden_size、d_model、channels |
每层特征的维数 | 加宽的参数代价是平方级,加深是线性级,这是两者取舍的关键 |
| 连接方式 | 全连接、卷积、循环、注意力 | 参数是否共享、信息能流多远 | 它决定参数量的量级,影响比前两个更大 |
三者共同决定一个可以在训练前就算出来的量:参数量。这是唯一能在跑之前就检验结构是否合理的指标。经验门槛是"参数量不超过样本量的十分之一";超过就得靠强正则、数据增强或换小模型。下面先把常用层的参数量公式跑一遍,再回到具体参数的取值。
参数量核算(结构设计的第一个硬约束):
"""5.1 结构层参数的换算:参数量到底怎么算出来的。
结构参数只有三个自由变量:层数、每层的维度、层与层怎么连。
但"参数量"不是凭感觉估的,它由每个层的公式决定。下面把常用层的公式直接算一遍,
你会看到一个反直觉的结论:CNN 的参数量由卷积核尺寸与通道数决定,与图片大小无关;
而全连接层与序列长度无关、却与特征维度平方相关——这就是为什么大模型必须用注意力而不是 MLP。
"""
import numpy as np
def linear(in_dim, out_dim):
"""全连接层:权重 in*out,偏置 out。"""
return in_dim * out_dim + out_dim
def conv2d(k, cin, cout):
"""卷积层:k*k*cin*cout + cout。注意输入分辨率 h、w 不出现——这是卷积的权重共享。"""
return k * k * cin * cout + cout
def batchnorm(c):
"""归一化层:每个通道 2 个参数(gamma、beta),外加 2 个不参与训练的统计量缓冲区。"""
return 2 * c, 2 * c
def lstm(in_dim, hidden, layers=1, bidirectional=False):
"""LSTM:每个门都是一次 hidden*(input+hidden)+hidden 的仿射;共 4 个门。"""
dirs = 2 if bidirectional else 1
total = 0
for l in range(layers):
i = in_dim if l == 0 else hidden * dirs
total += 4 * (hidden * (i + hidden) + hidden) * dirs
return total
def attention(d_model, n_heads=None):
"""多头注意力:Q、K、V、O 四个 d_model*d_model 投影。头数不改变参数量,只改变形状。"""
return 4 * d_model * d_model + 4 * d_model
def transformer_block(d_model, d_ff):
"""一个 Transformer 块 = 注意力 + 两层前馈 + 两处 LayerNorm。"""
ln = 2 * 2 * d_model
ffn = d_model * d_ff + d_ff + d_ff * d_model + d_model
return attention(d_model) + ln + ffn
print("--- 全连接层:维度按平方增长 ---")
for d in (128, 512, 1024, 4096):
print(f"Linear({d} -> {d}):{linear(d, d):>12,} 参数")
print("\n--- 卷积层:与输入分辨率无关 ---")
for size in (64, 224, 1024):
print(f"输入 {size}x{size},Conv 3x3 c64->c128:{conv2d(3, 64, 128):>10,} 参数"
f"(输入变大,参数量不变)")
print("\n--- 同样的特征维度,卷积 vs 全连接 ---")
h = w = 56
print(f"把 64x{h}x{w} 接全连接到 1024 维:{linear(64 * h * w, 1024):>12,} 参数")
print(f"用 3x3 卷积 64->128 再全局池化: {conv2d(3, 64, 128) + linear(128, 1024):>12,} 参数")
print("\n--- LSTM 与注意力的对照(d_model=512,d_ff=2048)---")
print(f"LSTM(hidden=512, 1 层): {lstm(512, 512):>12,}")
print(f"LSTM(hidden=512, 3 层, 双向): {lstm(512, 512, 3, True):>12,}")
print(f"单个 Transformer 块: {transformer_block(512, 2048):>12,}")
print(f"12 个 Transformer 块(约 56M): {transformer_block(512, 2048) * 12:>12,}")
print("\n--- 参数量与样本量的经验法则 ---")
for param in (1e5, 1e6, 1e7):
print(f"参数量 {param:>10,.0f}:建议至少 {param / 10:>12,.0f} 个训练样本"
f"(按 10 倍反推),少于 {param / 100:>12,.0f} 就必须强正则或换小模型")
print("\n读法:三条结论,都比“越大越好”有用——")
print(" 1) 卷积的参数量与输入分辨率无关,所以同一个 CNN 可以直接吃 224 或 512 的图;")
print(" 2) 全连接的参数量与输入维度平方相关:64x56x56 接全连接要 2.06 亿参数,")
print(" 换成卷积 + 全局池化只要 20.6 万,差 1000 倍——这是 CNN 取代全连接的根本原因;")
print(" 3) 一个 Transformer 块 3.15M 参数里,FFN 占 2.10M(三分之二)、注意力占 1.05M。")
print(" 所以调 d_ff 比调 n_heads 对容量的影响大得多:n_heads 只改变形状,不改变参数量。")
落到具体参数上,需要调的就是下面这四行:
| 参数 | 含义 | 典型取值 | 调大与调小的影响 |
|---|---|---|---|
层数 num_layers |
网络的深度 | MLP 2 到 5,CNN 18 到 152,Transformer 6 到 96 | 调大:表达能力提升,但需配套残差连接与归一化,否则难训;调小:易欠拟合 |
隐藏维度 hidden_size |
每层神经元数或特征维 | 64 到 1024 | 调大:容量提升,参数与显存按平方增长;调小:需靠加深补偿 |
| 参数量 | 由上述两者与连接方式决定 | — | 经验法则:参数量不超过样本量的 10 倍,超过则必须强正则或换小模型 |
| 激活函数 | 非线性变换 | ReLU、GELU、SiLU、LeakyReLU | ReLU 快但有死亡风险;GELU 平滑,是 Transformer 标配;SiLU 在深网络中表现更稳 |
5.2 优化器参数
下面这四节的参数(优化器、调度、正则、批大小),在 5.0 的训练骨架里都标了具体位置。遇到不熟悉的名字,先回去看那一行代码,比在表里找解释快得多。
随机梯度下降(SGD)
| 参数 | 含义 | 典型取值 | 影响 |
|---|---|---|---|
lr |
学习率 | 0.01 到 0.1(配合调度器) | SGD 对学习率极敏感,通常需要 warmup 与衰减 |
momentum |
动量系数 | 0.9(常用)、0.99 | 调大加速收敛、抑制震荡,过大易冲过最优点 |
weight_decay |
权重衰减(L2) | 1e-4 到 1e-2 | 抑制过拟合 |
nesterov |
Nesterov 动量 | True | 通常优于普通动量,无额外代价 |
dampening |
动量阻尼 | 0 | 很少需要改 |
Adam 与 AdamW
| 参数 | 含义 | 典型取值 | 影响 |
|---|---|---|---|
lr |
学习率 | 1e-4 到 3e-3(预训练),1e-5 到 5e-4(微调) | Adam 比 SGD 宽容,但仍是最关键参数 |
betas |
一阶与二阶矩估计的指数衰减率 | (0.9, 0.999),大模型常用 (0.9, 0.95) | 第二个值调小(如 0.95)能加快对梯度尺度变化的响应,长序列训练更稳 |
eps |
数值稳定项 | 1e-8,混合精度下用 1e-6 到 1e-5 | 过小在 fp16 下易除零产生 NaN |
weight_decay |
权重衰减 | 0.01(AdamW 常用),1e-4 到 0.1 | AdamW 中权重衰减与梯度解耦,是相比 Adam 的主要改进;L2 正则在 Adam 中会被自适应学习率缩放,效果不如预期 |
amsgrad |
是否用梯度平方的极大值 | False | 理论更优,实践中收益不稳定 |
常见错误:用
Adam而不是AdamW,却发现正则几乎不起作用。原因是 Adam 把 L2 惩罚混入梯度,被二阶矩估计归一化,等效正则强度随参数尺度变化,不可控。这是面试高频考点。
5.3 学习率调度
| 调度器 | 关键参数 | 曲线形态 | 适用场景 |
|---|---|---|---|
| StepLR | step_size、gamma |
阶梯下降 | 传统 CNN 训练 |
| MultiStepLR | milestones、gamma |
多阶梯 | 需在特定轮次突降,如 60%、80% 处 |
| CosineAnnealingLR | T_max、eta_min |
余弦下降到下限 | 现代主流,平滑无突变 |
| CosineAnnealingWarmRestarts | T_0、T_mult |
余弦 + 周期性重启 | 帮助跳出局部最优 |
| OneCycleLR | max_lr、pct_start、total_steps |
先升后降的单周期 | 训练轮数确定时收敛最快,常配 super-convergence |
| ReduceLROnPlateau | factor、patience、threshold |
指标停滞时下降 | 无法预知总轮数时最实用 |
| Warmup + Linear Decay | warmup_steps、warmup_ratio |
线性升温后线性或余弦下降 | Transformer 与所有大模型的标准配置 |
warmup 的必要性:训练初期参数随机、梯度方向混乱,若直接使用大学习率,会破坏预训练权重或让模型陷入坏区域。warmup 用几百到几千步把学习率从接近 0 线性升到目标值,是 Transformer 类模型能否收敛的前提。经验值:warmup_ratio 取总步数的 1% 到 5%,小数据集取上限。
5.4 正则化参数
| 手段 | 关键参数 | 典型取值 | 作用机理与注意事项 |
|---|---|---|---|
| Dropout | p |
0.1 到 0.5(全连接),0.1 到 0.3(Transformer) | 随机置零神经元,等价于集成大量子网络。调大正则更强;推理时必须关闭,否则结果错误 |
| Weight Decay | weight_decay |
1e-4 到 0.1 | 参数向 0 收缩。不应施加于偏置与归一化层参数,这是提高精度的细节技巧 |
| BatchNorm | momentum、eps |
0.1、1e-5 | 按 batch 统计量归一化,加速收敛、允许更大学习率。batch 很小时统计量不稳,改用 GroupNorm 或 LayerNorm |
| LayerNorm | eps |
1e-5 到 1e-6 | 按单样本特征归一化,与 batch 大小无关,是 Transformer 标配 |
| Label Smoothing | smoothing |
0.05 到 0.1 | 把硬标签软化为 0.9 与 0.1 除以类别数,抑制过度自信,提升校准度与泛化 |
| 早停 | patience、min_delta、mode |
5 到 20 轮 | 验证指标不再提升即停止,是最廉价有效的正则。min_delta 防止把噪声当提升 |
| 数据增强 | 各任务专用 | — | 图像翻转裁剪、文本回译替换、时序加噪抖动,等效于扩充数据 |
| 梯度裁剪 | max_norm |
0.5 到 1.0(RNN 常 1.0) | 防止梯度爆炸。按范数裁剪优于按值裁剪,因为它保持梯度方向不变 |
5.5 批大小与相关参数
| 参数 | 含义 | 典型取值 | 影响 |
|---|---|---|---|
batch_size |
单次迭代样本数 | 32 到 1024 | 调大:梯度估计更准、吞吐更高,但泛化可能变差、显存占用上升;调小:噪声大、正则效果强,但训练慢 |
gradient_accumulation_steps |
梯度累积步数 | 1 到 32 | 在显存受限时模拟大 batch,等效 batch = batch_size 乘累积步数 |
num_workers |
数据加载进程数 | 4 到 16(Windows 建议 0 到 4) | 过小会 GPU 空等,过大会争抢内存 |
pin_memory |
锁页内存 | True(有 GPU 时) | 加速 CPU 到 GPU 传输 |
批大小与学习率的联动规则:线性缩放法则认为 batch 增大 k 倍,学习率也应增大 k 倍;平方根缩放法则认为应增大 √k 倍。实践中大 batch 常配合 warmup 使用平方根缩放,否则初期易发散。
一个关键认知:batch size 过大导致的泛化损失(generalization gap)是真实存在的。在相同 epoch 数下,batch 从 32 增到 1024,测试精度常下降 1 到 2 个百分点。若必须用大 batch,应配合更高的学习率、更长的训练轮次或 LARS/LAMB 类分层自适应优化器。
第六章 典型网络结构的结构参数
6.1 卷积神经网络
结构实现:CNN 的结构参数全部服务于一个公式:输出边长 =(输入 + 2×padding − kernel)/ stride + 1。把公式写成代码逐层打印,就再也不会卡在形状不匹配上,顺带能看清参数集中在哪一层。
"""6.1 卷积神经网络:一次前向传播里每一层的形状怎么变。
CNN 的结构参数看着多,其实全部服务于一个公式:
输出边长 = (输入边长 + 2*padding - kernel_size) / stride + 1
把公式写成函数,逐层打印,你就再也不会在 "size mismatch" 上卡住。
同时算一遍参数量——卷积层的参数只有 k*k*Cin*Cout,与分辨率无关。
这份实现用 numpy,不需要 torch,跑完能直接对上 PyTorch 的 Conv2d 输出形状。
"""
import numpy as np
def conv_out(size, k, stride=1, padding=0, dilation=1):
"""卷积/池化的输出边长公式。dilation 把核等效放大成 k_eff = dilation*(k-1)+1。"""
k_eff = dilation * (k - 1) + 1
return (size + 2 * padding - k_eff) // stride + 1
def conv_params(k, cin, cout, bias=True):
return k * k * cin * cout + (cout if bias else 0)
def conv_forward(x, w, b, stride=1, padding=0):
"""真正的卷积:x 形状 (C,H,W),w 形状 (Cout,C,k,k)。只用两层循环,便于看清索引。"""
C, H, W = x.shape
Cout, _, k, _ = w.shape
xp = np.pad(x, ((0, 0), (padding, padding), (padding, padding)))
Ho = (H + 2 * padding - k) // stride + 1
Wo = (W + 2 * padding - k) // stride + 1
out = np.zeros((Cout, Ho, Wo))
for co in range(Cout):
for i in range(Ho):
for j in range(Wo):
patch = xp[:, i * stride:i * stride + k, j * stride:j * stride + k]
out[co, i, j] = np.sum(patch * w[co]) + b[co] # 逐通道乘加,再求和
return out
# ---------- 一个迷你 VGG 式的结构:每段"卷积两次 + 池化一次" ----------
print("--- 逐层形状与参数量(输入 1x32x32,10 类)---")
shape = (1, 32, 32)
stages = [(32, 3, 1, 1), (64, 3, 1, 1), (128, 3, 1, 1)] # (输出通道, k, stride, padding)
total = 0
for idx, (cout, k, s, p) in enumerate(stages, 1):
cin, H, W = shape
params = conv_params(k, cin, cout)
total += params
Ho, Wo = conv_out(H, k, s, p), conv_out(W, k, s, p)
print(f"stage{idx} Conv{k}x{k} {cin}->{cout}: {cin}x{H}x{W} -> {cout}x{Ho}x{Wo} "
f"参数 {params:>10,}")
H, W = Ho, Wo
Ho, Wo = conv_out(H, 2, 2), conv_out(W, 2, 2) # 2x2 最大池化,步长 2
print(f" MaxPool2x2: {cout}x{H}x{W} -> {cout}x{Ho}x{Wo} 参数 0")
shape = (cout, Ho, Wo)
cin = cout
final_dim = shape[0] * shape[1] * shape[2]
print(f"\n全局池化后接 Linear({shape[0]} -> 10):参数 {shape[0] * 10 + 10:,}")
print(f"若改用 Flatten + Linear({final_dim} -> 10):参数 {final_dim * 10 + 10:,}"
f"——多 {final_dim * 10 // (shape[0] * 10)} 倍")
print(f"卷积部分总参数:{total:,}")
# ---------- 验证:手写卷积与公式是否一致 ----------
rng = np.random.default_rng(0)
x = rng.normal(size=(3, 8, 8))
w = rng.normal(size=(4, 3, 3, 3))
b = rng.normal(size=4)
y = conv_forward(x, w, b, stride=2, padding=1)
print(f"\n手写卷积:输入 3x8x8,k=3 s=2 p=1 -> 输出 {y.shape}"
f"(公式给出 {conv_out(8, 3, 2, 1)})")
print("\n读法:三个 stage 的参数量是 320、18,496、73,856,逐段放大 58 倍和 4 倍——")
print(" 通道数翻倍时参数量按 cin*cout 增长(约 4 倍),而分辨率下降让计算量反而减少。")
print(" 这就是 CNN 设计的基本节奏:空间上越来越小,通道上越来越多,参数集中在深层。")
print(" padding 的作用只有保持尺寸:p=(k-1)/2 时 3x3 核不改变分辨率,")
print(" stride=2 才是真正的降采样手段,它让输出边长减半。")
| 参数 | 含义 | 典型取值 | 调大与调小的影响 |
|---|---|---|---|
kernel_size |
卷积核尺寸 | 3x3(主流)、5x5、7x7(首层) | 大核感受野大但参数多;两个 3x3 堆叠等效 5x5 感受野且参数更少、非线性更多,这是 VGG 的核心洞察 |
stride |
步长 | 1(特征提取)、2(下采样) | 步长 2 降分辨率,参数与计算量下降 |
padding |
边界填充 | 1(3x3 核保持尺寸)、same |
无填充则每层尺寸收缩,深网络会迅速耗尽空间维度 |
channels(out_channels) |
输出通道数 | 32 到 512,逐层翻倍 | 通道数决定特征多样性,通常每下采样一次翻倍以保持信息容量 |
dilation |
空洞率 | 1(普通)、2 到 4 | 调大扩大感受野而不增加参数,用于语义分割、波形建模 |
groups |
分组卷积组数 | 1(普通)、等于通道数(深度可分离) | 分组降低计算量,是 MobileNet 系列的基础 |
pool_size |
池化窗口 | 2x2 | 降维,提供一定平移不变性 |
pool_type |
池化类型 | max、avg |
max 保留显著特征,avg 保留整体强度;现代网络后期多用 avg 或全局平均池化替代全连接 |
尺寸计算:输出边长 = (输入边长 + 2 乘 padding 减 kernel_size) / stride + 1。这个公式是排查维度不匹配问题的第一工具。
CNN 成功标志:首层卷积核可视化呈现边缘、颜色斑块等可辨认模式(若呈噪声状,说明学习率过大或数据未归一化);特征图不出现大面积为 0 的死通道;训练与验证精度差距在数据增强开启后小于 5 个百分点。
6.2 循环神经网络
结构实现:LSTM 的四个门、hidden_size 的含义、参数量为什么是平方级——手写一个单元就全清楚了。这段代码把每步的形状与数值范围都打出来,包括 h 被 tanh 压住而 c 没有的原因。
"""6.2 循环神经网络:手写一个 LSTM 单元,看清 hidden_size 到底控制了什么。
nn.LSTM 的参数量、输出形状、门控计算全部来自下面这四行公式(LSTM 的经典定义):
i = sigmoid(W_ii x + b_ii + W_hi h + b_hi) 输入门
f = sigmoid(W_if x + b_if + W_hf h + b_hf) 遗忘门
g = tanh (W_ig x + b_ig + W_hg h + b_hg) 候选记忆
o = sigmoid(W_io x + b_io + W_ho h + b_ho) 输出门
c' = f * c + i * g 记忆更新
h' = o * tanh(c') 输出
关键认知:hidden_size 同时决定 h 与 c 的宽度,并且 4 个门各自有一份 (hidden x input) 与 (hidden x hidden) 权重,
所以参数量是 4*(hidden*(input+hidden)+hidden)——它是 hidden 的平方级参数。
"""
import numpy as np
def sigmoid(z):
return 1 / (1 + np.exp(-np.clip(z, -30, 30)))
class LSTMCell:
"""最小 LSTM 单元:只实现单步前向,足以看清形状与参数量。"""
def __init__(self, in_dim, hidden, seed=0):
rng = np.random.default_rng(seed)
self.hidden = hidden
# 4 个门 = i, f, g, o,每门两份权重:输入侧 W_x 与隐藏侧 W_h
scale = 1 / np.sqrt(hidden)
self.W_x = rng.normal(0, scale, (4 * hidden, in_dim))
self.W_h = rng.normal(0, scale, (4 * hidden, hidden))
self.b = np.zeros(4 * hidden)
def forward(self, x, state=None):
"""x: (input_dim,),返回 (h, c)。state 为 None 时从全零开始。"""
h, c = (np.zeros(self.hidden), np.zeros(self.hidden)) if state is None else state
gates = self.W_x @ x + self.W_h @ h + self.b # (4*hidden,)
i, f, g, o = np.split(gates, 4) # 按顺序切成四段
i, f, o = sigmoid(i), sigmoid(f), sigmoid(o)
g = np.tanh(g)
c = f * c + i * g # 记忆:选择性遗忘 + 选择性写入
h = o * np.tanh(c) # 输出:把记忆压到 -1 到 1
return h, c
def n_params(self, in_dim):
return self.W_x.size + self.W_h.size + self.b.size
print("--- hidden_size 对参数量的影响(输入 128 维)---")
for hidden in (64, 128, 256, 512):
cell = LSTMCell(128, hidden)
print(f"hidden_size={hidden:<4} 参数量={cell.n_params(128):>9,} "
f"(4*(hidden*(128+hidden)+hidden) = {4 * (hidden * (128 + hidden) + hidden):,})")
# ---------- 前向一步:形状与数值范围 ----------
cell = LSTMCell(in_dim=128, hidden=64, seed=0)
x = np.random.default_rng(1).normal(size=128)
h, c = cell.forward(x)
print(f"\n单步前向:输入 {x.shape} -> h {h.shape}(范围 {h.min():.2f} 到 {h.max():.2f})"
f",c {c.shape}(范围 {c.min():.2f} 到 {c.max():.2f})")
print("h 被 tanh 压住,所以恒在 -1 到 1;c 没有压缩,可以累加长程信息——这是 LSTM 记住长期依赖的机制。")
# ---------- 序列:时间步之间只传递 h 与 c ----------
seq = np.random.default_rng(2).normal(size=(30, 128)) # 30 个时间步
state = None
norms = []
for t in range(seq.shape[0]):
h, c = cell.forward(seq[t], state)
state = (h, c)
norms.append(np.linalg.norm(h))
print(f"\n30 步后 ||h|| = {norms[-1]:.3f},前 5 步 ||h|| = {np.round(norms[:5], 3)}")
print("若把 sigmoid 换成线性激活,||h|| 会随步数指数增长或衰减——这就是梯度爆炸与消失的来源,")
print("所以 6.2 表里的梯度裁剪 max_norm 对 RNN 尤其重要,不能省。")
print("\n--- 层数与双向的代价(输入 128,hidden 256)---")
for layers in (1, 2, 3):
for bi in (False, True):
dirs = 2 if bi else 1
total = 0
for l in range(layers):
i = 128 if l == 0 else 256 * dirs
total += 4 * (256 * (i + 256) + 256) * dirs
print(f"num_layers={layers} bidirectional={str(bi):<5} 参数量={total:>10,}")
print("\n读法:hidden 从 64 到 512,参数量从 5 万涨到 131 万,是按 hidden 平方增长的——")
print(" 所以 RNN 加宽很快就不划算,这是它被 Transformer 取代的原因之一。")
print(" 双向的代价正好是 2 倍参数,且它要求“看完整句”,所以生成任务不能用。")
print(" batch_first 只影响维度排列(是 (seq, batch, feat) 还是 (batch, seq, feat)),不影响任何结果。")
| 参数 | 含义 | 典型取值 | 影响 |
|---|---|---|---|
hidden_size |
隐藏状态维度 | 64 到 512 | 容量核心参数 |
num_layers |
堆叠层数 | 1 到 3 | 超过 3 层收益递减且难训,需配残差 |
dropout |
层间 dropout | 0 到 0.5 | 只在多层之间生效,单层 RNN 上设了也没用 |
bidirectional |
是否双向 | 文本理解任务 True,生成任务 False | 双向能看到未来信息,生成任务中会造成泄漏 |
batch_first |
输入维度顺序 | True | 仅影响维度排列,不影响结果 |
seq_len |
序列长度 | 按任务 | 过长导致梯度消失,需截断或换注意力机制 |
teacher_forcing_ratio |
训练时用真实上一 token 的概率 | 0.5 到 1.0 递减 | 过高则推理时暴露偏差(exposure bias),可做计划采样逐步降低 |
LSTM 与 GRU 的取舍:GRU 参数少约 25%、训练更快,在多数中小任务上与 LSTM 效果相当;LSTM 在长序列与需要精细门控的任务上略优。若两者差距明显,通常说明数据或序列建模方式有问题,而非门控结构本身。
6.3 Transformer
结构实现:自注意力的五步计算里藏着 d_model、n_heads、head_dim 三者的关系。跑一遍会看到一个反直觉的结论:改 n_heads 时参数量一个字都不变,变的只是形状。
"""6.3 Transformer:手写一遍缩放点积注意力,看清 d_model 与 n_heads 的关系。
注意力的全部计算只有五步:
1) Q = X W_q, K = X W_k, V = X W_v 三个线性投影,把 d_model 拆成 n_heads 份
2) S = Q K^T / sqrt(head_dim) 每个位置对其他位置打分
3) S = S + mask 因果掩码把"未来"的位置打成 -inf
4) A = softmax(S) 归一化成权重
5) O = A V 加权求和,再拼回 d_model 维
最关键的一条:n_heads 不改变参数量,只改变形状。
d_model=512、n_heads=8 时每头 64 维,8 个头拼回来还是 512 维——参数与单头一样多。
这就是"多头"能用几乎零成本换到更多表达子空间的原因。
"""
import numpy as np
def softmax(x, axis=-1):
x = x - x.max(axis=axis, keepdims=True) # 减最大值防止 exp 溢出,结果不变
e = np.exp(x)
return e / e.sum(axis=axis, keepdims=True)
def scaled_dot_product_attention(Q, K, V, mask=None):
"""Q/K/V 形状 (batch, n_heads, seq, head_dim)。"""
d_k = Q.shape[-1]
scores = Q @ K.transpose(0, 1, 3, 2) / np.sqrt(d_k) # 步骤 2:为什么除以 sqrt(d_k)
if mask is not None:
scores = scores + mask # 步骤 3:-inf 经 softmax 后变 0
A = softmax(scores) # 步骤 4
return A @ V, A # 步骤 5
class MultiHeadAttention:
"""最小多头注意力。融合矩阵 W_o 把各头拼回 d_model,这一步常被忽略但必须有。"""
def __init__(self, d_model, n_heads, seed=0):
assert d_model % n_heads == 0, "d_model 必须能被 n_heads 整除"
rng = np.random.default_rng(seed)
self.d_model, self.n_heads = d_model, n_heads
self.head_dim = d_model // n_heads # 每头维度 = d_model / n_heads
scale = 1 / np.sqrt(d_model)
self.Wq = rng.normal(0, scale, (d_model, d_model)) # 实际实现常用一个融合矩阵切三份
self.Wk = rng.normal(0, scale, (d_model, d_model))
self.Wv = rng.normal(0, scale, (d_model, d_model))
self.Wo = rng.normal(0, scale, (d_model, d_model))
def n_params(self):
return 4 * self.d_model ** 2 + 4 * self.d_model # 四个矩阵 + 四个偏置
def split_heads(self, x):
"""(batch, seq, d_model) -> (batch, n_heads, seq, head_dim)"""
b, s, _ = x.shape
return x.reshape(b, s, self.n_heads, self.head_dim).transpose(0, 2, 1, 3)
def forward(self, x, causal=True):
b, s, _ = x.shape
Q = self.split_heads(x @ self.Wq)
K = self.split_heads(x @ self.Wk)
V = self.split_heads(x @ self.Wv)
mask = None
if causal: # 因果掩码:位置 i 只能看 0 到 i
mask = np.triu(np.full((s, s), -1e9), k=1)
out, A = scaled_dot_product_attention(Q, K, V, mask)
out = out.transpose(0, 2, 1, 3).reshape(b, s, self.d_model) # 各头拼回 d_model
return out @ self.Wo, A
rng = np.random.default_rng(42)
seq_len, d_model = 6, 64
x = rng.normal(size=(1, seq_len, d_model))
print("--- n_heads 只改形状,不改参数量 ---")
for n_heads in (1, 2, 4, 8):
mha = MultiHeadAttention(d_model, n_heads)
out, A = mha.forward(x)
print(f"n_heads={n_heads:<2} head_dim={mha.head_dim:<3} 输出形状={out.shape} "
f"参数量={mha.n_params():,} "
f"注意力矩阵形状={A.shape}")
print("\n--- 序列翻倍,注意力分数矩阵变成 4 倍 ---")
for s in (6, 128, 1024):
print(f"seq_len={s:<5} 注意力矩阵元素数={s * s:>9,} "
f"(batch 32、8 头时约 {32 * 8 * s * s / 1e6:.0f}M 个数)")
# ---------- 因果掩码到底做了什么 ----------
mha = MultiHeadAttention(d_model, n_heads=4, seed=0)
_, A_causal = mha.forward(x, causal=True)
_, A_full = mha.forward(x, causal=False)
print(f"\n因果掩码下第 0 个位置对第 5 个位置的注意力 = {A_causal[0, 0, 0, 5]:.1e}")
print(f"不加掩码时为 {A_full[0, 0, 0, 5]:.4f}")
print("掩码把上三角压成 -1e9,softmax 之后精确为 0,不是近似为 0。")
print("\n--- Transformer 块的参数分布(d_model=512, d_ff=2048)---")
d_ff = 2048
para_attn = 4 * 512 ** 2 + 4 * 512
para_ffn = 512 * d_ff + d_ff + d_ff * 512 + 512
para_ln = 2 * 2 * 512
print(f"注意力 4*d^2:{para_attn:>10,} ({para_attn / (para_attn + para_ffn + para_ln):.1%})")
print(f"前馈 2*d*d_ff:{para_ffn:>9,} ({para_ffn / (para_attn + para_ffn + para_ln):.1%})")
print(f"两处 LayerNorm:{para_ln:>8,} ({para_ln / (para_attn + para_ffn + para_ln):.1%})")
print("\n读法:n_heads 从 1 到 8,参数量一个字没变(都是 16,640),变的只是切分方式——")
print(" 所以多头不是更多参数,而是同一批参数在更多子空间里各算各的。")
print(" 但头数不能无限加:head_dim = d_model / n_heads 小于 32 时,每个头的表达力太弱,")
print(" 实证上 d_model/n_heads 落在 64 附近最好,这也是 5.1 表里那条经验的来源。")
print(" 第二组数据解释了 flash attention:seq 从 128 到 1024,分数矩阵涨 64 倍,")
print(" 显存瓶颈从来不在权重上,而在那个 seq x seq 的中间矩阵。")
| 参数 | 含义 | 典型取值 | 调大与调小的影响 |
|---|---|---|---|
d_model |
模型隐藏维度 | 256 到 4096 | 容量核心。必须能被 n_heads 整除 |
n_heads |
注意力头数 | 8 到 32 | 多头捕获不同子空间的关系。头数过多则每头维度太小(低于 32)表达力下降;经验上 d_model / n_heads 取 64 附近 |
d_ff |
前馈层中间维度 | 4 乘 d_model,LLaMA 用约 2.7 倍并配门控 |
决定前馈层容量,占总参数约三分之二 |
n_layers |
层数 | 6 到 96 | 深度决定抽象的层次性,需配 pre-LN 与残差才能训深 |
max_position_embeddings |
最大位置长度 | 512 到 32768 | 超过则无法处理,需外推方案(RoPE 缩放、NTK 插值) |
dropout / attention_dropout |
注意力与残差的 dropout | 0 到 0.1(预训练常用 0.1) | 大模型预训练常设 0,因为数据量本身提供了强正则 |
attention_mask |
注意力掩码 | 因果掩码或填充掩码 | 生成任务必须用因果掩码,否则信息泄漏 |
norm_type / norm_placement |
归一化类型与位置 | LayerNorm 或 RMSNorm;Pre-LN 或 Post-LN | Pre-LN 训练更稳定、可用更大学习率,是现代默认;Post-LN 表达力略强但需 warmup |
activation |
前馈激活 | GELU、SwiGLU | SwiGLU 在同等参数量下效果更优,被 LLaMA 系列采用 |
use_flash_attention |
是否用 FlashAttention | True | 显著降低显存与提升速度,不改变数学结果(除数值精度) |
Transformer 的复杂度:自注意力计算量与显存随序列长度平方增长。序列翻倍,显存约翻四倍。这是长文本任务必须用 FlashAttention、稀疏注意力或分块处理的原因。
6.4 视觉 Transformer 与混合结构
结构实现:ViT 的新东西只有开头一步:切 patch。之后就是标准 Transformer,所以它的结构参数只有 patch_size 与 image_size 两个,代价全部体现在序列长度上。
"""6.4 视觉 Transformer:patch 切分与序列长度是怎么算出来的。
ViT 的全部"新东西"只有开头一步:把一张图切成不重叠的小块,每块拉平后当做一个 token。
之后它就是标准的 Transformer,一个 token 都不差。所以结构参数只有三个:
num_patches = (image_size / patch_size)^2 序列长度,再加 1 个 class token
token_dim = patch_size^2 * in_channels 每块的原始维度,需要线性投影到 d_model
参数量 主要由投影层与后续 Transformer 块决定,与 image_size 无关(除了位置编码)
下面把这个切分过程真正做一遍,并对比三种 patch_size 的代价。
"""
import numpy as np
def patchify(img, patch_size):
"""img 形状 (C,H,W)。返回 (num_patches, patch_size^2*C) 的 token 序列。"""
C, H, W = img.shape
assert H % patch_size == 0 and W % patch_size == 0, "图像尺寸必须能被 patch 整除"
n_h, n_w = H // patch_size, W // patch_size
# 先 reshape 成网格,再交换轴,让每个 patch 的像素连续排列
patches = img.reshape(C, n_h, patch_size, n_w, patch_size)
patches = patches.transpose(1, 3, 0, 2, 4) # (n_h, n_w, C, p, p)
return patches.reshape(n_h * n_w, C * patch_size * patch_size)
def vit_param_count(image_size, patch_size, d_model, n_layers, n_heads=8, d_ff=None, n_class=1000):
"""只算主干:patch 投影 + 位置编码 + n_layers 个块 + 分类头。"""
d_ff = d_ff or 4 * d_model
n_patches = (image_size // patch_size) ** 2
proj = 3 * patch_size * patch_size * d_model + d_model # 3 通道输入
pos = (n_patches + 1) * d_model # 位置编码,与序列长度成正比
block = (4 * d_model * d_model + 4 * d_model) + (2 * d_model * d_ff + d_ff + d_model) + 2 * 2 * d_model
head = d_model * n_class + n_class
return n_patches, proj + pos + block * n_layers + head, pos
print("--- 一张 3x224x224 的图,切不同的 patch ---")
img = np.random.default_rng(0).normal(size=(3, 224, 224))
for p in (32, 16, 8):
tokens = patchify(img, p)
print(f"patch_size={p:<3} token 数={tokens.shape[0]:<5} 每 token 维度={tokens.shape[1]:<5} "
f"(含 class token 后序列长 {tokens.shape[0] + 1})")
print("\n--- 参数量(d_model=768, 12 层,ViT-Base 的配置)---")
for p in (32, 16, 8):
n_patch, total, pos = vit_param_count(224, p, 768, 12)
print(f"patch_size={p:<3} num_patches={n_patch:<4} 总参数={total / 1e6:.2f}M "
f"(其中位置编码 {pos / 1e3:.1f}K)")
print("\n--- 分辨率变化时,什么会变 ---")
for size in (224, 384, 512):
n_patch, total, pos = vit_param_count(size, 16, 768, 12)
print(f"image_size={size:<4} num_patches={n_patch:<5} 总参数={total / 1e6:.2f}M "
f"注意力矩阵={n_patch ** 2 / 1e3:.1f}K 元素/头")
print("\n--- 真正的取舍在这里:注意力算力随 token 数平方增长 ---")
for p in (32, 16, 8):
n = (224 // p) ** 2 + 1
print(f"patch_size={p:<3} 序列长={n:<5} 注意力分数矩阵={n * n:>8,} 个数 "
f"(相对 p=16 是 {(n / 197) ** 2:.2f} 倍)")
print("\n读法:patch_size 从 16 减到 8,序列长度从 197 涨到 785(约 4 倍),")
print(" 注意力矩阵涨 16 倍,而总参数反而少了 0.5%(patch 投影层变小)——ViT 的瓶颈是计算,不是参数。")
print(" 反过来 patch_size=32 时总参数多 1.65M(投影层变大),但细节被抹掉,小目标检测明显变差。")
print(" image_size 从 224 到 512 时序列从 197 涨到 1024,位置编码表装不下了,必须插值,")
print(" 这就是换分辨率必须重采样位置编码的实现层面含义;patch 投影层的参数完全不受影响。")
print(" 最后,patch_size=8 的一行说明为什么 ViT 在小图上不划算:token 数接近 800,")
print(" 序列建模成本已经赶上语言模型,而图像只有 224x224。")
| 参数 | 含义 | 典型取值 | 说明 |
|---|---|---|---|
patch_size |
图像切块大小 | 16、14、8 | 调小则序列变长、计算量平方增长;调大则细节丢失 |
image_size |
输入分辨率 | 224、384 | 需与预训练分辨率一致,否则需插值位置编码 |
num_patches |
序列长度 | (image_size / patch_size) 的平方 | 加上 1 个 class token |
小数据(少于 10 万张)上,CNN 或预训练 ViT 微调显著优于从零训练 ViT。ViT 缺少 CNN 的局部性归纳偏置,需要海量数据才能补上这一课。
第七章 大模型微调参数
7.1 全参数微调(SFT)关键参数
核心代码:全参微调与普通训练只有三个差别:学习率小一到两个数量级、轮数少、必须 warmup 与梯度裁剪。下面给两版代码——Trainer 的实战写法和手写循环,参数落在哪一行一目了然。
"""7.1 全参数微调(SFT)的核心代码:所有参数都参与更新的那一版。
全参微调与普通训练只有三个差别,都在下面几行里:
1) 学习率小一到两个数量级(1e-5 到 1e-4),因为要"轻推"而不是"重训"
2) 轮数少(1 到 3),因为数据少、极易过拟合与灾难性遗忘
3) 必须 warmup + 梯度裁剪,否则前几步的大梯度会直接把预训练权重冲坏
下面给两版:A 是 transformers Trainer 的实战写法(推荐),B 是手写循环(理解用)。
运行需要 transformers + torch,本手册未做实际运行验证,只做结构参照。
"""
from dataclasses import dataclass
# ==================== A 版:Trainer(实战用这个) ====================
@dataclass
class SFTConfigShim:
"""把关键参数集中在一处,逐个对应 7.1 节表格。"""
output_dir: str = "./sft_out"
learning_rate: float = 2e-5 # 全参微调:远小于预训练,避免灾难性遗忘
num_train_epochs: float = 2.0 # 1 到 3 轮,超过几乎必然过拟合
per_device_train_batch_size: int = 2
gradient_accumulation_steps: int = 8 # 等效 batch = 2 * 8 = 16
warmup_ratio: float = 0.05 # 前 5% 步数线性升温,大模型必须
lr_scheduler_type: str = "cosine"
weight_decay: float = 0.0 # SFT 常设 0 或极小
max_grad_norm: float = 1.0 # 防 loss 尖峰破坏权重
bf16: bool = True # 优先 bf16,动态范围大不易溢出
gradient_checkpointing: bool = True # 用约 20% 速度换 60% 以上显存
logging_steps: int = 10
save_strategy: str = "epoch"
eval_strategy: str = "epoch" # transformers 4.38 用 evaluation_strategy
def build_trainer(model, tokenizer, train_ds, eval_ds):
"""真实项目里这一段是十几行样板代码,贴出来是为了让你知道每个参数落在哪。"""
from transformers import Trainer, TrainingArguments
args = TrainingArguments(
output_dir="./sft_out",
learning_rate=2e-5,
num_train_epochs=2.0,
per_device_train_batch_size=2,
gradient_accumulation_steps=8,
warmup_ratio=0.05,
lr_scheduler_type="cosine",
weight_decay=0.0,
max_grad_norm=1.0,
bf16=True,
gradient_checkpointing=True,
evaluation_strategy="epoch", # 注意:5.x 改名为 eval_strategy,版本不对会报错
save_strategy="epoch",
logging_steps=10,
report_to="none",
)
return Trainer(model=model, args=args, train_dataset=train_ds, eval_dataset=eval_ds)
# ==================== B 版:手写循环(看清每一步) ====================
def collate(batch, tokenizer, max_len=512):
"""把样本拼成 input_ids / labels。SFT 的关键:labels 与 input_ids 相同,但 prompt 段置 -100。"""
texts = [b["text"] for b in batch]
enc = tokenizer(texts, truncation=True, max_length=max_len, padding=True,
return_tensors="pt")
labels = enc["input_ids"].clone()
labels[enc["attention_mask"] == 0] = -100 # padding 不参与损失
enc["labels"] = labels
return enc
def train_full_finetune(model, tokenizer, dataset, epochs=2, lr=2e-5,
grad_accum=8, max_grad_norm=1.0, warmup_ratio=0.05):
"""全参微调的最小实现:注意 optimizer 拿到的是 model.parameters() 全部参数。"""
import torch
from torch.utils.data import DataLoader
from transformers import get_cosine_schedule_with_warmup
loader = DataLoader(dataset, batch_size=2, shuffle=True,
collate_fn=lambda b: collate(b, tokenizer))
total_steps = len(loader) // grad_accum * epochs
# 全参微调用 AdamW 而不是 Adam:让 weight_decay 与梯度解耦
optimizer = torch.optim.AdamW(model.parameters(), lr=lr, weight_decay=0.0)
scheduler = get_cosine_schedule_with_warmup(
optimizer, num_warmup_steps=int(total_steps * warmup_ratio),
num_training_steps=total_steps)
model.train()
for epoch in range(epochs):
for step, batch in enumerate(loader):
out = model(**{k: v.to(model.device) for k, v in batch.items()})
loss = out.loss / grad_accum # 梯度累积:先除再反传,等效大 batch
loss.backward()
if (step + 1) % grad_accum == 0:
torch.nn.utils.clip_grad_norm_(model.parameters(), max_grad_norm)
optimizer.step()
scheduler.step() # 按 optimizer 步数走,不是按 batch
optimizer.zero_grad(set_to_none=True)
if step % 10 == 0:
print(f"epoch {epoch} step {step} loss {loss.item() * grad_accum:.4f} "
f"lr {scheduler.get_last_lr()[0]:.2e}")
# 三个高频错误,都在这份代码里有明确的位置:
# 1) 忘了把 padding 位置的 labels 设成 -100 -> 模型在学"怎么输出 padding"
# 2) scheduler.step() 每个 batch 都调 -> 实际衰减步数是预期的 grad_accum 倍
# 3) 用 fp16 但没开 loss scaling -> 梯度下溢成 0,loss 完全不动(用 bf16 可避开)
| 参数 | 含义 | 典型取值 | 说明 |
|---|---|---|---|
learning_rate |
学习率 | 1e-5 到 1e-4(全参),2e-4 到 2e-3(LoRA) | 全参微调学习率应远小于预训练,否则灾难性遗忘 |
num_train_epochs |
训练轮数 | 1 到 3 | SFT 通常 1 到 3 轮即饱和,超过 3 轮几乎必然过拟合与遗忘 |
per_device_train_batch_size |
单卡批大小 | 1 到 8 | 受显存限制 |
gradient_accumulation_steps |
梯度累积 | 4 到 32 | 使等效批大小达到 32 到 128 |
warmup_ratio |
预热比例 | 0.03 到 0.1 | 大模型必须 warmup |
lr_scheduler_type |
调度类型 | cosine、linear |
微调常用 cosine |
weight_decay |
权重衰减 | 0 到 0.1 | SFT 中常设 0 或很小 |
max_grad_norm |
梯度裁剪阈值 | 1.0 | 防止 loss 尖峰导致权重破坏 |
fp16 / bf16 |
混合精度 | bf16 优先 | bf16 动态范围大,不易溢出;fp16 需配 loss scaling |
gradient_checkpointing |
梯度检查点 | True | 用约 20% 速度换 60% 以上显存,显存不足时的首选 |
7.2 LoRA 与 QLoRA
核心代码:LoRA 把权重变化拆成两个瘦矩阵的乘积。r 决定多瘦、alpha/r 决定有效步长、B 零初始化决定不破坏原模型——三件事都在下面的代码里,可以直接跑出数来。
"""7.2 LoRA:低秩分解是怎么注入的,r 与 alpha 到底动的是什么。
LoRA 的假设是:微调带来的权重变化 Delta W 是低秩的。于是不直接训 Delta W,
而是把它拆成两个瘦矩阵的乘积:
Delta W = B @ A A: (r, d_in) B: (d_out, r)
前向变成 h = W x + (alpha / r) * B A x
三个关键点都能在这三行里看到:
1) r 决定 A、B 有多"瘦",直接决定新增参数量(与 r 成正比,不是平方)
2) alpha / r 是缩放系数,改 alpha 等价于改 LoRA 分支的有效学习率
3) 初始化时 B 全零、A 随机,所以训练开始时 Delta W = 0,不破坏原模型
下面用 numpy 演示秩分解与参数量,并验证"alpha 固定时改 r,有效步长怎么变"。
"""
import numpy as np
def lora_params(d_out, d_in, r):
"""LoRA 新增参数 = r*d_in + d_out*r。对比全参的 d_out*d_in。"""
return r * d_in + d_out * r
def lora_delta(x, A, B, alpha, r):
"""前向增量:先降到 r 维再升回去,最后乘 alpha/r 缩放。"""
return (x @ A.T @ B.T) * (alpha / r)
# ---------- 参数量对照:r 与全参的差距 ----------
print("--- 单个 512x512 的投影层,加 LoRA 的参数量 ---")
d = 512
for r in (4, 8, 16, 32, 64):
p = lora_params(d, d, r)
print(f"r={r:<3} LoRA 参数={p:>7,} 占全参 {p / (d * d):.2%}")
print("\n--- 一个 7B 模型的粗算(按 32 层、每层 7 个投影矩阵、d=4096)---")
d_model, layers, n_proj, r = 4096, 32, 7, 16
full_attn = layers * n_proj * d_model * d_model
lora = layers * n_proj * lora_params(d_model, d_model, r)
print(f"这些投影矩阵本身有 {full_attn / 1e9:.2f}B 参数(7B 模型里 FFN 另占一半左右)")
print(f"LoRA r={r} 只加 {lora / 1e6:.1f}M 参数,占 7B 的 {lora / 7e9:.2%}")
print(f"若做全参微调,需要为 7B 参数各存一份梯度与优化器状态,显存约 7B*16 字节 = 112GB")
print("这就是 24G 卡只能上 LoRA 的原因:不是算不动,是存不下优化器状态。")
# ---------- 初始化:为什么 B 必须是零 ----------
rng = np.random.default_rng(0)
x = rng.normal(size=4096) * 0.1
d_in, d_out, r, alpha = 4096, 4096, 16, 32
A = rng.normal(0, 1 / np.sqrt(d_in), (r, d_in))
B_zero = np.zeros((d_out, r))
B_rand = rng.normal(0, 1 / np.sqrt(r), (d_out, r))
print(f"\nB 全零时的增量范数 = {np.linalg.norm(lora_delta(x, A, B_zero, alpha, r)):.6f}")
print(f"B 随机初始化时 = {np.linalg.norm(lora_delta(x, A, B_rand, alpha, r)):.6f}")
print("B 零初始化保证训练第 0 步的输出与基座模型完全一致——这是 LoRA 不破坏预训练的前提。")
# ---------- alpha 与 r 的比例关系 ----------
print("\n--- 同一个 r=16,改 alpha 等于改有效步长 ---")
for alpha in (8, 16, 32):
scale = alpha / r
print(f"alpha={alpha:<3} 缩放系数 alpha/r = {scale:.2f}")
print("\n--- alpha 不变(16)时改 r,缩放系数与参数量怎么变 ---")
for rr in (4, 8, 16, 32):
print(f"r={rr:<3} alpha/r = {16 / rr:.2f} 参数={lora_params(4096, 4096, rr):>9,}")
# ---------- 秩分解:目标矩阵真的低秩时,LoRA 能完美拟合 ----------
print("\n--- 当 Delta W 本身是秩 4 的时候,LoRA r=4 能精确还原 ---")
true_rank = 4
U = rng.normal(size=(d_out, true_rank))
V = rng.normal(size=(true_rank, d_in)) * 0.01
dW = U @ V # 真实增量,秩恰好为 4
Uo, S, Vo = np.linalg.svd(dW, full_matrices=False)
recon = (Uo[:, :true_rank] * S[:true_rank]) @ Vo[:true_rank]
print(f"真实秩 = {np.linalg.matrix_rank(dW)},用前 4 个奇异值重建的相对误差 = "
f"{np.linalg.norm(recon - dW) / np.linalg.norm(dW):.2e}")
print(f"若只取前 2 个:{np.linalg.norm((Uo[:, :2] * S[:2]) @ Vo[:2] - dW) / np.linalg.norm(dW):.3f}")
print("\n读法:r 从 4 涨到 64,LoRA 参数从 4,096 线性涨到 65,536,而这一层的全参是 262,144——")
print(" 注意增长是线性的,不是平方的,所以加 r 比加宽度便宜得多。")
print(" r=64 时已占全参的 25%,收益递减而显存线性上升,实践中很少超过 32。")
print(" 第二组给出量级感:7B 模型上 r=16 的 LoRA 只占 0.42%,而全参微调要 100GB 以上显存,")
print(" 所以 LoRA 省的不是算力,是优化器状态——这才是单卡能训 7B 的真实原因。")
print(" 第三组解释 B 零初始化:它不是技巧,是让 Delta W 从 0 出发的必要条件。")
print(" 最后一组是 LoRA 的适用边界——真实增量若秩很高,小 r 会欠拟合,")
print(" 表现为训练集也学不会,这时该加 r,而不是加 epoch。")
| 参数 | 含义 | 典型取值 | 调大与调小的影响 |
|---|---|---|---|
r(rank) |
低秩矩阵的秩 | 4 到 64(常用 8、16、32) | 调大:可表达能力增强,能学到更复杂的变化,但参数增多、易过拟合;调小:欠拟合,模型几乎学不到新行为 |
lora_alpha |
缩放系数,实际缩放为 alpha/r | 常取 r 的 1 到 2 倍,或固定 16、32 | 调大等效于加大 LoRA 分支的学习率。关键是与 r 的比例,而非绝对值 |
lora_dropout |
LoRA 层的 dropout | 0 到 0.1 | 小数据集上取 0.05 到 0.1 抗过拟合 |
target_modules |
施加 LoRA 的模块名 | q_proj、v_proj(最小配置);加 k_proj、o_proj、gate_proj、up_proj、down_proj(更充分) |
覆盖模块越多效果越好,参数也越多。只加 q、v 是性价比起点;全线性层是效果上限 |
bias |
偏置是否训练 | none |
一般不动,收益微弱 |
task_type |
任务类型 | CAUSAL_LM、SEQ_2_SEQ_LM |
必须与模型类型匹配 |
QLoRA 额外参数
| 参数 | 含义 | 典型取值 | 说明 |
|---|---|---|---|
load_in_4bit |
是否 4bit 量化加载 | True | 显存降至约四分之一 |
bnb_4bit_quant_type |
量化类型 | nf4 |
nf4 针对正态分布权重更优,是默认选择 |
bnb_4bit_compute_dtype |
计算精度 | bfloat16 |
反量化后参与计算的精度 |
bnb_4bit_use_double_quant |
二次量化 | True | 对量化常数再量化,再省约 0.4 bit/参数 |
gradient_checkpointing |
梯度检查点 | True | QLoRA 场景几乎必开 |
QLoRA 的代价:训练速度比 LoRA 慢约 30% 到 50%,且量化误差会带来轻微效果损失。若显存足够(如 7B 模型配 80GB 卡),优先用 bf16 LoRA 而非 QLoRA。
7.3 偏好对齐(DPO)
核心代码:DPO 的损失只有四行。beta 的作用就是那一行乘法:放大偏离、让 sigmoid 饱和、让模型不敢走远。代码把不同 beta 下的损失与梯度直接打出来。
"""7.3 DPO:偏好对齐的损失函数只有四行,beta 的作用一测就明白。
DPO 的完整思想:不训练奖励模型,直接用"策略模型 vs 参考模型"的对数概率比构造隐式奖励。
对每个偏好对 (chosen, rejected),定义:
logits = beta * [ (logp_pi(y_w) - logp_ref(y_w)) - (logp_pi(y_l) - logp_ref(y_l)) ]
loss = -log(sigmoid(logits))
beta 的作用全在那一行乘法里:
beta 大 -> 括号里同样的偏离会被放大成很大的 logit -> 梯度饱和 -> 模型不敢偏离参考模型
beta 小 -> 同样的偏离产生较小的 logit -> 梯度持续 -> 模型敢走更远,也更容易崩
所以"beta 调大更保守"不是经验说法,是 sigmoid 饱和的数学结果。
"""
import numpy as np
def sigmoid(z):
return 1 / (1 + np.exp(-np.clip(z, -30, 30)))
def dpo_loss(logp_pi_w, logp_pi_l, logp_ref_w, logp_ref_l, beta=0.1):
"""四个输入都是"整条回复的对数概率"(标量或数组),形状需一致。"""
pi_logratio = logp_pi_w - logp_pi_l # 策略模型更偏好 chosen 多少
ref_logratio = logp_ref_w - logp_ref_l # 参考模型本身更偏好 chosen 多少
logits = beta * (pi_logratio - ref_logratio)
loss = -np.mean(np.log(sigmoid(logits) + 1e-12))
return loss, logits
print("--- beta 如何改变同一个偏好对的损失与梯度 ---")
# 假设:参考模型对 chosen 与 rejected 差不多(差 0.2),策略模型刚开始偏好 chosen(差 1.0)
ref_w, ref_l = -12.0, -12.2
pi_w, pi_l = -11.0, -12.0
print(f"参考模型 logp:chosen {ref_w}, rejected {ref_l}(差 {ref_w - ref_l:.2f})")
print(f"策略模型 logp:chosen {pi_w}, rejected {pi_l}(差 {pi_w - pi_l:.2f})")
for beta in (0.01, 0.1, 0.5, 1.0):
loss, logit = dpo_loss(pi_w, pi_l, ref_w, ref_l, beta)
# loss 对 logit 的梯度是 -(1 - sigmoid(logit)),logit 越大梯度越小
grad = -(1 - sigmoid(logit))
print(f"beta={beta:<5} logit={float(logit):>7.3f} loss={float(loss):.4f} "
f"dLoss/dlogit={float(grad):+.4f}")
print("\n--- 模型已经学得很好时,beta 决定它还愿不愿意继续走 ---")
# 策略模型已经把 chosen 抬得很高:差达到 4.0
pi_w2, pi_l2 = -8.0, -12.0
for beta in (0.01, 0.1, 0.5, 1.0):
loss, logit = dpo_loss(pi_w2, pi_l2, ref_w, ref_l, beta)
grad = -(1 - sigmoid(logit))
print(f"beta={beta:<5} logit={float(logit):>7.3f} loss={float(loss):.6f} "
f"dLoss/dlogit={float(grad):+.6f} "
f"{'梯度接近饱和' if abs(grad) < 0.03 else '仍在推动'}")
# ---------- 常见的错误用法:漏掉参考模型项 ----------
print("\n--- 漏掉参考模型(ref 全设为 0)会发生什么 ---")
for pi_w3, pi_l3 in [(-11.0, -12.0), (-1.0, -12.0), (-0.01, -12.0)]:
loss, logit = dpo_loss(pi_w3, pi_l3, 0.0, 0.0, beta=0.1)
print(f"策略 logp 差 {pi_w3 - pi_l3:>6.2f} -> loss={float(loss):.4f}")
print("没有参考模型做锚,模型只要无限抬高 chosen 的对数概率就能继续降 loss,")
print("结果是对数概率整体漂移、输出长度暴涨——这是 DPO 崩坏最常见的原因。")
print("\n读法:第一组里 beta 从 0.01 到 1.0,同一个偏好对的 logit 从 0.008 放大到 0.800,")
print(" 梯度从 -0.498 降到 -0.310,说明 beta 越大、更新越保守。")
print(" 第二组是模型已经学好的情形:beta=1.0 时 logit 冲到 3.8,残余梯度只剩 -0.022,")
print(" 是 beta=0.01 时(-0.49)的 4.5%——所以 beta 越大越早停手;反之 beta 太小时,")
print(" 模型会一直推到自身崩掉才停。经验区间 0.1 到 0.5;数据偏好噪声大时往大取。")
| 参数 | 含义 | 典型取值 | 说明 |
|---|---|---|---|
beta |
对参考模型偏离的惩罚强度 | 0.1 到 0.5 | 调大:更保守,贴近参考模型,对齐幅度小;调小:更激进,易出现语言退化与模式崩塌 |
learning_rate |
学习率 | 5e-7 到 5e-6 | DPO 学习率比 SFT 小一到两个数量级 |
num_train_epochs |
轮数 | 1 到 2 | 超过 2 轮极易过拟合,表现为输出长度暴涨或重复 |
loss_type |
损失变体 | sigmoid、ipo、kto_pair |
IPO 对偏好噪声更鲁棒 |
7.4 微调成功的判据
| 维度 | 指标 | 合格线 |
|---|---|---|
| 任务效果 | 领域测试集准确率或胜率 | 相比基座模型提升 5 个百分点以上,或人工评测胜率高于 60% |
| 遗忘程度 | 通用能力基准(如 MMLU 子集、GSM8K 抽样) | 下降不超过 3 个百分点 |
| 格式遵循 | 指令格式正确率 | 高于 95% |
| 输出质量 | 平均回复长度、重复率 | 长度与 SFT 数据分布接近(偏离小于 30%),4-gram 重复率低于 5% |
| 稳定性 | 同输入多次采样的方差 | 温度 0 时结果完全一致;温度 0.7 时语义一致 |
浙公网安备 33010602011771号