AIGC标识 机器学习与深度学习算法参数详解(上)

机器学习与深度学习算法参数详解与调参实战手册

目录

第一章 阅读指南

1.1 这本手册解决什么问题

调参这件事最容易被讲成玄学:老手说"学习率调小一点""正则加强一些",新手照做却不知道为什么,也不知道做完之后该看什么现象判断对错。本手册的基本立场是:每一个超参数都有它控制的物理量,每一个物理量都会在训练曲线上留下痕迹,而痕迹是可以被读出来的。

所以本手册不给你一份"最佳参数值清单",而是给你四样东西:

  1. 参数表——每个算法有哪些真正需要调的参数,它们各自控制什么,典型取值范围是多少;
  2. 实现代码——每个算法不只给调包写法,还给一段把它内部机制摊开的最小实现,注释直接标出"这个参数作用在哪一行";
  3. 判据表——训练跑起来之后,看哪些指标、出现什么形态,说明这一次训练是成功的;
  4. 病历表——出问题时对应哪种病症,怎么定位,怎么开药。

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 算法选型的实用顺序

不要一上手就上最复杂的模型。推荐的决策顺序如下:

  1. 先问数据量。样本少于 1000 且特征维度高,优先线性模型 + 强正则;样本 1 万到 100 万,优先 LightGBM 或 XGBoost;样本超过百万或需处理非结构化数据,才考虑深度学习。
  2. 再问数据类型。表格数据上,梯度提升树几乎总是优于神经网络,这是被无数竞赛与工业实践反复验证的结论;图像、语音、文本等非结构化数据上,深度网络是唯一现实选择。
  3. 再问可解释性要求。金融风控、医疗诊断等场景若需向监管或医生解释,线性模型与浅层树模型优于黑箱模型。
  4. 最后问迭代成本。树模型训练秒级、调试直观;深度模型依赖 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"的头号元凶,必须在调参之前排除。

  1. 预处理泄漏:在全量数据上做标准化、填充、编码、特征选择。
  2. 过采样泄漏:先对全量数据 SMOTE 再划分数据集。
  3. 时间泄漏:用未来数据预测过去,或特征中混入了标签发生之后才产生的字段。
  4. 实体泄漏:同一用户、同一设备、同一患者的记录同时出现在训练集与测试集。
  5. 目标编码泄漏:用包含当前样本自身标签的统计量做编码,未做折外编码。
  6. 重复样本泄漏:数据集中存在重复或近重复样本被分到不同集合。

自检方法:把测试集指标与训练集指标对比,若差距小于 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 同上

调参要点:

  1. 必须先标准化。否则 lbfgs 收敛极慢甚至不收敛,且正则项对不同量纲特征的惩罚不公平。
  2. C 的搜索范围要跨数量级。常见错误是在 0.5 到 2 之间细搜,而真正的最优值可能在 0.01 或 50。
  3. 看系数而非只看指标。逻辑回归的价值在于系数可解释,若系数符号与业务常识相反,往往意味着特征共线性严重,应先用 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 不影响结果,只影响速度

调参要点:

  1. n_estimators 先设大(如 500),后面调其他参数时不必反复动它。
  2. 随机森林对 max_features 最敏感,建议在 sqrt 到 0.6 之间搜索。
  3. 若 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

调参要点:

  1. C 与 gamma 必须联合网格搜索,单独调任一个都会得到误导性结论。推荐 C 取 10 的幂次、gamma 取 10 的负幂次做二维网格。
  2. SVM 对量纲极度敏感,不标准化时 RBF 核几乎必然失效。
  3. 样本超过 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 优于随机初始化

聚类"成功"的标志与监督学习不同,不能看准确率:

  1. 轮廓系数大于 0.5(0.25 到 0.5 说明结构弱,低于 0.25 基本无结构);
  2. 簇大小不极端失衡(最大簇与最小簇样本比小于 10);
  3. 业务可解释:每个簇能用两三个特征描述出清晰画像,否则聚类结果无法落地;
  4. 稳定性:换随机种子或自助采样后,用 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 时语义一致

posted @ 2026-11-19 13:03  随性岁分享  阅读(27)  评论(1)    收藏  举报