机器学习与深度学习算法参数详解(下)
第八章 训练成功的判据体系
8.1 "成功"需要同时满足三个层次
很多人判断训练成功的标准只有一条:验证集指标比上次高。这不够。一个真正成功的训练必须同时通过三层检验。
| 层次 | 问题 | 判据 | 不通过的后果 |
|---|---|---|---|
| 第一层:优化成功 | 模型是否真的学到了训练集里的模式 | 训练损失稳定下降并收敛,梯度健康 | 模型没拟合,后面都无意义 |
| 第二层:泛化成功 | 学到的模式是否可迁移到未见数据 | 验证集指标与训练集接近,学习曲线正常 | 过拟合,线上崩盘 |
| 第三层:业务成功 | 指标提升是否等于业务价值提升 | 业务指标同步改善,且提升幅度超过噪声 | 指标涨了但没意义,甚至有害 |
三层是依次递进的。只优化第一层就宣布成功,是新手最典型的误判。
8.2 损失曲线的四种健康形态
| 形态 | 现象 | 判断 |
|---|---|---|
| 标准收敛 | 训练损失快速下降后趋于平缓,验证损失同步下降后略微上翘 | 健康。验证损失上翘的位置就是最佳早停点 |
| 阶梯式下降 | 损失在若干平台期后突降 | 健康。通常由学习率衰减触发,说明调度器在起作用 |
| 长尾缓慢 | 训练损失长时间缓慢下降,验证损失同步 | 健康但欠训练,可增加轮数或提高学习率 |
| 平滑无抖动 | 曲线过于平滑、方差极小 | 需警惕,可能是 batch 太大掩盖了信息,或数据重复度过高 |
读曲线时看三个量:下降速度(前 10% 步数内应完成大部分下降)、最终平台高度(决定模型上限)、验证损失拐点位置(决定早停时机)。
8.3 指标健康度判据
| 指标 | 健康表现 | 阈值参考 |
|---|---|---|
| 训练集与验证集指标差 | 随训练进行收敛到较小值 | 分类任务小于 3 到 5 个百分点;回归任务验证 RMSE 不超过训练 RMSE 的 1.3 倍 |
| 交叉验证标准差 | 各折之间波动小 | 分类准确率标准差小于 2%;回归 RMSE 变异系数小于 10% |
| 学习曲线 | 随训练样本增加,训练与验证曲线收敛 | 加入 50% 数据后验证指标仍明显上升,说明应补数据而非调参 |
| 混淆矩阵 | 各类别召回率不低于整体的 60% | 若某类召回接近 0,说明该类被完全牺牲 |
| 校准度 | 预测概率与实际频率吻合 | 可靠性曲线接近对角线;用 ECE 衡量,小于 0.05 为良好 |
| 阈值敏感性 | 相邻阈值指标变化平缓 | 阈值从 0.45 到 0.55 时 F1 波动小于 3%,说明模型稳健 |
8.4 参数健康度(深度学习必查)
这些量不看会吃亏,因为它们能在指标恶化之前预警。
| 检查项 | 健康区间 | 异常含义 |
|---|---|---|
| 梯度范数 | 1e-3 到 10(视模型规模) | 持续小于 1e-6 为梯度消失;突然上千为梯度爆炸 |
| 各层梯度范数比 | 相邻层差异不超过一个数量级 | 差异过大说明某层学不动或主导训练 |
| 权重范数 | 训练过程中平稳或缓慢增长 | 快速膨胀预示发散;快速趋零预示正则过强 |
| 激活值分布 | 均值接近 0,标准差在 0.5 到 2 之间 | 大量为 0 说明神经元死亡;数值过大说明尺度失衡 |
| 更新量比例 | 参数更新量 / 参数值 在 1e-3 量级 | 过大则训练不稳,过小则学不动 |
| 损失尖峰频率 | 偶发且能自行恢复 | 频繁尖峰需降低学习率或加强梯度裁剪 |
实现方式:注册 PyTorch 的 register_forward_hook 与 register_full_backward_hook,每个 epoch 打印各层梯度范数与激活均值标准差均值。
8.5 学习曲线诊断图
以训练样本量为横轴、指标为纵轴,画训练分数与验证分数两条线,可以得到四种典型诊断:
| 图形特征 | 诊断 | 处方 |
|---|---|---|
| 两条线都低且靠得很近 | 欠拟合(高偏差) | 增加模型容量、加特征、减正则、训练更久 |
| 训练线高、验证线低,差距大 | 过拟合(高方差) | 加数据、加正则、降容量、早停 |
| 两条线都高且很近,但验证线仍在上升 | 数据不足 | 补数据收益最大 |
| 两条线交叉震荡 | 数据划分有问题或学习率过大 | 检查泄漏与划分方式,降学习率 |
8.6 训练成功体检表
把下面这张表当作交付前的 checklist,全部通过才宣布训练成功。
| 序号 | 检查项 | 通过标准 | 结果 |
|---|---|---|---|
| 1 | 数据无泄漏 | 按实体、时间、预处理三条线逐一排查 | 待填 |
| 2 | 训练损失已收敛 | 最后 10% 步数的损失均值波动小于 1% | 待填 |
| 3 | 训练验证差距可控 | 分类小于 5 个百分点,回归 RMSE 比值小于 1.3 | 待填 |
| 4 | 交叉验证稳定 | 各折指标标准差小于 2% | 待填 |
| 5 | 基线已被超越 | 相比规则基线或简单模型提升显著(超 2 个百分点) | 待填 |
| 6 | 指标覆盖多维度 | 不只看 accuracy,含精确率、召回率、F1 或 AUC | 待填 |
| 7 | 概率已校准 | ECE 小于 0.05,或已做 Platt 与保序回归校准 | 待填 |
| 8 | 结果可复现 | 固定种子后两次运行指标差异小于 0.5 个百分点 | 待填 |
| 9 | 超参已记录 | 完整配置文件与版本号已存档 | 待填 |
| 10 | 残差或误差已分析 | 已抽样查看至少 50 个错误样本并归类 | 待填 |
第 10 条最容易被跳过,但它往往是提升幅度最大的来源。看完错误样本后常见的发现是:某类样本标注错了、某字段缺失率在特定群体中极高、文本长度超过截断阈值。这些问题的修复成本远低于调参。
第九章 失败与病态训练图鉴
这一章按"现象 → 根因 → 诊断 → 处方"的四段式列出十七种典型失败。遇到问题时先在此表定位。
9.1 拟合不足类
病症一:欠拟合(高偏差)
| 项目 | 内容 |
|---|---|
| 现象 | 训练损失下降后停在较高的平台;训练集与验证集指标都差且几乎相等;增加训练轮数无改善 |
| 根因 | 模型容量不足;特征信息量不够;正则过强;学习率过小导致未走到最优点;标签本身噪声大导致上限低 |
| 诊断 | 用极小正则、极大容量(如深度不限的树)跑一次,若训练集指标仍低,说明是数据或特征问题而非容量问题 |
| 处方 | 增加特征与交互项;提高模型容量;降低 weight decay 与 dropout;检查是否存在特征被错误缩放或截断 |
病症二:学习率过小(训练龟速)
| 项目 | 内容 |
|---|---|
| 现象 | 损失下降极其缓慢,曲线近乎水平;训练很久仍未收敛;梯度范数正常但参数几乎不动 |
| 根因 | 学习率比合适值小一到两个数量级;或参数初始化尺度过小 |
| 诊断 | 学习率扫描测试:取 1e-6 到 1 的对数序列各跑 100 步,看损失下降幅度 |
| 处方 | 提高到扫描得到的最优区间;配合 warmup 与余弦衰减;检查优化器是否被正确绑定到模型参数 |
9.2 过拟合类
病症三:经典过拟合(高方差)
| 项目 | 内容 |
|---|---|
| 现象 | 训练损失持续下降到接近 0,验证损失在某个点后持续上升,二者形成开口向外的喇叭形;训练准确率 99% 而验证 75% |
| 根因 | 模型容量远超数据信息量;样本量不足;特征维度高而样本少;正则缺失 |
| 诊断 | 画学习曲线确认是数据不足还是容量过大;对比加入正则后的验证指标变化 |
| 处方 | 加数据优先;增强数据增强;加 dropout 与 weight decay;降容量;早停;树模型加深 min_child_samples 与 reg_lambda |
病症四:早停过早(伪欠拟合)
| 项目 | 内容 |
|---|---|
| 现象 | 训练在指标刚开始提升时就停止;恢复训练后指标还能继续涨 |
| 根因 | patience 设得过小(如 2 到 3 轮);验证集太小导致指标噪声大,被误判为不再提升;min_delta 设为 0 导致微小波动触发停止 |
| 诊断 | 把早停关闭跑满,观察指标能到多高,对比早停点 |
| 处方 | patience 设为总轮数的 5% 到 10%,且不低于 10 轮;min_delta 设为 1e-4 量级;验证集至少 1000 条;改用平滑后的指标做早停判断 |
病症五:批大小过大导致泛化变差
| 项目 | 内容 |
|---|---|
| 现象 | 训练损失下降更平滑、训练集指标更高,但验证集指标比小 batch 时低 1 到 2 个百分点;且对学习率调整不敏感 |
| 根因 | 大 batch 梯度估计噪声小,倾向收敛到尖锐极小值,泛化差;等效学习率未按比例调整 |
| 诊断 | 固定其他条件,仅改 batch size,观察验证指标随 batch 的变化曲线 |
| 处方 | 按平方根法则同步提高学习率;增加训练轮数;使用 LARS/LAMB;或改回小 batch 配梯度累积 |
9.3 优化失稳类
病症六:学习率过大(震荡与发散)
| 项目 | 内容 |
|---|---|
| 现象 | 损失曲线剧烈上下震荡呈锯齿状;损失突然跳高一个数量级;准确率在 10% 与 40% 之间来回跳(二分类时 10% 附近的来回跳说明模型在反向学习) |
| 根因 | 学习率超过损失曲面的稳定上限;warmup 缺失或过短;梯度未裁剪 |
| 诊断 | 将学习率降 10 倍重跑,若震荡消失即确认 |
| 处方 | 降学习率一个数量级;加 warmup;加梯度裁剪 max_norm=1.0;确认数据已归一化 |
病症七:梯度消失
| 项目 | 内容 |
|---|---|
| 现象 | 训练损失几乎不动,或只在前几层更新而深层参数不变;梯度范数持续小于 1e-6;深层网络尤其明显 |
| 根因 | 激活函数饱和(sigmoid、tanh 在深层连乘后梯度趋零);网络过深无残差;初始化尺度过小;RNN 长序列连乘 |
| 诊断 | 逐层打印梯度范数,观察从输出层到输入层的衰减倍数;若每层衰减一个数量级即可确认 |
| 处方 | 换 ReLU、GELU 等非饱和激活;加残差连接;用 LayerNorm 或 BatchNorm;改用合适的初始化(He 初始化、Xavier);RNN 换 LSTM 或 GRU;降低深度 |
病症八:梯度爆炸
| 项目 | 内容 |
|---|---|
| 现象 | 损失突然变成 NaN 或极大值;梯度范数突然升到 1e3 以上;权重范数快速膨胀 |
| 根因 | 学习率过大;深网络连乘放大;RNN 长序列;初始化尺度过大;损失函数未做数值稳定处理(如未取对数直接算概率乘积) |
| 诊断 | 打印每步梯度范数,看是否有尖峰;检查损失计算是否含 log(0) |
| 处方 | 梯度裁剪(首选);降学习率;用 torch.nn.utils.clip_grad_norm_;改用 bf16 而非 fp16;损失计算加 eps;检查标签范围是否合法 |
病症九:Loss 为 NaN 或 Inf
| 项目 | 内容 |
|---|---|
| 现象 | 训练若干步后 loss 变为 nan,之后永久为 nan |
| 根因 | 数值溢出:fp16 下指数运算溢出;除零(如 log(0)、分母为 0);学习率过大导致参数爆炸;输入含 NaN 或 Inf;标签含非法值 |
| 诊断 | 在训练循环中加断言,逐步检查输入、logits、loss 是否含 nan;用 torch.autograd.set_detect_anomaly(True) 定位出错算子 |
| 处方 | 改用 bf16;log 前加 eps;用 log_softmax 而非 log(softmax());检查数据管道中的空值与无穷;降学习率;确认标签编码范围正确(如 CrossEntropy 的标签从 0 开始而非 1) |
病症十:ReLU 死亡
| 项目 | 内容 |
|---|---|
| 现象 | 训练一段时间后损失不再下降;某些层输出恒为 0;该层梯度恒定为零 |
| 根因 | 学习率过大把 ReLU 的输入推到负半轴,之后梯度恒为 0 无法恢复;初始化不当 |
| 诊断 | 统计各层激活为 0 的比例,若某层超过 50% 且不再变化即可确认 |
| 处方 | 降学习率;换 LeakyReLU、ELU 或 GELU;加 BatchNorm;减小初始化尺度 |
9.4 指标幻觉类(最危险,因为看起来成功了)
病症十一:数据泄漏导致的虚高
| 项目 | 内容 |
|---|---|
| 现象 | 线下 AUC 0.98,线上 0.65;验证集指标高得反常;模型重要性排名第一的特征是某个可疑字段 |
| 根因 | 六种泄漏形态之一(见 3.6 节);最常见的是目标编码未做折外、全量数据做预处理、时序特征含未来信息 |
| 诊断 | 打乱标签后重训,若指标仍显著高于随机水平,说明存在泄漏;检查 Top 特征是否在业务上"不可能提前知道" |
| 处方 | 把全部预处理放进 Pipeline 内部;目标编码用 K 折折外统计;按时间或实体严格划分;删除事后字段 |
病症十二:类别不平衡下的准确率幻觉
| 项目 | 内容 |
|---|---|
| 现象 | 准确率 95%,但模型把所有样本都预测为多数类;少数类的召回率为 0 |
| 根因 | 只看 accuracy;不均衡比例超过 20 比 1 时,全预测多数类即可获得很高的 accuracy |
| 诊断 | 查看混淆矩阵与各类别召回率;计算与"全预测多数类"基线的对比 |
| 处方 | 改用 PR-AUC、F1、召回率、Kappa 系数;设 class_weight 或 scale_pos_weight;调整决策阈值;分层抽样 |
病症十三:标签噪声掩盖真实上限
| 项目 | 内容 |
|---|---|
| 现象 | 无论怎么调参,验证指标停在一个不高不低的平台;训练损失降不到很低;模型预测与人工判断在高置信样本上仍不一致 |
| 根因 | 标注错误率超过 5%;标注标准不一致;存在难以判定的边界样本 |
| 诊断 | 抽样人工复核 100 条高损失样本,统计其中标注错误的占比;训练一个"是否易错"的辅助模型,看是否集中在特定标注者或特定类别 |
| 处方 | 清洗标签;用置信学习(confident learning)筛出可疑样本;多标注者投票;对噪声鲁棒损失(对称交叉熵、广义交叉熵) |
病症十四:分布漂移导致的线下线上不一致
| 项目 | 内容 |
|---|---|
| 现象 | 离线评估通过,上线后指标持续下滑;上线首日尚可,一周后明显退化 |
| 根因 | 训练集与线上数据分布不同(时间、渠道、人群);上游特征计算逻辑变更 |
| 诊断 | 监控特征分布(PSI、KL 散度),PSI 超过 0.2 需警惕;对比线上与离线同一时间窗的指标 |
| 处方 | 用时间上更近的数据重训;加分布监控告警;建立再训练触发机制;对漂移敏感特征做在线归一化 |
9.5 工程配置类
病症十五:训练与推理行为不一致(BN 陷阱)
| 项目 | 内容 |
|---|---|
| 现象 | 训练时指标 92%,推理时只有 70%;同一批数据在前向两次得到不同结果 |
| 根因 | 推理时忘记 model.eval(),BatchNorm 仍用当前 batch 统计量、Dropout 仍随机置零 |
| 诊断 | 推理前后打印 model.training 属性;对比 eval 模式下的指标 |
| 处方 | 推理前固定调用 model.eval(),并用 with torch.no_grad(): 包裹;确认 BatchNorm 的 running_mean 与 running_var 已正确更新(momentum 不要设为 1) |
病症十六:结果不可复现
| 项目 | 内容 |
|---|---|
| 现象 | 相同代码相同数据,两次训练指标差 3 个百分点以上;无法判断改动是否真的有效 |
| 根因 | 未固定随机种子;DataLoader 多进程的种子不同;cudnn 的非确定性算法;浮点累加顺序差异 |
| 诊断 | 固定全部种子后重复三次,看方差 |
| 处方 | 固定 random、numpy、torch 种子;设 torch.backends.cudnn.deterministic=True 与 benchmark=False;DataLoader 设 worker_init_fn 与 generator;记录环境版本 |
病症十七:正则配置错误导致正则失效
| 项目 | 内容 |
|---|---|
| 现象 | 加了 weight decay 但过拟合没有缓解;加了 dropout 但训练与验证差距不变 |
| 根因 | 用 Adam 而非 AdamW,L2 惩罚被自适应学习率缩放;dropout 加在了错误位置(如在 BatchNorm 之前导致统计量偏移);树模型中 bagging_freq=0 使 bagging_fraction 失效 |
| 诊断 | 打印实际生效的正则强度;对比开启与关闭正则的权重范数变化 |
| 处方 | 优化器换 AdamW;dropout 放在激活之后、BN 之前需谨慎,推荐放在残差相加之前;树模型检查 bagging_freq 大于 0 |
第十章 调参方法论
10.1 调参五步法
调参不是把参数网格跑一遍,而是一个有假设、有对照、有结论的收敛过程。
| 步骤 | 动作 | 产出 |
|---|---|---|
| 1 建立可信基线 | 用默认参数或最简单模型跑通全流程,记录指标 | 基线指标与基线配置 |
| 2 定位瓶颈 | 判断当前是欠拟合、过拟合还是数据问题 | 明确的问题归属 |
| 3 排序参数 | 按对目标的预期影响排序,只动前三个 | 待调参数列表 |
| 4 单变量扫描 | 每次只改一个参数,跨数量级扫描 | 每个参数的敏感度曲线 |
| 5 联合微调与验证 | 取各参数最优区间的组合,用交叉验证确认 | 最终配置与置信区间 |
步骤 2 是整个流程的分水岭。 如果你的诊断是过拟合,却去调学习率,那大概率白干一天。
10.2 参数优先级排序(重要度递减)
不同算法的敏感参数不同,但有一个通用的排序直觉:先调控制模型容量的参数,再调控制随机性的参数,最后调控制优化过程的参数。
| 算法 | 第一优先 | 第二优先 | 第三优先 |
|---|---|---|---|
| 逻辑回归 | C |
penalty |
class_weight |
| 随机森林 | max_features |
n_estimators |
min_samples_leaf |
| XGBoost | max_depth + min_child_weight |
learning_rate + n_estimators |
subsample 与 colsample_bytree |
| LightGBM | num_leaves + min_data_in_leaf |
learning_rate + n_estimators |
feature_fraction 与 bagging_fraction |
| SVM | C 与 gamma(联合) |
kernel |
class_weight |
| 神经网络 | learning_rate |
网络容量(层数与宽度) | weight_decay 与 dropout |
| 大模型 LoRA | r(或 lora_alpha/r) |
learning_rate |
target_modules |
10.3 搜索策略对比
| 策略 | 原理 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|---|
| 网格搜索 | 穷举笛卡尔积 | 简单、可并行、覆盖确定 | 维度灾难,参数多时不可行 | 参数不超过 3 个且范围已知 |
| 随机搜索 | 在分布中随机采样 | 高维下比网格更高效(Bergstra 结论) | 不保证覆盖最优点 | 参数较多时的默认选择 |
| 贝叶斯优化 | 用代理模型(TPE、GP)建模参数与指标的关系 | 样本效率最高 | 串行、实现复杂、易陷入局部 | 单次训练成本高(如深度学习) |
| HyperBand | 早停劣质配置,把预算给有希望的 | 快数倍,适合大规模 | 需要支持中间报告 | 深度学习、大模型 |
| ASHA | 异步逐次减半 | 支持并行、无需等待 | 需要调度框架 | 分布式训练 |
| 遗传算法 | 交叉变异迭代 | 适合离散与组合空间 | 收敛慢、超参更多 | 特征选择、结构搜索 |
实践建议:先用随机搜索在粗粒度上定区间,再用贝叶斯优化在小区间内精修,深度学习场景优先用 HyperBand 或 ASHA。
10.4 实验管理规范
可复现性是调参的前提,没有它所有对比都是幻觉。最低要求:
- 配置文件化:所有超参写进 YAML 或 dataclass,不写在代码里,不改代码就能改实验。
- 命名可读:
exp_20261118_lgb_leaves63_lr005比exp37有用得多;或用 MLflow、W&B 自动记录。 - 记录五要素:数据版本、代码 commit、超参配置、随机种子、环境版本。
- 一次一个变量:同时改两个参数得到提升,你不知道是谁的功劳,也不知道是否互相抵消。
- 记录失败的实验:负结果同样有价值,能避免重复踩坑。
推荐最小实验记录表:
| 实验编号 | 变更内容 | 训练指标 | 验证指标 | 测试指标 | 训练时长 | 结论 |
|---|---|---|---|---|---|---|
| E001 | 基线 LightGBM 默认 | 0.912 | 0.874 | — | 42s | 基线 |
| E002 | 加 min_data_in_leaf=50 | 0.895 | 0.881 | — | 45s | 验证涨 0.7 点,保留 |
| E003 | 加 feature_fraction=0.8 | 0.891 | 0.883 | — | 40s | 再涨 0.2 点,保留 |
10.5 调参陷阱清单
| 陷阱 | 表现 | 正确做法 |
|---|---|---|
| 在测试集上调参 | 测试指标与线上差距大 | 只用验证集调参,测试集只用一次 |
| 反复用同一验证集 | 验证指标逐渐虚高(对验证集过拟合) | 用交叉验证,或留一份从未看过的 holdout |
| 追求指标小数点后三位 | 花大量时间换 0.1 点提升 | 先确认提升超过随机种子带来的波动范围 |
| 忽略训练成本 | 指标涨 0.2 点但训练时间翻五倍 | 同时衡量指标、时间、显存、可维护性 |
| 不做特征工程直接调参 | 参数调到极限仍达不到要求 | 先做特征,通常收益远大于调参 |
| 复制他人最优参数 | 在自己的数据上效果差 | 参数与数据规模、特征分布强相关,只能作为起点 |
第十一章 常见面试题与参考答案
按主题分为六组。答案已压缩到面试口述长度,每题为 3 到 5 句。
11.1 基础概念
Q1:过拟合与欠拟合的本质区别,分别怎么解决?
过拟合是模型学到了训练集中的噪声,方差大,表现为训练指标远好于验证指标;欠拟合是模型连训练集的规律都没学到,偏差大,表现为训练与验证指标都低。解决过拟合:加数据、加正则、降容量、早停、数据增强;解决欠拟合:加特征、加容量、减正则、训练更久、换更强的模型族。
Q2:偏差-方差分解说明了什么?
期望泛化误差 = 偏差平方 + 方差 + 不可约噪声。模型复杂度上升时偏差下降、方差上升,总误差呈 U 形,最优点在二者平衡处。这解释了为什么"更复杂的模型"不一定更好,也解释了集成方法的两条路线:Boosting 降偏差、Bagging 降方差。
Q3:L1 与 L2 正则的区别?为什么 L1 产生稀疏解?
L1 惩罚系数绝对值之和,L2 惩罚平方和。L1 的等值线是菱形,顶点落在坐标轴上,与损失函数等高线的交点常出现在坐标轴上,因此部分系数被压为 0,可用于特征选择。L2 的等值线是圆形,收缩但不为零,且能稳定处理共线性。几何解释之外,从贝叶斯角度看 L1 等价于拉普拉斯先验,L2 等价于高斯先验。
Q4:为什么交叉验证比单次划分更可靠?
单次划分的评估结果受划分随机性影响大,小数据集上方差尤其高。K 折交叉验证让每个样本都参与一次验证,评估结果是 K 次的平均,方差降低约 K 倍,且能给出置信区间。代价是训练成本增加 K 倍。分类任务要用分层 K 折保持类别比例,时序数据要用时间序列切分。
Q5:什么是数据泄漏?举三种典型场景。
数据泄漏指训练过程中使用了预测时不可能获得的信息,导致评估虚高。三种典型:一是预处理泄漏,在全量数据上做标准化或特征选择;二是过采样泄漏,划分前对全量数据做 SMOTE;三是时间泄漏,用未来数据预测过去,或特征中混入标签发生后才产生的字段。检测方法是打乱标签重训,若指标仍显著高于随机水平则存在泄漏。
11.2 算法对比
Q6:XGBoost 与 GBDT 的区别?
GBDT 是框架思想:串行训练树,每棵树拟合前一轮的负梯度。XGBoost 是它的工程化改进:目标函数用二阶泰勒展开(引入一阶与二阶导数信息),加入显式的正则项控制树复杂度,支持列采样与行采样、缺失值自动处理、并行化的特征分裂点查找、内置交叉验证与早停。精度与速度都优于朴素 GBDT。
Q7:LightGBM 相比 XGBoost 快在哪里?代价是什么?
三点加速:一是直方图算法,把连续特征离散成桶,分裂点查找从遍历样本变为遍历桶;二是叶子优先(Leaf-wise)生长,同等叶子数下损失下降更快;三是单边梯度采样(GOSS)与互斥特征捆绑(EFB),减少样本与特征数。代价是 Leaf-wise 在数据量小时极易过拟合,必须调大 min_data_in_leaf;且对类别特征的处理需要额外正则。
Q8:随机森林与 GBDT 的核心差异?
随机森林是 Bagging:并行训练多棵独立的深树,靠平均降低方差,每棵树偏差低方差高。GBDT 是 Boosting:串行训练多棵浅树,每棵树拟合残差或梯度,靠累加降低偏差,单棵树偏差高方差低。因此随机森林对参数不敏感、不易过拟合,GBDT 精度上限更高但更依赖调参。
Q9:为什么树模型不需要特征缩放,而 SVM 和神经网络需要?
树模型的分裂只依赖特征值的相对顺序,单调变换不改变分裂点,所以缩放无影响。SVM 依赖距离计算与核函数,量纲大的特征会主导距离;神经网络依赖梯度下降,未归一化会导致不同参数的梯度尺度差异巨大,损失曲面呈狭长形,收敛极慢甚至不收敛。
Q10:处理类别不平衡有哪些方法?优先选哪个?
按代价从低到高:调整决策阈值(最省事,不重训)、设类权重(class_weight='balanced')、重采样(过采样 SMOTE、欠采样)、换损失函数(Focal Loss)、异常检测视角重构问题。优先选阈值调整与类权重,因为它们不改变数据分布、不引入合成样本的偏差。评估指标必须从 accuracy 换成 PR-AUC、F1 或召回率。
11.3 参数与调参
Q11:逻辑回归的 C 与 Ridge 的 alpha 是什么关系?
互为倒数,C = 1/alpha。C 是正则强度的倒数,C 越大正则越弱、越易过拟合;alpha 是正则强度本身,alpha 越大正则越强、越易欠拟合。这是面试中常见的"方向陷阱",写代码时把两者的调参方向搞反会导致完全错误的结论。
Q12:XGBoost 的 min_child_weight 是什么?什么时候调它?
它是叶子节点所需的最小样本权重和。回归任务中权重为 1,等价于最小样本数;分类任务中权重是二阶导(hessian),对概率接近 0 或 1 的样本权重很小。它是最有效的抗过拟合参数之一。当验证集指标明显低于训练集、且树的叶子过多时,优先调大它。
Q13:LightGBM 中 bagging_fraction 设了但没效果,为什么?
因为 bagging_freq 默认为 0,表示不做 bagging,此时 bagging_fraction 完全失效。必须同时设 bagging_freq 为大于 0 的整数(如 1 表示每轮都采样)。这是 LightGBM 最常见的配置疏漏,也是面试常考的细节题。
Q14:学习率与树的数量(或训练轮数)是什么关系?怎么联合调?
反向耦合:学习率越小,需要越多轮才能收敛,但泛化通常更好;学习率越大,收敛快但易过拟合。正确做法是固定一个中等学习率(如 0.1)用早停确定轮数,调完其他参数后再把学习率降到 0.02 到 0.05 重新确定轮数。切忌同时大幅调整二者,否则无法归因。
Q15:为什么 SVM 的 C 和 gamma 必须联合搜索?
C 控制对误分类的容忍度,gamma 控制单个样本的影响半径,二者共同决定决策边界的弯曲程度与容错能力。固定一个调另一个会得到误导性结论:例如在 gamma 很大(边界极弯曲)时,无论 C 怎么调都容易过拟合,于是误判 C 无效。必须做二维网格或随机搜索。
Q16:KNN 的 k 怎么选?k 太小和太大分别有什么问题?
用交叉验证扫描 k 的取值,取验证误差最小的点,通常落在 5 到 20 之间。k 太小(如 1)时决策边界贴合噪声,方差极大;k 太大时邻域覆盖过广,边界过度平滑,退化为接近多数类的预测,偏差大。k 取奇数可避免二分类平票。
Q17:t-SNE 的 perplexity 是什么?调错了会怎样?
perplexity 可以理解为每个点的有效近邻数,反映对局部与全局结构的权衡。调小(如 5)突出局部团簇,但全局结构失真;调大(如 50)保留更多全局关系,但局部细节糊在一起。它必须小于样本数的约三分之一,否则算法会报警。另外要记住 t-SNE 的坐标与簇间距离没有物理意义。
11.4 深度学习训练
Q18:为什么 Adam 之后要提出 AdamW?
Adam 把 L2 正则项混入梯度,而梯度会被二阶矩估计归一化,导致等效正则强度随参数尺度自适应变化,不可控;且与动量耦合。AdamW 把权重衰减从梯度更新中解耦,直接对参数做衰减,正则强度恒定可控,在大模型训练上泛化更好。这是目前所有大模型的标准配置。
Q19:BatchNorm 和 LayerNorm 的区别?为什么 Transformer 用 LayerNorm?
BatchNorm 在 batch 维度上对每个特征归一化,依赖 batch 统计量,batch 小时不稳定,且训练与推理行为不同。LayerNorm 在单个样本的特征维度上归一化,与 batch 大小无关,训练推理行为一致,适合变长序列。Transformer 的序列长度可变、batch 通常较小,因此用 LayerNorm(现代模型多用其简化版 RMSNorm)。
Q20:为什么 Transformer 需要 warmup?
训练初期参数随机,梯度方向不一致,且 LayerNorm 与残差结构使得深层梯度尺度波动大。若直接使用目标学习率,前几步的大更新会破坏参数分布,模型可能陷入难以恢复的坏区域。warmup 用几百到几千步把学习率从接近 0 线性升到目标值,让模型先进入稳定区域。Post-LN 结构对此尤其敏感。
Q21:梯度消失和梯度爆炸怎么诊断和解决?
诊断:逐层打印梯度范数,观察从输出到输入的衰减或放大倍数。消失表现为深层梯度小于 1e-6,爆炸表现为突然升到 1e3 以上或 loss 变 NaN。解决消失:换非饱和激活、加残差、加归一化、用合适初始化、RNN 换 LSTM。解决爆炸:梯度裁剪(首选,保持方向不变)、降学习率、用 bf16、检查损失函数的数值稳定性。
Q22:batch size 与学习率有什么关系?
经验上有线性缩放(batch 增 k 倍、学习率增 k 倍)与平方根缩放(增 √k 倍)两种法则。线性缩放适合小 batch 区间,大 batch 时通常用平方根缩放并配 warmup,否则初期易发散。另外大 batch 会降低梯度噪声,倾向收敛到尖锐极小值,泛化可能变差,需要更长的训练或分层自适应优化器补偿。
Q23:dropout 在训练和推理时分别怎么工作?
训练时以概率 p 随机把神经元输出置零,并对保留的神经元除以 (1-p) 做缩放,使期望不变(inverted dropout)。推理时全部神经元参与,不做任何缩放,等价于对指数级多个子网络取平均。因此推理前必须调用 model.eval(),否则结果错误且不稳定,这是新手最常见的线上事故之一。
Q24:为什么 weight decay 通常不施加于偏置和归一化层参数?
偏置的作用是平移激活,归一化层的 gamma 与 beta 控制缩放与平移,它们不参与特征组合,对其做衰减会扭曲模型的表达能力而不带来正则收益。实践中把它们排除在 weight decay 之外通常能带来小幅但稳定的精度提升,这在训练大模型时是标准做法。
Q25:早停的 patience 怎么设?设太小会怎样?
patience 建议设为总训练轮数的 5% 到 10%,且不低于 10 轮。设太小会早停过早,在指标仍能提升时就终止训练,表现为"恢复训练后还能继续涨"。此外验证集太小导致指标噪声大时,也容易被噪声触发早停,此时应增大验证集、用平滑指标或提高 min_delta。
11.5 大模型微调
Q26:LoRA 的原理是什么?为什么能起作用?
LoRA 假设微调带来的权重变化是低秩的,因此把权重更新分解为两个低秩矩阵的乘积 B 乘 A(B 为 d 乘 r,A 为 r 乘 k,r 远小于 d 和 k),冻结原权重只训练 A 与 B。可训练参数减少到原来的百分之几,显存与存储大幅下降。它起作用的原因是对下游任务而言,所需的适配确实集中在低维子空间。推理时可把 BA 加回原权重,无额外延迟。
Q27:LoRA 的 r 和 alpha 怎么选?只调 r 够吗?
r 控制低秩矩阵的秩即可表达能力,常用 8 到 32,任务越复杂、数据越多可越大。alpha 是缩放系数,实际缩放为 alpha 除以 r。关键在于二者的比例而非绝对值:比例过大会放大 LoRA 分支的影响,等效于加大该分支学习率,易训练不稳;比例过小则学不动。常用做法是固定 alpha 为 16 或 32,再调 r,或让 alpha 等于 2r。
Q28:QLoRA 相比 LoRA 牺牲了什么?
三点牺牲:一是速度,4bit 反量化带来额外开销,训练慢 30% 到 50%;二是精度,量化误差会带来轻微效果损失,尤其对数值敏感的任务;三是实现复杂度,需要 bitsandbytes 且对某些算子兼容性差。收益是显存降至约四分之一,使单卡微调 7B 甚至 13B 成为可能。显存足够时优先用 bf16 LoRA。
Q29:SFT 训练几轮合适?训太多会怎样?
通常 1 到 3 轮。SFT 数据量小、格式单一,超过 3 轮几乎必然过拟合,表现为:通用能力下降(灾难性遗忘)、输出长度异常(偏长或偏短)、开始机械复述训练数据、对未见指令的遵循能力退化。判断依据是同时监控领域测试集与通用能力基准,一旦通用能力下降超过 3 个百分点就应停止。
Q30:DPO 的 beta 是什么?调大调小分别有什么后果?
beta 控制对参考模型的偏离惩罚强度,即 KL 约束的隐式强度。调大时模型更保守、更贴近参考模型,对齐幅度小但输出稳定;调小时模型更激进,容易过度优化偏好信号,出现语言退化、重复、模式崩塌、回复长度暴涨。常用 0.1 到 0.5,数据噪声大时取上限。
11.6 场景与陷阱题
Q31:线下 AUC 0.98,线上只有 0.65,怎么排查?
按顺序查四件事。第一查泄漏:打乱标签重训,若指标仍远高于随机水平则存在泄漏;检查 Top 特征是否有"事后才知道"的字段。第二查分布:对比训练集与线上数据的特征分布,用 PSI 或 KL 散度量化,PSI 超过 0.2 说明漂移严重。第三查管道一致性:线上特征计算逻辑是否与离线一致,是否存在时间窗口、聚合口径的差异。第四查评估口径:线上的正负样本定义、观察窗口、样本延迟回收是否与离线相同。
Q32:验证集指标比训练集还高,正常吗?
在小数据集、强数据增强、或用 dropout 与 BN 的情况下可能出现,属正常现象:训练时的指标是在带正则与增强的状态下算的,而验证时正则关闭、增强不作,模型处于"完整能力"状态。但如果验证指标持续显著高于训练指标,要警惕数据泄漏或验证集过小导致的高方差。
Q33:模型效果怎么调都上不去,你的下一步是什么?
先判断瓶颈归属。第一,检查标签质量:抽样复核高损失样本,统计标注错误率,若超过 5% 优先清洗。第二,检查特征:是否缺少关键业务字段、是否存在可构造的交互特征,特征工程的收益通常远大于调参。第三,看学习曲线判断是数据不足还是容量问题。第四,确认评估指标是否与业务目标一致,可能指标选错了。调参永远排在数据与特征之后。
Q34:为什么样本量少的时候优先微调预训练模型而不是从零训练?
从零训练需要海量数据来学习通用的特征表示,小样本下模型只能记住训练集,泛化极差。预训练模型已经在大规模数据上学到了通用表示,微调只是在其上做小幅调整,所需样本量可降低一到两个数量级。此外小样本场景更应优先考虑提示工程、特征工程加线性模型、或传统机器学习方法,而不是强行上深度模型。
Q35:如何判断一个提升是真的提升而不是噪声?
三个手段。一是多随机种子重复实验,取均值与标准差,提升幅度必须显著大于标准差;二是交叉验证给出置信区间,用配对检验(如 Wilcoxon 符号秩检验)判断差异显著性;三是留出从未用于任何决策的 holdout 测试集做最终确认。经验上分类任务准确率提升小于 1 个百分点、AUC 提升小于 0.005 时,很可能只是噪声。
Q36:模型训练很慢,你会从哪些方面优化?
分四层。数据层:检查 DataLoader 的 num_workers 与 pin_memory,确认 GPU 不是在空等数据;用预取与缓存减少 IO。模型层:混合精度(bf16 优先)、梯度累积替代大 batch、梯度检查点、减少不必要的层。计算层:算子融合、FlashAttention、编译优化(torch.compile)。工程层:多卡并行策略(DDP 优于 DP)、增大 batch 提升 GPU 利用率。
Q37:为什么训练损失能降到很低但验证损失不降?该加正则还是加数据?
这是典型过拟合,加数据与加正则都有效,但优先级不同。先看学习曲线:如果加入更多训练数据后验证指标仍明显上升,说明是数据不足,加数据收益最大;如果验证曲线在现有数据量下已经走平,说明信息量饱和,此时加正则或降容量更有效。实践中先做数据增强(成本低于标注),再考虑加正则。
Q38:介绍一下你调参的完整流程。
按五步走。第一,用默认参数或简单模型建立可信基线,记录指标与配置。第二,定位瓶颈:通过训练与验证指标差距判断是欠拟合、过拟合还是数据问题。第三,按敏感度排序参数,只动前三个(如树模型先动容量与正则参数,神经网络先动学习率)。第四,单变量跨数量级扫描,画出敏感度曲线,避免同时改多个参数导致无法归因。第五,在最优区间内做联合搜索,用交叉验证确认并给出置信区间,最后在 holdout 上做一次最终验证。
Q39:类别特征怎么处理?不同模型下的最优做法有何不同?
树模型:可直接用 LightGBM 与 CatBoost 的原生类别支持,走目标统计编码并配套正则(cat_smooth、cat_l2),CatBoost 的有序目标编码能有效避免泄漏。线性模型:one-hot 编码,高基数时改目标编码或哈希编码。神经网络:用 embedding 层学习低维表示。通用注意两点:目标编码必须做折外(out-of-fold)统计以防泄漏;高基数类别要设最小频次阈值,把低频类归为"其他"。
Q40:如果让你给一个新人讲清楚"怎么判断训练成功了",你会怎么说?
三层检验。第一层看优化:训练损失是否稳定收敛、梯度是否健康,这决定模型有没有学到东西。第二层看泛化:训练与验证指标的差距是否收敛到可接受范围(分类 5 个百分点内)、交叉验证是否稳定、是否超越了简单基线。第三层看业务:指标提升是否转化为业务价值、概率是否校准、结果是否可复现。三层都过才叫成功,只看验证集涨了 0.5 个点就宣布成功是最常见的误判。
第十二章 实战课题与学习成果自测
前十一章解决"知道",这一章解决"会不会"。全章给出三十个可独立完成的实战课题,每个课题都配好了数据集、任务定义、评估指标、关键参数、通关判据四件套,你只需要搭一次环境,然后按顺序做下来。
12.1 使用规则
先说四条纪律,否则三十个课题很容易变成"收藏夹里跑过一遍"。
第一,判据是参考线,不是承诺。每个课题给的指标数字来自公开排行榜的中位水平或该数据集的常见结果,用于判断"你是否真的做对了",不是精度上限。达不到先怀疑流程有 bug,而不是怀疑自己不行。
第二,每个课题必须留下三份产物:可复现的配置文件、一张训练或验证曲线图、一份 200 字以上的复盘。只交代码不算完成。
第三,先跑通基线再看精度。所有课题的第一步都是拿到一个丑陋但能跑的基线(逻辑回归、默认参数、历史均值),然后证明你的复杂方案比它好。跳过基线的人,永远不知道自己是在优化还是在自我安慰。
第四,难度分级只影响顺序,不影响取舍。入门题(难度一星)建议全部做完,进阶题(二星)按你的方向挑一半,挑战题(三星)做一到两个即可。三十个全做完不是目标。
第五,每个课题都配了一份可运行的参考脚本,放在 code/ 目录下,文件名形如 1-1_california_housing.py,编号与课题一一对应。脚本的设计原则是"能跑、能改、能对照":优先用内置或可公开下载的数据集,取不到时自动降级为结构相同的合成数据并在终端打印提示,所以你 clone 下来就能跑通,不会卡在数据获取上。参考脚本不是标准答案——它给出的是一份"参数放在哪里、对照实验怎么做"的骨架,你要做的是改它、跑它、看结果怎么变。
12.2 环境搭建(搭一次,三十个课题复用)
这一节的目标是让三十个课题共用同一套环境与目录,避免每个课题重装一次依赖。
12.2.1 三档环境
不要把所有依赖装进一个环境。深度学习的 CUDA 版本冲突会把整个环境炸掉,分档是唯一可靠的隔离方式。
| 档位 | 用途 | Python | 关键依赖 | 显存要求 |
|---|---|---|---|---|
| ml | 传统机器学习课题(1 到 9 组) | 3.10 | scikit-learn、xgboost、lightgbm、catboost、imbalanced-learn、shap | 无 |
| dl | 深度学习课题(10 到 14 组) | 3.10 | torch、torchvision、pytorch-lightning、timm、einops | 8GB 起 |
| llm | 大模型微调(15 组) | 3.10 | transformers、peft、trl、accelerate、bitsandbytes、datasets | 16GB 起(QLoRA) |
创建命令(Windows 与 Linux 通用,只改 CUDA 版本号):
conda create -n ml python=3.10 -y
conda create -n dl python=3.10 -y
conda create -n llm python=3.10 -y
conda activate ml
pip install scikit-learn==1.3.2 xgboost==2.0.3 lightgbm==4.3.0 catboost==1.2.3
pip install imbalanced-learn==0.12.0 shap==0.44.0 pandas==2.1.4 matplotlib==3.8.2 joblib==1.3.2
conda activate dl
pip install torch==2.2.1 torchvision==0.17.1 --index-url https://download.pytorch.org/whl/cu121
pip install pytorch-lightning==2.2.0 timm==0.9.16 einops==0.7.0
conda activate llm
pip install transformers==4.38.2 peft==0.9.0 trl==0.7.11 accelerate==0.27.2
pip install bitsandbytes==0.42.0 datasets==2.18.0 sentencepiece==0.1.99
版本号不是随手写的:scikit-learn 1.3 与 1.4 的部分 API 行为有差异,peft 0.9 与 trl 0.7 是经过验证能跑通 LoRA SFT 的组合。先按这个装,跑通后再升级。
12.2.2 目录约定
三十个课题如果各自一个随手命名的文件夹,两周后你连自己跑过什么都没印象。统一成下面的结构,所有课题共用。
study/
├── envs/ # 环境导出文件
├── data/ # 原始数据,只读,永不修改
│ ├── raw/ # 下载的原始文件
│ └── interim/ # 清洗后的中间产物
├── src/
│ ├── common/ # 复用代码:评估、日志、种子、绘图
│ └── p01_housing/ # 一个课题一个目录
├── outputs/
│ ├── p01_housing/ # 模型文件、预测结果
│ └── logs/ # 实验记录(csv 或 mlflow)
└── reports/ # 每个课题一份复盘 md
12.2.3 通用工具函数(三个函数解决八成重复劳动)
每个课题都会写"固定种子、算指标、存实验记录"这三件事。把它固化成 src/common/utils.py,三十个课题共用同一套,实验之间才可比。
# src/common/utils.py
import os, random, json, numpy as np, torch
def set_seed(seed=42):
random.seed(seed); np.random.seed(seed)
os.environ["PYTHONHASHSEED"] = str(seed)
torch.manual_seed(seed); torch.cuda.manual_seed_all(seed)
torch.backends.cudnn.deterministic = True
torch.backends.cudnn.benchmark = False
def log_exp(path, record: dict):
"""一行一条实验记录,字段不定,追加写入"""
with open(path, "a", encoding="utf-8") as f:
f.write(json.dumps(record, ensure_ascii=False) + "\n")
def cls_metrics(y_true, y_prob, threshold=0.5):
from sklearn.metrics import roc_auc_score, precision_score, recall_score, f1_score
y_pred = (y_prob >= threshold).astype(int)
return {"auc": round(roc_auc_score(y_true, y_prob), 4),
"precision": round(precision_score(y_true, y_pred, zero_division=0), 4),
"recall": round(recall_score(y_true, y_pred, zero_division=0), 4),
"f1": round(f1_score(y_true, y_pred, zero_division=0), 4)}
12.2.4 数据合规底线
课题涉及医学影像(肺炎 X 光)、用户行为(零售交易)时,必须遵守两条:只用公开已脱敏数据集,不下载任何含真实身份信息的原始数据;成果不对外发布含样本图像的截图,示例图只截取与个人身份无关的部分。这一条不是形式要求,越过它的代价远高于课题本身的收益。
12.3 通用实训流程(七个步骤,每个课题都走一遍)
课题之间数据集不同,但流程完全一致。把下面这张表贴在屏幕上,每个课题照着走。
| 步骤 | 动作 | 必须留下的产物 | 常见错误 |
|---|---|---|---|
| 1 数据审计 | 看行列数、缺失率、类别分布、重复样本、可疑字段 | 一页数据体检表 | 直接开始建模,两周后发现标签有错 |
| 2 建立基线 | 用最简方案跑通全流程 | 基线指标 + 基线配置 | 基线用复杂模型,后面无法证明改进 |
| 3 特征或结构 | 加特征、改网络结构、做数据增强 | 对照实验记录 | 同时改三处,指标涨了但不知原因 |
| 4 调参 | 按第十章优先级,单变量跨数量级扫描 | 每个参数的敏感度曲线 | 在验证集上反复试到满意,实质过拟合 |
| 5 体检 | 对照第八章 8.6 的十项体检表逐条打勾 | 体检表(全部通过) | 只看指标,不看梯度与曲线 |
| 6 误差分析 | 抽样看至少 50 个错误样本并归类 | 错误类型分布表 | 跳过,于是错过了最大的提升来源 |
| 7 复盘 | 写清"做了什么、结论是什么、下次改什么" | 200 字以上复盘 | 只记指标,不记判断 |
步骤 6 是三十个课题里最容易被跳过、也最容易带来惊喜的一步。多数时候你会发现提升空间在数据而不在模型:某类样本标注错了、某字段在特定群体里系统性缺失、文本被截断在关键句之前。
12.4 传统机器学习课题(九组,每组两题)
九组覆盖线性模型到降维的全部主力算法,全部可在 CPU 上完成,不需要显卡。建议按顺序做,因为后面的课题会用到前面的特征工程与评估习惯。
12.4.1 线性回归与正则化
这一组训练的是"用一个可解释的模型把话说清楚"的能力,而不是刷分。共线性诊断与系数解读比指标更重要。
| 项目 | 内容 |
|---|---|
| 课题 1-1 | 加州房价预测与共线性诊断 |
| 数据集 | sklearn.datasets.fetch_california_housing(),20640 条、8 个数值特征,目标为街区房价中位数(单位 10 万美元),无缺失;首次运行自动下载约 1MB,取不到时脚本降级为同结构合成表 |
| 任务与指标 | 回归,主指标 RMSE、辅以 R²。参考线:RMSE ≤ 0.55 |
| 关键参数 | alpha(对数网格 1e-4 到 1e2)、fit_intercept、PolynomialFeatures(degree=2)、solver |
| 通关判据 | Ridge 的 RMSE 比 OLS 低至少 0.5%;用 VIF 找出至少 2 对强共线特征;8 个系数的符号全部符合地理与经济学常识 |
| 加分挑战 | 加坐标交互项把 RMSE 压到 0.50 以下;用 Lasso 把特征压到 4 个以内且 RMSE 退化小于 2% |
| 建议耗时 | 3 到 4 小时(难度 1 星,对应第三、四章) |
参考实现:code/1-1_california_housing.py
"""课题 1-1 加州房价预测与共线性诊断
目标:用 Ridge/Lasso 把 RMSE 压到 0.55 以下,并用 VIF 找出至少 2 对强共线特征,
最后确认 8 个系数的符号符合地理与经济学常识。
依赖:scikit-learn、numpy、pandas(数据由 sklearn 自动下载,约 1MB)
"""
import numpy as np
import pandas as pd
from sklearn.datasets import fetch_california_housing
from sklearn.linear_model import LassoCV, LinearRegression, RidgeCV
from sklearn.metrics import mean_squared_error, r2_score
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
SEED = 42
def vif_table(X: pd.DataFrame) -> pd.DataFrame:
"""VIF_j = 1 / (1 - R2_j),R2_j 用其余所有特征回归第 j 个特征得到。"""
rows = []
for col in X.columns:
others = X.drop(columns=col)
r2 = LinearRegression().fit(others, X[col]).score(others, X[col])
rows.append({"feature": col, "VIF": 1.0 / max(1e-9, 1.0 - r2)})
return pd.DataFrame(rows).sort_values("VIF", ascending=False)
def rmse(y_true, y_pred) -> float:
return float(np.sqrt(mean_squared_error(y_true, y_pred)))
def load_frame() -> pd.DataFrame:
"""优先用官方数据;离线环境下用同列名的合成表,保证诊断流程仍可跑通。"""
try:
return fetch_california_housing(as_frame=True).frame
except Exception as exc:
print(f"[降级] 无法下载加州房价数据({type(exc).__name__}),改用合成表")
rng = np.random.default_rng(SEED)
n = 8000
med_inc = rng.lognormal(1.0, 0.4, n)
ave_rooms = rng.normal(5.4, 1.5, n).clip(2, 12)
df = pd.DataFrame({
"MedInc": med_inc,
"HouseAge": rng.integers(1, 52, n).astype(float),
"AveRooms": ave_rooms,
# 与 AveRooms 强共线:这是真实数据里 VIF 高的主要原因
"AveBedrms": ave_rooms * 0.2 + rng.normal(0, 0.05, n),
"Population": rng.lognormal(8.0, 0.6, n),
"AveOccup": rng.lognormal(1.0, 0.3, n),
"Latitude": rng.uniform(32, 42, n),
"Longitude": rng.uniform(-124, -114, n),
})
df["MedHouseVal"] = (0.45 * med_inc + 0.05 * df["HouseAge"] / 10
+ rng.normal(0, 0.5, n)).clip(0.15, 5.0)
return df
df = load_frame()
# 人为构造两个派生特征,用来演示"看似增强、实则制造共线"的典型情形
df["RoomsPerPerson"] = df["AveRooms"] / df["AveOccup"]
df["BedroomsRatio"] = df["AveBedrms"] / df["AveRooms"]
X = df.drop(columns="MedHouseVal")
y = df["MedHouseVal"]
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.2, random_state=SEED)
# 基线:不做任何处理的最小二乘
ols = make_pipeline(StandardScaler(), LinearRegression()).fit(Xtr, ytr)
print(f"[基线 OLS ] RMSE={rmse(yte, ols.predict(Xte)):.4f} R2={r2_score(yte, ols.predict(Xte)):.4f}")
# 调参点 1:alpha 用对数网格交叉验证选取,不要手填
alphas = np.logspace(-4, 2, 25)
ridge = make_pipeline(StandardScaler(), RidgeCV(alphas=alphas, cv=5)).fit(Xtr, ytr)
print(f"[Ridge ] RMSE={rmse(yte, ridge.predict(Xte)):.4f} best_alpha={ridge[-1].alpha_:.4g}")
# 调参点 2:Lasso 的 alpha 决定稀疏度,想让特征更少就整体上移网格
lasso = make_pipeline(StandardScaler(), LassoCV(alphas=alphas, cv=5, max_iter=20000)).fit(Xtr, ytr)
print(f"[Lasso ] RMSE={rmse(yte, lasso.predict(Xte)):.4f} best_alpha={lasso[-1].alpha_:.4g} "
f"非零系数={int((np.abs(lasso[-1].coef_) > 1e-8).sum())}/{X.shape[1]}")
# 共线性诊断:VIF > 10 视为强共线,> 5 需要关注
print("\n--- VIF 诊断(>10 强共线)---")
print(vif_table(Xtr).to_string(index=False, float_format=lambda v: f"{v:.2f}"))
# 系数解读:标准化后系数的符号就是"相关性方向"
coef = pd.Series(ridge[-1].coef_, index=X.columns).sort_values()
print("\n--- 标准化系数(符号须符合常识:经度负、收入正)---")
print(coef.to_string(float_format=lambda v: f"{v:+.4f}"))
score = rmse(yte, ridge.predict(Xte))
print("\n判据对照:")
print(f" RMSE={score:.4f} {'达到' if score < 0.55 else '未达到'}参考线 0.55"
"(真实数据可达;合成数据不必强求)")
print(f" VIF 最高特征 = {vif_table(Xtr).iloc[0]['feature']},"
f"值 {vif_table(Xtr).iloc[0]['VIF']:.1f},{'存在' if vif_table(Xtr).iloc[0]['VIF'] > 10 else '未见'}强共线")
| 项目 | 内容 |
|---|---|
| 课题 1-2 | 二手车价格预测(结构化回归全流程) |
| 数据集 | Kaggle Playground Series S4E9 "Regression of Used Car Prices",约 18.8 万行、13 列,含品牌、年份、里程、变速箱等混合类型特征 |
| 任务与指标 | 回归,主指标 RMSLE。参考线:公开验证集 RMSLE ≤ 0.57 |
| 关键参数 | 目标变换 log1p、LightGBM 的 reg_lambda 与 min_data_in_leaf、类别编码方式(原生类别 vs 目标编码) |
| 通关判据 | 完成"目标变换 vs 不做变换"的对照实验并解释差异;缺失值与异常里程的处理有书面记录;提交文件列名与格式正确 |
| 加分挑战 | 用 5 折折外预测做 LightGBM + XGBoost + CatBoost 的加权融合,RMSLE 再降 3% |
| 建议耗时 | 6 到 8 小时(难度 2 星,对应第三、四章) |
参考实现:code/1-2_used_car_price.py
"""课题 1-2 二手车价格预测(结构化回归全流程)
目标:RMSLE 打到 0.57 以下,并完成"目标变换 vs 不做变换"的对照实验。
数据:Kaggle Playground S4E9,把 train.csv 放到 data/s4e9/train.csv;
没有数据时脚本自动生成同结构的合成数据,保证流程可以先跑通。
依赖:scikit-learn、pandas、numpy(装了 lightgbm 会自动启用)
"""
from pathlib import Path
import numpy as np
import pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.ensemble import HistGradientBoostingRegressor
from sklearn.metrics import mean_squared_error
from sklearn.model_selection import KFold
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OrdinalEncoder
SEED = 42
DATA = Path("data/s4e9/train.csv")
def load_frame() -> pd.DataFrame:
"""有真实数据就用真实的,没有就造一份同列名的合成数据跑通管线。"""
if DATA.exists():
return pd.read_csv(DATA)
rng = np.random.default_rng(SEED)
n = 20000
brand = rng.choice(["Toyota", "Honda", "BMW", "Audi", "Ford"], n)
year = rng.integers(2000, 2024, n)
mileage = rng.integers(5_000, 250_000, n)
trans = rng.choice(["Manual", "Automatic"], n)
fuel = rng.choice(["Petrol", "Diesel", "Hybrid"], n)
price = (30000 - (2024 - year) * 900 - mileage * 0.05
+ (brand == "BMW") * 6000 + (brand == "Audi") * 5000 + rng.normal(0, 1500, n))
return pd.DataFrame({"id": np.arange(n), "brand": brand, "model_year": year,
"mileage": np.maximum(mileage, 500), "transmission": trans,
"fuel_type": fuel, "price": np.maximum(price, 500)})
df = load_frame()
num_cols = ["model_year", "mileage"]
cat_cols = [c for c in ["brand", "transmission", "fuel_type"] if c in df.columns]
X, y = df[num_cols + cat_cols], df["price"].astype(float)
# 调参点 1:类别编码。树模型用序数编码即可,线性模型必须独热
pre = ColumnTransformer([
("cat", OrdinalEncoder(handle_unknown="use_encoded_value", unknown_value=-1), cat_cols),
], remainder="passthrough")
# 调参点 2:学习率与叶子数是一对连体参数,learning_rate 减半通常要把 max_leaf_nodes 增大
model = HistGradientBoostingRegressor(
learning_rate=0.05, # 0.02 更准更慢,0.1 更快更糙
max_leaf_nodes=63, # 数据量越大越该往上走(31/63/127)
min_samples_leaf=20, # 抗噪主力,过拟合先动它
l2_regularization=1.0,
early_stopping=True, # 留出 10% 做早停,避免手填 n_estimators
validation_fraction=0.1,
random_state=SEED,
)
pipe = Pipeline([("pre", pre), ("model", model)])
def rmsle(y_true, y_pred) -> float:
return float(np.sqrt(mean_squared_error(np.log1p(y_true), np.log1p(np.maximum(y_pred, 0)))))
# 对照实验:同一套参数,只改目标是否做 log1p 变换
for tag, transform in [("原始目标", lambda v: v), ("log1p 目标", np.log1p)]:
oof = np.zeros(len(X))
for tr, va in KFold(5, shuffle=True, random_state=SEED).split(X):
fit_y = transform(y.iloc[tr])
pipe.fit(X.iloc[tr], fit_y)
pred = pipe.predict(X.iloc[va])
oof[va] = np.expm1(pred) if tag.startswith("log1p") else pred
print(f"[{tag:9s}] OOF RMSLE = {rmsle(y.values, oof):.4f}")
print("\n结论模板:log1p 变换把长尾价格压成近正态,RMSLE 通常降 3% 到 8%;"
"若两者接近,说明价格分布本身不偏,变换无收益——这个判断要写进复盘。")
12.4.2 逻辑回归
这一组的关键词是"不平衡"与"可解释"。两个课题都会逼你放弃 accuracy,改用能反映业务代价的指标。
| 项目 | 内容 |
|---|---|
| 课题 2-1 | 信用卡欺诈检测(极度不平衡) |
| 数据集 | Kaggle mlg-ulb/creditcardfraud,28.4 万笔交易、492 笔欺诈(正类占 0.172%),特征为 PCA 脱敏后的 V1 到 V28 加 Time、Amount |
| 任务与指标 | 二分类,主指标 PR-AUC,辅以"精确率固定 0.9 时的召回率"。参考线:PR-AUC ≥ 0.75 |
| 关键参数 | class_weight='balanced'、C、solver='saga'、决策阈值 |
| 通关判据 | PR-AUC ≥ 0.75;精确率 0.9 时召回 ≥ 0.75;能用实验数据说明"准确率 99.8% 但召回为 0"的假成功 |
| 加分挑战 | 对比类权重与 SMOTE 两种方案,画出两条 PR 曲线并说明谁更适合本场景 |
| 建议耗时 | 4 小时(难度 1 星,对应第三章 3.3、第四章 4.2) |
参考实现:code/2-1_credit_fraud.py
"""课题 2-1 信用卡欺诈检测(极不平衡二分类)
目标:正类占比约 0.17% 时,用 PR-AUC 而不是准确率评估;扫出业务可接受的阈值。
数据:Kaggle creditcardfraud 的 creditcard.csv 放到 data/creditcard/ 下;
没有就用 make_classification 造 0.17% 的正类。
依赖:scikit-learn、pandas、numpy(可选 imbalanced-learn 做 SMOTE)
"""
from pathlib import Path
import numpy as np
import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import (average_precision_score, confusion_matrix, f1_score,
precision_recall_curve, roc_auc_score)
from sklearn.model_selection import train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
SEED = 42
DATA = Path("data/creditcard/creditcard.csv")
NEG_RATIO = 0.0017 # 真实数据的正类比例,造数据时保持一致
def load_data():
if DATA.exists():
df = pd.read_csv(DATA)
return df.drop(columns=["Time"]), df["Class"].values
# 合成时让正类在前 6 维有明显平移,否则 0.17% 的样本量下模型几乎学不到信号,
# 会得到一个"PR-AUC 极低、误报上万"的假结论,失去教学意义
rng = np.random.default_rng(SEED)
n = 60000
X = rng.normal(0, 1, (n, 30)).astype("float32")
y = (rng.random(n) < NEG_RATIO).astype(int)
X[y == 1, :6] += rng.normal(2.2, 1.0, (int(y.sum()), 6))
return pd.DataFrame(X, columns=[f"V{i}" for i in range(30)]), y
X, y = load_data()
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.3, stratify=y, random_state=SEED)
print(f"训练集正类 {ytr.sum()} / {len(ytr)} = {ytr.mean():.4%}")
# 关键:类别权重必须交给模型,而不是靠“平衡采样后忘了还原概率”
# L2 是 LogisticRegression 的默认正则,无需显式传 penalty(新版 sklearn 已弃用该参数)
base = dict(solver="liblinear", max_iter=1000, random_state=SEED)
for tag, kw in [("无权重(基线)", dict(class_weight=None)),
("balanced 权重", dict(class_weight="balanced")),
("1:50 权重", dict(class_weight={0: 1, 1: 50}))]:
clf = make_pipeline(StandardScaler(), LogisticRegression(**base, **kw)).fit(Xtr, ytr)
prob = clf.predict_proba(Xte)[:, 1]
print(f"[{tag:14s}] PR-AUC={average_precision_score(yte, prob):.4f} "
f"ROC-AUC={roc_auc_score(yte, prob):.4f}")
# 调参点:阈值不是 0.5。按召回率下限反解阈值,这才是业务口径
clf = make_pipeline(StandardScaler(), LogisticRegression(**base, class_weight="balanced")).fit(Xtr, ytr)
prob = clf.predict_proba(Xte)[:, 1]
prec, rec, thr = precision_recall_curve(yte, prob)
print("\n--- 阈值 — 精确率 / 召回率 / F1 ---")
for target_recall in (0.80, 0.85, 0.90):
idx = int(np.argmin(np.abs(rec[:-1] - target_recall)))
t = thr[idx]
pred = (prob >= t).astype(int)
print(f"阈值={t:.3f} 召回={rec[idx]:.3f} 精确={prec[idx]:.3f} "
f"F1={f1_score(yte, pred):.3f} 误报数={(pred == 1).sum() - ((pred == 1) & (yte == 1)).sum()}")
best = np.argmax(np.where(rec[:-1] >= 0.85, prec[:-1], 0))
tn, fp, fn, tp = confusion_matrix(yte, (prob >= thr[best]).astype(int)).ravel()
print(f"\n选中阈值 {thr[best]:.3f} 的混淆矩阵:TP={tp} FP={fp} FN={fn} TN={tn}")
print("复盘要点:准确率此时会高达 99.8%,但它是个无效指标——必须写清为什么。")
| 项目 | 内容 |
|---|---|
| 课题 2-2 | 电信客户流失预测(业务可解释优先) |
| 数据集 | Kaggle blastchar/telco-customer-churn,7043 行、21 列,含合同类型、月费、在网时长等 |
| 任务与指标 | 二分类,主指标 AUC。参考线:AUC ≥ 0.84 |
| 关键参数 | C(注意方向)、penalty='l1' 做特征筛选、标准化、class_weight |
| 通关判据 | AUC ≥ 0.84;输出 Top5 流失驱动因素并写 3 条可执行业务建议;概率校准后 ECE < 0.05 |
| 加分挑战 | 结合"挽回成本"画利润曲线,给出最优干预阈值并说明与 0.5 阈值的差异 |
| 建议耗时 | 5 小时(难度 2 星,对应第四章 4.2、第八章 8.3) |
参考实现:code/2-2_telco_churn.py
"""课题 2-2 电信客户流失预测(可解释分类)
目标:ROC-AUC 达到 0.84 以上,并找出三个最有业务含义的流失驱动因素。
数据:IBM Telco 的 WA_Fn-UseC_-Telco-Customer-Churn.csv 放到 data/telco/;
没有就用合成表跑通管线。
依赖:scikit-learn、pandas、numpy
"""
from pathlib import Path
import numpy as np
import pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import (average_precision_score, classification_report,
roc_auc_score)
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler
SEED = 42
DATA = Path("data/telco/WA_Fn-UseC_-Telco-Customer-Churn.csv")
def load_frame() -> pd.DataFrame:
if DATA.exists():
df = pd.read_csv(DATA)
df["TotalCharges"] = pd.to_numeric(df["TotalCharges"], errors="coerce")
df["Churn"] = df["Churn"].map({"Yes": 1, "No": 0})
return df.dropna(subset=["TotalCharges"])
rng = np.random.default_rng(SEED)
n = 5000
tenure = rng.integers(1, 72, n)
contract = rng.choice(["Month-to-month", "One year", "Two year"], n, p=[0.55, 0.25, 0.2])
monthly = rng.uniform(20, 110, n)
logit = (1.4 * (contract == "Month-to-month") - 0.05 * tenure + 0.012 * monthly - 1.2)
churn = (rng.random(n) < 1 / (1 + np.exp(-logit))).astype(int)
return pd.DataFrame({"tenure": tenure, "Contract": contract, "MonthlyCharges": monthly,
"TotalCharges": monthly * tenure, "Churn": churn})
df = load_frame()
target = "Churn"
num_cols = [c for c in ["tenure", "MonthlyCharges", "TotalCharges"] if c in df.columns]
cat_cols = [c for c in ["Contract", "PaymentMethod", "InternetService"] if c in df.columns]
X, y = df[num_cols + cat_cols], df[target]
# 调参点 1:类别特征一律独热;handle_unknown="ignore" 防止线上出现新取值直接报错
pre = ColumnTransformer([
("num", StandardScaler(), num_cols),
("cat", OneHotEncoder(handle_unknown="ignore", drop="first"), cat_cols),
])
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.25, stratify=y, random_state=SEED)
# 调参点 2:C 是正则强度的倒数。小数据 + 多类别特征时,C 从 1 往下试到 0.01
for C in (1.0, 0.1, 0.01):
clf = Pipeline([("pre", pre),
("clf", LogisticRegression(C=C, class_weight="balanced",
max_iter=2000, random_state=SEED))]).fit(Xtr, ytr)
prob = clf.predict_proba(Xte)[:, 1]
print(f"[C={C:<5}] ROC-AUC={roc_auc_score(yte, prob):.4f} "
f"PR-AUC={average_precision_score(yte, prob):.4f}")
# 系数解读:OneHot 之后每个类别一个系数,正号代表提高流失概率
clf = Pipeline([("pre", pre), ("clf", LogisticRegression(C=0.1, class_weight="balanced",
max_iter=2000, random_state=SEED))])
clf.fit(Xtr, ytr)
names = clf.named_steps["pre"].get_feature_names_out()
coef = pd.Series(clf.named_steps["clf"].coef_[0], index=names).sort_values()
print("\n--- 最降低流失 / 最提高流失的各 5 项 ---")
print(pd.concat([coef.head(5), coef.tail(5)]).to_string(float_format=lambda v: f"{v:+.3f}"))
print("\n" + classification_report(yte, (clf.predict_proba(Xte)[:, 1] >= 0.5).astype(int),
target_names=["留存", "流失"], digits=3))
12.4.3 决策树与随机森林
单棵树的价值在解释,森林的价值在稳健。这两个课题要把"为什么这棵树这么分"讲到别人能听懂。
| 项目 | 内容 |
|---|---|
| 课题 3-1 | 泰坦尼克生存预测(可解释性训练) |
| 数据集 | Kaggle c/titanic,891 条训练集、418 条测试集、11 列 |
| 任务与指标 | 二分类,主指标 5 折交叉验证准确率。参考线:≥ 0.80 |
| 关键参数 | max_depth=3 到 6、min_samples_leaf、criterion(gini 与 entropy 对比)、ccp_alpha |
| 通关判据 | 画出深度为 3 的树,用中文完整复述每条决策规则;训练与验证准确率差 ≤ 5 个百分点;手算一次基尼不纯度并与 sklearn 输出对齐 |
| 加分挑战 | 用 ccp_alpha 做代价复杂度剪枝,画出"剪枝强度与准确率"曲线 |
| 建议耗时 | 4 小时(难度 1 星,对应第四章 4.4) |
参考实现:code/3-1_titanic_tree.py
"""课题 3-1 泰坦尼克生存预测(决策树可解释性)
目标:用决策树把"谁能活下来"讲清楚;对比 max_depth 从 2 到 10 的过拟合曲线。
数据:seaborn 内置 titanic(首次自动下载,约 100KB);离线环境用合成表兜底。
依赖:scikit-learn、pandas、numpy(可选 seaborn)
"""
import numpy as np
import pandas as pd
from sklearn.metrics import accuracy_score, roc_auc_score
from sklearn.model_selection import cross_val_score, train_test_split
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import OneHotEncoder
from sklearn.compose import ColumnTransformer
from sklearn.tree import DecisionTreeClassifier, export_text
SEED = 42
def load_frame() -> pd.DataFrame:
try:
import seaborn as sns
df = sns.load_dataset("titanic")
df = df[["survived", "pclass", "sex", "age", "sibsp", "parch", "fare", "embarked"]]
return df.dropna(subset=["embarked"])
except Exception:
rng = np.random.default_rng(SEED)
n = 891
pclass = rng.choice([1, 2, 3], n, p=[0.24, 0.21, 0.55])
sex = rng.choice(["male", "female"], n)
age = rng.normal(30, 14, n).clip(1, 80)
fare = rng.lognormal(3, 1, n)
prob = 1 / (1 + np.exp(-(1.2 * (sex == "female") - 0.7 * (pclass - 2) + 0.3)))
return pd.DataFrame({"survived": (rng.random(n) < prob).astype(int), "pclass": pclass,
"sex": sex, "age": age, "sibsp": rng.integers(0, 4, n),
"parch": rng.integers(0, 3, n), "fare": fare,
"embarked": rng.choice(["S", "C", "Q"], n)})
df = load_frame()
# 特征工程:家庭规模与"是否独自出行"往往比原始 sibsp/parch 更有解释力
df["family_size"] = df["sibsp"] + df["parch"] + 1
df["is_alone"] = (df["family_size"] == 1).astype(int)
num_cols = ["pclass", "age", "fare", "family_size", "is_alone"]
cat_cols = ["sex", "embarked"]
X, y = df[num_cols + cat_cols], df["survived"]
# 调参点 1:缺失值策略。树模型可以用中位数填补,但中位数会掩盖"儿童优先"这类非线性
pre = ColumnTransformer([
("num", SimpleImputer(strategy="median"), num_cols),
("cat", Pipeline([("imp", SimpleImputer(strategy="most_frequent")),
("oh", OneHotEncoder(handle_unknown="ignore", drop="first"))]), cat_cols),
])
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.25, stratify=y, random_state=SEED)
print("--- 复杂度曲线:单变量只改 max_depth ---")
for depth in (2, 3, 4, 6, 8, 10, None):
pipe = Pipeline([("pre", pre), ("clf", DecisionTreeClassifier(
max_depth=depth, min_samples_leaf=5, random_state=SEED))])
cv = cross_val_score(pipe, Xtr, ytr, cv=5, scoring="roc_auc").mean()
pipe.fit(Xtr, ytr)
tr = accuracy_score(ytr, pipe.predict(Xtr))
te = accuracy_score(yte, pipe.predict(Xte))
print(f"max_depth={str(depth):<4} CV-AUC={cv:.4f} 训练准确率={tr:.4f} 测试准确率={te:.4f} "
f"gap={tr - te:+.4f}")
# 调参点 2:min_samples_leaf 是控制过拟合的第二道闸;先定深度,再调叶样本数
best = Pipeline([("pre", pre), ("clf", DecisionTreeClassifier(
max_depth=3, min_samples_leaf=10, random_state=SEED))]).fit(Xtr, ytr)
print("\n--- 深度 3 的决策规则(可直接讲给业务方)---")
feat_names = best.named_steps["pre"].get_feature_names_out()
print(export_text(best.named_steps["clf"], feature_names=list(feat_names), max_depth=3))
print(f"测试集 ROC-AUC = {roc_auc_score(yte, best.predict_proba(Xte)[:, 1]):.4f}")
| 项目 | 内容 |
|---|---|
| 课题 3-2 | 员工离职预测(随机森林全参数实践) |
| 数据集 | Kaggle "HR Analytics: Employee Attrition"(IBM HR 数据集),1470 行、35 列,正类约占 16% |
| 任务与指标 | 二分类,主指标少数类 F1。参考线:F1 ≥ 0.55 |
| 关键参数 | n_estimators、max_features、min_samples_leaf、class_weight='balanced_subsample'、oob_score=True |
| 通关判据 | OOB 分数与 5 折 CV 差距 ≤ 0.01;特征重要性 Top5 在 3 个不同种子下重叠 ≥ 4 个;输出袋外误差随树数的收敛曲线 |
| 加分挑战 | 用 SHAP 解释单个高风险员工,写出"哪三个特征把他推高了"的说明 |
| 建议耗时 | 4 到 5 小时(难度 2 星,对应第四章 4.5) |
参考实现:code/3-2_ibm_attrition_rf.py
"""课题 3-2 员工离职预测(随机森林 + OOB 与学习曲线)
目标:AUC ≥ 0.85,用 OOB 分数代替额外验证集,并用学习曲线判断"该补数据还是改模型"。
数据:IBM HR Analytics Attrition 的 WA_Fn-UseC_-HR-Employee-Attrition.csv 放到 data/ibm_hr/;
没有就用合成表跑通。
依赖:scikit-learn、pandas、numpy
"""
from pathlib import Path
import numpy as np
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import roc_auc_score, classification_report
from sklearn.model_selection import StratifiedKFold, learning_curve, train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OrdinalEncoder
SEED = 42
DATA = Path("data/ibm_hr/WA_Fn-UseC_-HR-Employee-Attrition.csv")
def load_frame() -> pd.DataFrame:
if DATA.exists():
df = pd.read_csv(DATA)
df["Attrition"] = df["Attrition"].map({"Yes": 1, "No": 0})
return df.select_dtypes(include=[np.number])
rng = np.random.default_rng(SEED)
n = 1470
overtime = rng.choice([0, 1], n, p=[0.72, 0.28])
years = rng.integers(0, 20, n)
income = rng.lognormal(8.6, 0.4, n)
logit = 1.1 * overtime - 0.08 * years - 0.00002 * income - 0.6
attr = (rng.random(n) < 1 / (1 + np.exp(-logit))).astype(int)
return pd.DataFrame({"OverTime": overtime, "YearsAtCompany": years,
"MonthlyIncome": income, "Age": rng.integers(20, 60, n),
"JobLevel": rng.integers(1, 6, n), "Attrition": attr})
df = load_frame()
y = df.pop("Attrition")
X = df.drop(columns=[c for c in df.columns if df[c].nunique() <= 1])
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.25, stratify=y, random_state=SEED)
# 调参点 1:oob_score=True 让你白拿一个验证分数,前提是 bootstrap=True
rf = Pipeline([("clf", RandomForestClassifier(
n_estimators=400, # 200 以后收益很小,但不会害你,先给足
max_features="sqrt", # 分类默认值;特征间高度相关时改 0.3 可能更好
min_samples_leaf=2, # 过拟合先加这个,再加 max_depth
max_depth=None, # 让它自己长,靠 min_samples_leaf 剪枝
class_weight="balanced_subsample", # 正类只有 16% 时必开
oob_score=True, bootstrap=True, n_jobs=-1, random_state=SEED))]).fit(Xtr, ytr)
print(f"OOB 分数 = {rf.named_steps['clf'].oob_score_:.4f}")
print(f"测试集 AUC = {roc_auc_score(yte, rf.predict_proba(Xte)[:, 1]):.4f}")
print(f"训练集 AUC = {roc_auc_score(ytr, rf.predict_proba(Xtr)[:, 1]):.4f} "
f"(与测试差 >0.05 说明还欠剪枝)")
# 调参点 2:学习曲线回答的是"加数据有没有用",这是选型阶段最该先问的问题
sizes, tr_scores, va_scores = learning_curve(
rf, Xtr, ytr, cv=StratifiedKFold(5, shuffle=True, random_state=SEED),
train_sizes=np.linspace(0.1, 1.0, 6), scoring="roc_auc", n_jobs=-1)
print("\n--- 学习曲线(训练 / 验证 AUC)---")
for s, a, b in zip(sizes, tr_scores.mean(1), va_scores.mean(1)):
print(f"样本 {int(s):5d} 训练={a:.4f} 验证={b:.4f} gap={a - b:+.4f}")
imp = pd.Series(rf.named_steps["clf"].feature_importances_, index=X.columns).sort_values(ascending=False)
print("\n--- 特征重要度 Top8 ---")
print(imp.head(8).to_string(float_format=lambda v: f"{v:.4f}"))
print("\n" + classification_report(yte, rf.predict(Xte), target_names=["留任", "离职"], digits=3))
12.4.4 梯度提升树(XGBoost、LightGBM、CatBoost)
这一组是表格数据的正面战场,重点是三件事:参数优先级、三方对比、时间切分。
| 项目 | 内容 |
|---|---|
| 课题 4-1 | 信贷违约预测(类别特征与不均衡) |
| 数据集 | Kaggle home-credit-default-risk 的 application_train,30.7 万行、122 列,正类违约率约 8%。算力有限时按标签分层抽 5 万行 |
| 任务与指标 | 二分类,主指标 AUC。参考线:AUC ≥ 0.75 |
| 关键参数 | num_leaves 与 min_data_in_leaf(LightGBM 首选组合)、scale_pos_weight、cat_smooth、early_stopping_rounds |
| 通关判据 | 完成 LightGBM、XGBoost、CatBoost 三方对比表(AUC、训练时长、内存占用);早停实际生效并记录最佳轮数;AUC ≥ 0.75 |
| 加分挑战 | 引入 bureau 表做聚合特征,AUC 提升 ≥ 0.01 |
| 建议耗时 | 8 小时(难度 2 星,对应第四章 4.6) |
参考实现:code/4-1_credit_default_gbdt.py
"""课题 4-1 信贷违约预测:XGBoost / LightGBM / CatBoost 三方对比
目标:在同一套特征与同一份切分上比三个库,找出"参数相当但结果不同"的来源。
数据:UCI Default of Credit Card Clients(openml 自动下载);离线时合成。
依赖:scikit-learn、pandas、numpy;可选 xgboost / lightgbm / catboost(缺谁跳过谁)
"""
import numpy as np
import pandas as pd
from sklearn.datasets import fetch_openml, make_classification
from sklearn.ensemble import HistGradientBoostingClassifier
from sklearn.metrics import average_precision_score, roc_auc_score
from sklearn.model_selection import StratifiedKFold, cross_val_score, train_test_split
SEED = 42
def load_data():
try:
bunch = fetch_openml("default-of-credit-card-clients", version=1, as_frame=True)
df = bunch.frame
y = (df.pop("default payment next month").astype(int)).values
return df.select_dtypes(include=[np.number]).fillna(0), y
except Exception:
X, y = make_classification(n_samples=20000, n_features=23, n_informative=10,
weights=[0.78, 0.22], random_state=SEED)
return pd.DataFrame(X, columns=[f"f{i}" for i in range(23)]), y
X, y = load_data()
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.3, stratify=y, random_state=SEED)
print(f"样本 {X.shape[0]} × {X.shape[1]},正类率 {y.mean():.2%}")
# 三个库刻意用"语义等价"的参数,让对比公平
models = {}
try:
from xgboost import XGBClassifier
models["XGBoost"] = XGBClassifier(
n_estimators=600, learning_rate=0.05, max_depth=5,
subsample=0.8, colsample_bytree=0.8, reg_lambda=1.0,
eval_metric="auc", early_stopping_rounds=50, random_state=SEED, n_jobs=-1)
except ImportError:
pass
try:
from lightgbm import LGBMClassifier
models["LightGBM"] = LGBMClassifier(
n_estimators=600, learning_rate=0.05, num_leaves=31,
subsample=0.8, colsample_bytree=0.8, reg_lambda=1.0,
random_state=SEED, n_jobs=-1, verbose=-1)
except ImportError:
pass
try:
from catboost import CatBoostClassifier
models["CatBoost"] = CatBoostClassifier(
iterations=600, learning_rate=0.05, depth=6, l2_leaf_reg=3.0,
verbose=0, random_seed=SEED)
except ImportError:
pass
# 兜底:至少保证有东西可跑,HistGB 是 sklearn 里的同族实现
models.setdefault("HistGB(sklearn)", HistGradientBoostingClassifier(
learning_rate=0.05, max_iter=600, max_leaf_nodes=31, l2_regularization=1.0, random_state=SEED))
print("\n--- 同一份数据、同一套参数 ---")
for name, model in models.items():
model.fit(Xtr, ytr)
prob = model.predict_proba(Xte)[:, 1]
cv = cross_val_score(model, Xtr, ytr, cv=StratifiedKFold(3, shuffle=True, random_state=SEED),
scoring="roc_auc", n_jobs=-1).mean()
print(f"{name:16s} 测试AUC={roc_auc_score(yte, prob):.4f} "
f"测试PR-AUC={average_precision_score(yte, prob):.4f} 3折CV={cv:.4f}")
print("\n对比结论要点:")
print("1) 三者 AUC 差距通常在 0.003 以内——差异主要来自分裂策略与正则默认值,不是玄学;")
print("2) 若 CV 与测试差超过 0.02,先查切分是否分层、是否有时序泄漏;")
print("3) early_stopping 三个库的语义不同(XGB 需传 eval_set,LGBM 自带回调),别照抄参数。")
| 项目 | 内容 |
|---|---|
| 课题 4-2 | 零售销量预测(回归 + 时间特征工程) |
| 数据集 | Kaggle rossmann-store-sales,约 101.7 万行、1115 家门店,含促销、节假日、门店类型 |
| 任务与指标 | 回归,主指标 RMSPE(只对开业日计算)。参考线:≤ 0.15 |
| 关键参数 | objective='regression'、learning_rate=0.03、时间特征(星期、月、促销、节假日前后)、bagging_freq |
| 通关判据 | 必须用时间切分而非随机切分;用实验证明"去掉时间特征后指标显著变差";RMSPE ≤ 0.15 |
| 加分挑战 | 加滞后特征与滚动均值,RMSPE 再降 10%,并说明为什么这类特征在线上部署时要注意可得性 |
| 建议耗时 | 8 到 10 小时(难度 3 星,对应第三章 3.6、第四章 4.6) |
参考实现:code/4-2_rossmann_ts.py
"""课题 4-2 Rossmann 销量预测(时序切分,禁止随机 CV)
目标:证明"随机划分会把未来信息漏进训练集",从而高估精度;用时间切分拿到可信结果。
数据:Kaggle Rossmann Store Sales 的 train.csv 放到 data/rossmann/;
没有就用合成的多门店日销序列(含促销、周末、节假日效应)。
依赖:scikit-learn、pandas、numpy
"""
from pathlib import Path
import numpy as np
import pandas as pd
from sklearn.ensemble import HistGradientBoostingRegressor
from sklearn.metrics import mean_absolute_percentage_error
from sklearn.model_selection import KFold, train_test_split
SEED = 42
DATA = Path("data/rossmann/train.csv")
def load_frame() -> pd.DataFrame:
if DATA.exists():
df = pd.read_csv(DATA, parse_dates=["Date"])
df = df[df["Open"] == 1].copy()
return df.sort_values(["Store", "Date"])
days = pd.date_range("2013-01-01", "2015-07-31", freq="D")
rows = []
rng = np.random.default_rng(SEED)
for store in range(1, 41):
base = rng.uniform(3000, 9000)
for d in days:
promo = int(d.weekday() < 5 and rng.random() < 0.4)
weekend = 1.2 if d.weekday() >= 5 else 1.0
season = 1 + 0.25 * np.sin(2 * np.pi * d.dayofyear / 365)
sales = base * weekend * season * (1 + 0.35 * promo) * rng.normal(1, 0.08)
rows.append((store, d, int(sales), promo, d.weekday(), d.month, d.day))
return pd.DataFrame(rows, columns=["Store", "Date", "Sales", "Promo", "Weekday", "Month", "Day"])
df = load_frame()
# 调参点 1:滞后特征是时序任务的命门。lag_7 抓周周期,rolling_28 抓趋势
df["lag_7"] = df.groupby("Store")["Sales"].shift(7)
df["lag_28"] = df.groupby("Store")["Sales"].shift(28)
df["roll_28"] = df.groupby("Store")["Sales"].transform(
lambda s: s.shift(1).rolling(28, min_periods=14).mean())
df = df.dropna()
feats = ["Store", "Promo", "Weekday", "Month", "Day", "lag_7", "lag_28", "roll_28"]
X, y = df[feats], df["Sales"]
model = HistGradientBoostingRegressor(
learning_rate=0.06, max_iter=800, max_leaf_nodes=63,
min_samples_leaf=40, l2_regularization=1.0, random_state=SEED)
# 错误做法:随机切分。同一门店相邻日期被分到两侧,等于把答案抄进训练集
cut = int(len(df) * 0.8)
Xr_tr, Xr_te = X.iloc[:cut], X.iloc[cut:]
yr_tr, yr_te = y.iloc[:cut], y.iloc[cut:]
idx = np.arange(len(df))
a, b = train_test_split(idx, test_size=0.2, random_state=SEED) # 打乱后才切
model.fit(X.iloc[a], y.iloc[a])
mape_random = mean_absolute_percentage_error(y.iloc[b], model.predict(X.iloc[b]))
# 正确做法:按时间切分,训练集全在测试集之前
model.fit(Xr_tr, yr_tr)
mape_time = mean_absolute_percentage_error(yr_te, model.predict(Xr_te))
print(f"随机切分 MAPE = {mape_random:.4f} ← 偏乐观,不可信")
print(f"时间切分 MAPE = {mape_time:.4f} ← 这个数字才能写进报告")
print(f"两者差距 = {(mape_time - mape_random) / mape_random:+.1%},"
"差距越大说明滞后特征越容易被随机切分提前泄漏。")
# 附:时间序列交叉验证的正确写法(滚动窗口,绝不 shuffle)
print("\n--- 滚动验证(3 折)---")
fold = len(Xr_tr) // 5 # 留足 5 段,保证三次迭代的验证窗口都非空
for k in range(3):
tr_end = fold * (k + 2)
va_end = min(tr_end + fold, len(Xr_tr))
tr, va = slice(0, tr_end), slice(tr_end, va_end)
model.fit(Xr_tr.iloc[tr], yr_tr.iloc[tr])
m = mean_absolute_percentage_error(yr_tr.iloc[va], model.predict(Xr_tr.iloc[va]))
print(f"折{k + 1}: 训练 {tr.stop:6d} 行 → 验证 {va.stop - va.start:5d} 行, MAPE={m:.4f}")
12.4.5 支持向量机
SVM 在今天很少是最终方案,但它是理解"核技巧与距离"的最佳载体,也是面试高频。
| 项目 | 内容 |
|---|---|
| 课题 5-1 | 手写数字 SVM 与 CNN 对比 |
| 数据集 | 先用 sklearn.datasets.load_digits()(1797 条、8×8)跑通,再换 MNIST 的 1 万张子集 |
| 任务与指标 | 多分类,准确率。参考线:digits 上 SVM ≥ 0.97 |
| 关键参数 | C、gamma、kernel,必须先做 StandardScaler |
| 通关判据 | 画出 C 与 gamma 的二维准确率热力图;给出线性核与 RBF 核的"精度-训练时长"对比;用实验证明不标准化时 RBF 明显变差 |
| 加分挑战 | 用 HOG 特征加线性 SVM,把训练时间降一个数量级而精度损失小于 1% |
| 建议耗时 | 4 小时(难度 1 星,对应第四章 4.7) |
参考实现:code/5-1_digits_svm_vs_cnn.py
"""课题 5-1 手写数字识别:SVM 与 CNN 的正面对比
目标:在同一份数据上,用网格搜索调 C/gamma,再和一个小 CNN 比精度与训练成本。
数据:sklearn 内置 digits(1797 张 8×8 灰度图,无需下载)
依赖:scikit-learn、numpy;安装 torch 后自动追加 CNN 对照组
"""
import time
import numpy as np
from sklearn.datasets import load_digits
from sklearn.metrics import classification_report
from sklearn.model_selection import GridSearchCV, train_test_split
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC, LinearSVC
SEED = 42
digits = load_digits()
X, y = digits.data / 16.0, digits.target # 缩放到 [0,1],SVM 对量纲敏感
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.25, stratify=y, random_state=SEED)
# 调参点 1:RBF 核必须同时搜 C 与 gamma。
# C 控制容错(越大越硬),gamma 控制影响半径(越大越贴合局部)
grid = {"svc__C": [1, 10, 100], "svc__gamma": ["scale", 0.01, 0.05, 0.1]}
t0 = time.perf_counter()
gs = GridSearchCV(make_pipeline(StandardScaler(), SVC(kernel="rbf")), grid,
cv=5, scoring="accuracy", n_jobs=-1).fit(Xtr, ytr)
svm_time = time.perf_counter() - t0
print(f"SVM 最优参数 {gs.best_params_} 5折CV={gs.best_score_:.4f} 搜索耗时 {svm_time:.1f}s")
print(f"SVM 测试集准确率 = {gs.score(Xte, yte):.4f}")
# 对照:线性核在 64 维上其实很有竞争力,而且快一个量级
lin = make_pipeline(StandardScaler(), LinearSVC(C=0.1, max_iter=5000, random_state=SEED))
lin.fit(Xtr, ytr)
print(f"LinearSVC 测试集准确率 = {lin.score(Xte, yte):.4f}")
# 调参点 2:小样本(<2000)上 CNN 未必赢。这里刻意用最小结构验证这个结论
try:
import torch
from torch import nn
from torch.utils.data import DataLoader, TensorDataset
torch.manual_seed(SEED)
net = nn.Sequential(
nn.Conv2d(1, 16, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2), # 8x8 -> 4x4
nn.Conv2d(16, 32, 3, padding=1), nn.ReLU(), nn.MaxPool2d(2), # 4x4 -> 2x2
nn.Flatten(), nn.Linear(32 * 2 * 2, 10))
dl = DataLoader(TensorDataset(
torch.tensor(Xtr.reshape(-1, 1, 8, 8), dtype=torch.float32),
torch.tensor(ytr, dtype=torch.long)), batch_size=64, shuffle=True)
opt = torch.optim.Adam(net.parameters(), lr=1e-3) # 小数据上 1e-3 起手足够
lossf = nn.CrossEntropyLoss()
for epoch in range(30):
net.train()
for xb, yb in dl:
opt.zero_grad()
loss = lossf(net(xb), yb)
loss.backward()
opt.step()
if (epoch + 1) % 10 == 0:
print(f" epoch {epoch + 1:2d} loss={loss.item():.4f}")
net.eval()
with torch.no_grad():
pred = net(torch.tensor(Xte.reshape(-1, 1, 8, 8), dtype=torch.float32)).argmax(1).numpy()
print(f"CNN 测试集准确率 = {(pred == yte).mean():.4f}(参数 {sum(p.numel() for p in net.parameters())} 个)")
except ImportError:
print("未安装 torch,跳过 CNN 对照组(结论:1797 张 8x8 图上 SVM 与 CNN 差距通常在 1% 内)")
print("\n" + classification_report(yte, gs.predict(Xte), digits=3))
| 项目 | 内容 |
|---|---|
| 课题 5-2 | IMDB 影评情感分类(高维稀疏文本) |
| 数据集 | HuggingFace imdb,5 万条影评;或 sklearn.datasets.fetch_20newsgroups 取两个类别做二分 |
| 任务与指标 | 二分类,准确率。参考线:TF-IDF 加 LinearSVC ≥ 0.88 |
| 关键参数 | C、ngram_range、min_df、max_features、sublinear_tf |
| 通关判据 | LinearSVC 与 LogisticRegression 对比;用数据说明为什么 RBF 核在这个规模上不可行(样本数与维度);词袋与 TF-IDF 对比 |
| 加分挑战 | 用 TruncatedSVD 降到 300 维,说明精度损失小于 1% 时换来了多少速度 |
| 建议耗时 | 4 小时(难度 2 星,对应第四章 4.7、4.11) |
参考实现:code/5-2_imdb_tfidf.py
"""课题 5-2 IMDB 影评情感:TF-IDF 与线性模型的强基线
目标:验证"文本分类里 TF-IDF + 线性模型常常打败复杂模型",并调清 n-gram 与 C。
数据:优先读 data/imdb/train.csv(含 text/label 两列);否则用 20newsgroups 的二分类子集;
都不可用则用合成语料,保证管线能跑。
依赖:scikit-learn、pandas、numpy
"""
from pathlib import Path
import numpy as np
import pandas as pd
from sklearn.datasets import fetch_20newsgroups, make_classification
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_auc_score
from sklearn.model_selection import GridSearchCV, train_test_split
from sklearn.pipeline import Pipeline
from sklearn.svm import LinearSVC
SEED = 42
DATA = Path("data/imdb/train.csv")
def load_texts():
if DATA.exists():
df = pd.read_csv(DATA)
return df["text"].astype(str).tolist(), df["label"].astype(int).values
try:
cats = ["rec.autos", "rec.motorcycles", "sci.space", "sci.med"]
ng = fetch_20newsgroups(subset="all", categories=cats, remove=("headers", "footers"))
y = (np.array(ng.target) >= 2).astype(int) # rec.* vs sci.*
return ng.data, y
except Exception:
rng = np.random.default_rng(SEED)
vocab = np.array([f"w{i}" for i in range(400)])
texts, labels = [], []
for _ in range(4000):
lab = int(rng.random() < 0.5)
# 两类共用同一词表,只是前 200 个词在正类里出现概率更高。
# 这样 bigram 也记不住生成规则,难度更接近真实影评
w = np.where(np.arange(400) < 200, 1.0 + 0.8 * lab, 1.8 - 0.8 * lab)
p = w / w.sum()
texts.append(" ".join(rng.choice(vocab, 70, p=p)))
labels.append(lab)
labels = np.array(labels)
# 掺 8% 标签噪声:真实标注必然有错标,这也是"再好的模型也过不了 0.95"的原因之一
flip = rng.random(len(labels)) < 0.08
labels[flip] ^= 1
return texts, labels
texts, y = load_texts()
Xtr, Xte, ytr, yte = train_test_split(texts, y, test_size=0.25, stratify=y, random_state=SEED)
print(f"训练 {len(Xtr)} 条 / 测试 {len(Xte)} 条,正类率 {y.mean():.1%}")
# 调参点 1:ngram_range 与 min_df 是文本特征的两把主刀
# (1,1) 快而稳;(1,2) 通常 +1~2 个点;min_df=2 能砍掉大量只出现一次的词
pipe = Pipeline([
("tfidf", TfidfVectorizer(sublinear_tf=True, ngram_range=(1, 2),
min_df=2, max_df=0.9, strip_accents="unicode")),
("clf", LogisticRegression(C=1.0, max_iter=1000, solver="liblinear")),
])
# 调参点 2:C 在文本上跨度很大,1 到 30 都常见;sublinear_tf=True 几乎总是该开
grid = {"tfidf__ngram_range": [(1, 1), (1, 2)], "clf__C": [1, 3, 10, 30]}
gs = GridSearchCV(pipe, grid, cv=3, scoring="roc_auc", n_jobs=-1).fit(Xtr, ytr)
print(f"最优 {gs.best_params_} CV-AUC={gs.best_score_:.4f}")
print(f"测试集 AUC = {roc_auc_score(yte, gs.predict_proba(Xte)[:, 1]):.4f} "
f"准确率 = {gs.score(Xte, yte):.4f}")
# 对照:LinearSVC 在文本上通常与逻辑回归持平,但训练更快、不输出概率
svc = Pipeline([("tfidf", TfidfVectorizer(sublinear_tf=True, ngram_range=(1, 2), min_df=2)),
("clf", LinearSVC(C=0.5, max_iter=5000, random_state=SEED))]).fit(Xtr, ytr)
print(f"LinearSVC 准确率 = {svc.score(Xte, yte):.4f}")
vocab = gs.best_estimator_.named_steps["tfidf"].get_feature_names_out()
coef = gs.best_estimator_.named_steps["clf"].coef_[0]
order = np.argsort(coef)
print("\n最负面词:", "、".join(vocab[order[:8]]))
print("最正面词:", "、".join(vocab[order[-8:]][::-1]))
12.4.6 K 近邻
KNN 训练成本为零、推理成本极高,这两个课题会让你对"距离"和"维度"产生真实的敬畏。
| 项目 | 内容 |
|---|---|
| 课题 6-1 | MovieLens 100K 用户协同过滤 |
| 数据集 | GroupLens 的 MovieLens 100K,10 万条评分、943 个用户、1682 部电影 |
| 任务与指标 | 评分预测(回归),主指标 RMSE。参考线:≤ 0.95 |
| 关键参数 | n_neighbors、weights='distance'、metric(cosine 通常优于 euclidean)、相似度归一化 |
| 通关判据 | 分别实现 user-based 与 item-based 两种并对比;RMSE ≤ 0.95;对冷启动用户单独给策略并说明效果 |
| 加分挑战 | 加偏置项(全局均值 + 用户偏置 + 物品偏置)后 RMSE ≤ 0.92,并解释每个偏置项吸收了哪部分方差 |
| 建议耗时 | 6 小时(难度 2 星,对应第四章 4.8) |
参考实现:code/6-1_movielens_knn.py
"""课题 6-1 MovieLens 电影推荐(KNN 协同过滤)
目标:手写基于用户的 KNN 协同过滤,用 RMSE 评估,并扫清邻居数 k 的拐点。
数据:data/ml-latest-small/ratings.csv(MovieLens 小数据集,约 10 万条);
没有就用带隐因子的合成评分矩阵,保证公式可验证。
依赖:scikit-learn、pandas、numpy
"""
from pathlib import Path
import numpy as np
import pandas as pd
from sklearn.metrics.pairwise import cosine_similarity
from sklearn.model_selection import train_test_split
SEED = 42
DATA = Path("data/ml-latest-small/ratings.csv")
def load_ratings() -> pd.DataFrame:
if DATA.exists():
return pd.read_csv(DATA)[["userId", "movieId", "rating"]]
rng = np.random.default_rng(SEED)
n_users, n_items, n_factors = 300, 200, 12
# 用户偏好与物品属性都落在同一个 12 维隐空间里,评分 = 基线 + 点积 + 噪声
# 没有这个低秩结构,协同过滤必然输给均值基线——真实数据恰好是这种结构
U = rng.normal(0, 0.5, (n_users, n_factors))
V = rng.normal(0, 0.5, (n_items, n_factors))
rows = []
for u in range(n_users):
items = rng.choice(n_items, rng.integers(20, 60), replace=False)
for i in items:
r = 3.5 + float(U[u] @ V[i]) + rng.normal(0, 0.35)
rows.append((u + 1, i + 1, float(np.clip(r, 0.5, 5.0))))
return pd.DataFrame(rows, columns=["userId", "movieId", "rating"])
df = load_ratings()
print(f"评分 {len(df)} 条,用户 {df.userId.nunique()},物品 {df.movieId.nunique()},"
f"稀疏度 {1 - len(df) / (df.userId.nunique() * df.movieId.nunique()):.2%}")
tr, te = train_test_split(df, test_size=0.2, random_state=SEED)
# 用户-物品矩阵:0 表示"未评分",不参与相似度计算
mat = tr.pivot_table(index="userId", columns="movieId", values="rating").fillna(0.0)
rated = mat > 0
user_mean = mat.where(rated).mean(axis=1)
global_mean = tr["rating"].mean()
# 调参点 1:相似度在"去均值"的矩阵上算。用户打分习惯(有的永远打 4 分)必须先扣掉,
# 否则相似度主要反映"谁打分高",而不是"谁口味像"
centered = mat.where(rated).sub(user_mean, axis=0).fillna(0.0)
sim_arr = cosine_similarity(centered)
np.fill_diagonal(sim_arr, 0.0) # 不能与自己相似,否则邻居永远是自己
sim = pd.DataFrame(sim_arr, index=mat.index, columns=mat.index)
def predict(u: int, i: int, k: int) -> float:
"""user-based KNN:pred = 用户均值 + 邻居偏差的相似度加权平均。"""
if i not in mat.columns: # 冷启动物品:退回用户均值
return float(user_mean.get(u, global_mean))
raters = mat[i][mat[i] > 0]
raters = raters.drop(index=u, errors="ignore") # 自己评过就不算邻居
if raters.empty:
return float(user_mean.get(u, global_mean))
top = sim.loc[u, raters.index].nlargest(k)
if top.abs().sum() < 1e-9:
return float(user_mean.get(u, global_mean))
bias = raters[top.index] - user_mean[top.index] # 关键:邻居的偏差而非原始分
return float(user_mean.get(u, global_mean) + (top * bias).sum() / top.abs().sum())
# 调参点 2:k 太小噪声大,k 太大退化成全局平均;稀疏数据上拐点常出现在 10~30
sample = te.sample(min(2000, len(te)), random_state=SEED)
print("\n--- 邻居数 k 的敏感度 ---")
for k in (5, 10, 20, 40, 80):
preds = np.array([predict(r.userId, r.movieId, k) for r in sample.itertuples()])
rmse = float(np.sqrt(np.mean((preds - sample["rating"].values) ** 2)))
print(f"k={k:3d} RMSE={rmse:.4f}")
base_rmse = float(np.sqrt(np.mean((user_mean.loc[sample.userId].values
- sample["rating"].values) ** 2)))
print(f"\n基线(只预测该用户自己的均值)RMSE = {base_rmse:.4f}")
print(f"基线(全体均值)RMSE = "
f"{np.sqrt(np.mean((global_mean - sample['rating'].values) ** 2)):.4f}")
print("结论:只有明显低于'用户均值'基线,才说明协同信号真的带来了增量;")
print(" 若持平,说明数据里没有可用的邻域结构,应转向矩阵分解或内容特征。")
| 项目 | 内容 |
|---|---|
| 课题 6-2 | CIFAR-10 图像检索(KNN 加降维) |
| 数据集 | torchvision.datasets.CIFAR10,5 万训练、1 万测试、10 类 |
| 任务与指标 | 以图搜图,主指标 Top-5 命中率。参考线:原始像素 ≥ 0.45,PCA 64 维后 ≥ 0.65 |
| 关键参数 | n_neighbors、PCA(n_components)、metric、algorithm 与 leaf_size |
| 通关判据 | 对比原始像素、PCA、HOG 三种表示;用实验证明高维下 brute 优于 kd_tree;输出 10 组检索结果图 |
| 加分挑战 | 换成预训练 ResNet18 的倒数第二层特征,Top-5 达到 0.85 以上,并解释为什么"学出来的距离"比"像素距离"好用 |
| 建议耗时 | 5 小时(难度 2 星,对应第四章 4.8、4.11) |
参考实现:code/6-2_cifar10_knn_retrieval.py
"""课题 6-2 CIFAR-10 图像检索(KNN + PCA 降维)
目标:用"像素/KNN"做以图搜图,量化它与 CNN 特征检索的差距,理解"手工特征的天花板"。
数据:torchvision 自动下载 CIFAR-10(约 170MB)到 data/;无 torch 时用 digits 放大替代。
依赖:scikit-learn、numpy;可选 torch、torchvision
"""
import numpy as np
from sklearn.decomposition import PCA
from sklearn.metrics import precision_score
from sklearn.neighbors import KNeighborsClassifier
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
SEED = 42
def load_images():
try:
from torchvision.datasets import CIFAR10
tr = CIFAR10(root="data", train=True, download=True)
te = CIFAR10(root="data", train=False, download=True)
Xtr = np.asarray(tr.data, dtype=np.float32).reshape(len(tr), -1) / 255.0
Xte = np.asarray(te.data, dtype=np.float32).reshape(len(te), -1) / 255.0
return Xtr, np.array(tr.targets), Xte, np.array(te.targets), "CIFAR-10"
except Exception as exc:
from sklearn.datasets import load_digits
d = load_digits()
n = len(d.data)
cut = int(n * 0.8)
print(f"[降级] 未取到 CIFAR-10({type(exc).__name__}),改用 digits 演示同一流程")
return d.data[:cut], d.target[:cut], d.data[cut:], d.target[cut:], "digits"
Xtr, ytr, Xte, yte, name = load_images()
print(f"数据集 {name}:训练 {Xtr.shape[0]} × {Xtr.shape[1]} 维")
# 调参点 1:PCA 保留维度决定"检索速度 vs 细节"的平衡,95% 方差是常用起点。
# 注意 n_components 不能超过特征数(降级到 digits 时只有 64 维)
for n_comp in (32, 64, 128):
n_use = min(n_comp, Xtr.shape[1])
pipe = Pipeline([
("scale", StandardScaler()),
("pca", PCA(n_components=n_use, random_state=SEED)),
# 调参点 2:k 取奇数避免平票;weights="distance" 在检索任务上通常更稳
("knn", KNeighborsClassifier(n_neighbors=5, weights="distance", metric="cosine", n_jobs=-1)),
]).fit(Xtr, ytr)
acc = pipe.score(Xte, yte)
print(f"PCA {n_use:3d} 维 KNN 准确率 = {acc:.4f}")
# 以图搜图:返回最相似的 5 张,看"近邻是否同类别"作为检索质量的代理指标
best = Pipeline([("scale", StandardScaler()), ("pca", PCA(n_components=64, random_state=SEED)),
("knn", KNeighborsClassifier(n_neighbors=5, metric="cosine"))]).fit(Xtr, ytr)
dist, idx = best.named_steps["knn"].kneighbors(
best.named_steps["pca"].transform(best.named_steps["scale"].transform(Xte[:200])))
hit = (ytr[idx] == yte[:200, None]).mean()
print(f"\nTop-5 检索命中率(近邻同类别)= {hit:.4f}")
print(f"首邻精确率 = {precision_score(yte[:200], ytr[idx[:, 0]], average='macro'):.4f}")
if name == "CIFAR-10":
print("\n预期结论:CIFAR-10 上像素 KNN 准确率约 0.35~0.40,远低于小 CNN 的 0.75+。")
print("这说明 KNN 的瓶颈不是 k,而是'欧氏距离在像素空间不表达语义'——换特征比调参有效。")
else:
print(f"\n当前跑的是 {name}(8×8、类内差异小),KNN 准确率通常在 0.93 以上。")
print("这恰好是对照组:同样的 KNN,在高分辨率自然图像上会掉到 0.35 左右。")
print("差别不在算法,而在'像素距离是否表达语义'——这就是特征工程的价值。")
12.4.7 朴素贝叶斯
朴素贝叶斯的正确定位是"极快的强基线"。做完这两个课题,你应该能判断什么时候不必上复杂模型。
| 项目 | 内容 |
|---|---|
| 课题 7-1 | 垃圾短信识别 |
| 数据集 | UCI SMS Spam Collection,5574 条短信,其中垃圾短信 747 条 |
| 任务与指标 | 二分类,主指标 F1。参考线:≥ 0.93 |
| 关键参数 | alpha(拉普拉斯平滑)、fit_prior、词频与二值化两种表示 |
| 通关判据 | MultinomialNB、BernoulliNB、ComplementNB 三者对比;画出 alpha 从 0.01 到 10 的指标敏感度曲线 |
| 加分挑战 | 与 LinearSVC 对比,并给出"朴素贝叶斯在什么数据规模下仍然够用"的结论 |
| 建议耗时 | 2 到 3 小时(难度 1 星,对应第四章 4.9) |
参考实现:code/7-1_sms_spam_nb.py
"""课题 7-1 垃圾短信识别(MultinomialNB vs BernoulliNB)
目标:在 0.5 万条短信上验证 alpha 与特征类型对朴素贝叶斯的影响,并解释三个变体的差别。
数据:UCI SMS Spam Collection 的 SMSSpamCollection 放到 data/sms/;
没有就用合成短信用语,保证流程可跑。
依赖:scikit-learn、pandas、numpy
"""
from pathlib import Path
import numpy as np
import pandas as pd
from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer
from sklearn.metrics import classification_report, f1_score
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import BernoulliNB, ComplementNB, MultinomialNB
from sklearn.pipeline import Pipeline
SEED = 42
DATA = Path("data/sms/SMSSpamCollection")
def load_sms():
if DATA.exists():
rows = [line.split("\t", 1) for line in DATA.read_text(encoding="utf-8").splitlines() if "\t" in line]
return [r[1] for r in rows], np.array([1 if r[0] == "spam" else 0 for r in rows])
rng = np.random.default_rng(SEED)
# 两类共享大量日常词,再各自掺 40% 的"对方词",模拟真实短信的重叠程度。
# 完全可分的数据会让所有模型都 100%,失去对照意义
common = "我 你 今天 明天 时间 可以 麻烦 确认 收到 谢谢 一下 那个 这个 已经".split()
spam_words = "中奖 免费 点击 链接 贷款 额度 限时 优惠 验证码 抢购".split()
normal_words = "会议 材料 孩子 晚饭 地铁 加班 报告 电话 地址 周末".split()
texts, labels = [], []
for _ in range(3000):
lab = int(rng.random() < 0.13)
own, other = (spam_words, normal_words) if lab else (normal_words, spam_words)
words = list(rng.choice(common, rng.integers(1, 4)))
words += list(rng.choice(own, rng.integers(1, 5)))
words += list(rng.choice(other, rng.integers(0, 3))) # 掺入对方词汇
rng.shuffle(words)
texts.append(" ".join(words))
labels.append(lab)
return texts, np.array(labels)
texts, y = load_sms()
Xtr, Xte, ytr, yte = train_test_split(texts, y, test_size=0.25, stratify=y, random_state=SEED)
print(f"样本 {len(texts)} 条,垃圾占比 {y.mean():.1%}")
# 调参点 1:alpha 是拉普拉斯平滑系数。词表小、样本少时 1.0 偏强,0.1 往往更好
print("\n--- MultinomialNB 的 alpha 敏感度(词频特征)---")
for alpha in (0.01, 0.1, 0.5, 1.0, 2.0):
pipe = Pipeline([("vec", CountVectorizer(lowercase=True, stop_words=None, ngram_range=(1, 2), min_df=2)),
("nb", MultinomialNB(alpha=alpha))]).fit(Xtr, ytr)
print(f"alpha={alpha:<5} 宏F1={f1_score(yte, pipe.predict(Xte), average='macro'):.4f}")
# 调参点 2:BernoulliNB 用"出现/不出现"建模,必须显式给二值特征,否则语义不对
variants = {
"MultinomialNB + 词频": Pipeline([
("vec", CountVectorizer(ngram_range=(1, 2), min_df=2)),
("nb", MultinomialNB(alpha=0.1))]),
"MultinomialNB + TF-IDF": Pipeline([
("vec", TfidfVectorizer(ngram_range=(1, 2), min_df=2, sublinear_tf=True)),
("nb", MultinomialNB(alpha=0.1))]),
"BernoulliNB + 二值": Pipeline([
("vec", CountVectorizer(ngram_range=(1, 2), min_df=2, binary=True)),
("nb", BernoulliNB(alpha=1.0, binarize=0.0))]),
"ComplementNB + TF-IDF": Pipeline([
("vec", TfidfVectorizer(ngram_range=(1, 2), min_df=2)),
("nb", ComplementNB(alpha=0.3))]),
}
print("\n--- 四种组合对比 ---")
for name, pipe in variants.items():
pipe.fit(Xtr, ytr)
pred = pipe.predict(Xte)
print(f"{name:26s} 宏F1={f1_score(yte, pred, average='macro'):.4f} 准确率={pipe.score(Xte, yte):.4f}")
best = variants["ComplementNB + TF-IDF"]
print("\n" + classification_report(yte, best.predict(Xte), target_names=["正常", "垃圾"], digits=3))
print("结论:类别不平衡(垃圾 13%)时 ComplementNB 通常优于 MultinomialNB,因为它补的是'类间互补'的偏差。")
| 项目 | 内容 |
|---|---|
| 课题 7-2 | 20 Newsgroups 主题分类 |
| 数据集 | sklearn.datasets.fetch_20newsgroups,约 1.8 万篇文档、20 个类别,支持按类别子集下载 |
| 任务与指标 | 多分类,主指标宏平均 F1。参考线:≥ 0.85 |
| 关键参数 | alpha、min_df、sublinear_tf、stop_words、是否去除 headers 与 footers |
| 通关判据 | 用实验说明"保留 headers、footers、quotes 会引入泄漏"(这几段含发信人所属机构信息);宏 F1 ≥ 0.85 |
| 加分挑战 | 用 ComplementNB 处理类别不均衡,对比宏 F1 与加权 F1 的变化 |
| 建议耗时 | 3 小时(难度 1 星,对应第三章 3.6、第四章 4.9) |
参考实现:code/7-2_20newsgroups_nb.py
"""课题 7-2 20 Newsgroups 主题分类(多分类朴素贝叶斯)
目标:处理 20 类文本,验证 fit_prior、min_df 与特征类型如何影响多分类表现。
数据:sklearn 内置 fetch_20newsgroups(首次下载约 14MB)
依赖:scikit-learn、numpy
"""
import numpy as np
from sklearn.datasets import fetch_20newsgroups
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics import classification_report, f1_score
from sklearn.naive_bayes import MultinomialNB
from sklearn.pipeline import Pipeline
SEED = 42
def get_data():
"""优先官方语料;离线失败时用合成 8 类语料,保证所有对照实验仍可执行。"""
try:
tr = fetch_20newsgroups(subset="train", remove=("headers", "footers", "quotes"),
random_state=SEED)
te = fetch_20newsgroups(subset="test", remove=("headers", "footers", "quotes"),
random_state=SEED)
return tr.data, tr.target, te.data, te.target, [n[:18] for n in tr.target_names]
except Exception as exc:
print(f"[降级] 无法下载 20newsgroups({type(exc).__name__}),改用合成 8 类语料")
rng = np.random.default_rng(SEED)
topics = {
"汽车": "engine wheel brake tire mileage sedan".split(),
"摩托": "helmet rider harley chain exhaust touring".split(),
"航天": "orbit shuttle launch nasa satellite payload".split(),
"医学": "patient symptom diagnosis treatment clinical".split(),
"加密": "cipher key encryption privacy pgp signature".split(),
"硬件": "cpu scsi motherboard jumper voltage bus".split(),
"政治": "policy senate election debate vote".split(),
"宗教": "faith bible church prayer belief".split(),
}
common = "the a of to and is in for with this that from".split()
X, y = [], []
for label, (_, words) in enumerate(topics.items()):
for _ in range(300):
toks = list(rng.choice(words, rng.integers(20, 60)))
toks += list(rng.choice(common, rng.integers(30, 80))) # 停用词之外的共享词
rng.shuffle(toks)
X.append(" ".join(toks))
y.append(label)
idx = rng.permutation(len(X))
cut = int(len(X) * 0.75)
X = [X[i] for i in idx]
y = np.array([y[i] for i in idx])
return X[:cut], y[:cut], X[cut:], y[cut:], list(topics.keys())
tr_data, tr_y, te_data, te_y, target_names = get_data()
print(f"训练 {len(tr_data)} 篇 / 测试 {len(te_data)} 篇,共 {len(target_names)} 类")
# 调参点 1:min_df 决定词表规模。20 类语料里 min_df=2 能把 13 万维压到 3 万维左右
print("\n--- min_df 与 max_features 的取舍 ---")
for min_df, max_feat in [(1, None), (2, None), (5, None), (2, 50_000)]:
pipe = Pipeline([
("vec", TfidfVectorizer(sublinear_tf=True, min_df=min_df, max_features=max_feat,
stop_words="english", ngram_range=(1, 1))),
("nb", MultinomialNB(alpha=0.01))]).fit(tr_data, tr_y)
n_feat = len(pipe.named_steps["vec"].vocabulary_)
print(f"min_df={min_df} max_features={max_feat} 词表={n_feat:6d} "
f"宏F1={f1_score(te_y, pipe.predict(te_data), average='macro'):.4f}")
# 调参点 2:fit_prior=False 表示用均匀先验。只有类别天然等频时才该关掉
print("\n--- 先验与 alpha ---")
for fit_prior, alpha in [(True, 0.01), (True, 0.1), (False, 0.01), (False, 0.1)]:
pipe = Pipeline([
("vec", TfidfVectorizer(sublinear_tf=True, min_df=2, stop_words="english")),
("nb", MultinomialNB(alpha=alpha, fit_prior=fit_prior))]).fit(tr_data, tr_y)
print(f"fit_prior={str(fit_prior):<5} alpha={alpha:<4} "
f"宏F1={f1_score(te_y, pipe.predict(te_data), average='macro'):.4f} "
f"准确率={pipe.score(te_data, te_y):.4f}")
final = Pipeline([("vec", TfidfVectorizer(sublinear_tf=True, min_df=2, stop_words="english")),
("nb", MultinomialNB(alpha=0.01, fit_prior=True))]).fit(tr_data, tr_y)
print("\n" + classification_report(te_y, final.predict(te_data),
target_names=target_names, digits=2))
# 常见的"看起来成功"陷阱:不做 remove,准确率会因为头部信息虚高,但线上直接掉
try:
leaky = fetch_20newsgroups(subset="train", random_state=SEED)
sneaky = Pipeline([("vec", TfidfVectorizer(min_df=2)),
("nb", MultinomialNB(alpha=0.01))]).fit(leaky.data, leaky.target)
print(f"\n[对照] 保留 headers 时训练集自评准确率 = "
f"{sneaky.score(leaky.data, leaky.target):.4f}")
print("这个数字没有意义——它主要来自邮件域名与签名档,属于典型数据泄漏。")
except Exception:
print("\n[对照] 离线环境取不到带 headers 的原始语料,这段只在联网时执行。")
print("结论不变:保留邮件头部会让模型学到域名与签名档,是教科书级的泄漏。")
12.4.8 聚类
聚类最容易被做成"跑出几个簇就交差"。这两个课题要求你给出业务画像与稳定性证据,而不只是标签。
| 项目 | 内容 |
|---|---|
| 课题 8-1 | RFM 客户分群 |
| 数据集 | UCI Online Retail II,约 100 万条交易记录(2009 到 2011 两年),含发票号、商品、数量、单价、客户 ID |
| 任务与指标 | 客户分群,指标用轮廓系数、簇稳定性、业务可解释性。参考线:轮廓系数 ≥ 0.45 |
| 关键参数 | n_clusters(肘部法加轮廓系数双判据)、n_init=20、init='k-means++'、log1p 处理金额 |
| 通关判据 | 轮廓系数 ≥ 0.45;每个簇能用 2 到 3 个特征写出清晰画像;换随机种子后两次结果的 ARI ≥ 0.7 |
| 加分挑战 | 与 GMM 对比,说明在"客户可同时属于多个群体"的业务假设下谁更合适 |
| 建议耗时 | 5 小时(难度 2 星,对应第三章 3.2、第四章 4.10) |
参考实现:code/8-1_rfm_kmeans.py
"""课题 8-1 RFM 客户分群(KMeans + 肘部法 + 轮廓系数)
目标:把客户分成 4~6 群并给出可执行的运营建议;重点验证"先变换再标准化"的必要性。
数据:data/online_retail/Online Retail.xlsx 或清洗后的 csv;没有就用合成 RFM。
依赖:scikit-learn、pandas、numpy
"""
from pathlib import Path
import numpy as np
import pandas as pd
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score
from sklearn.preprocessing import StandardScaler
SEED = 42
DATA = Path("data/online_retail/rfm.csv")
def load_rfm() -> pd.DataFrame:
if DATA.exists():
return pd.read_csv(DATA)[["Recency", "Frequency", "Monetary"]]
rng = np.random.default_rng(SEED)
# 真实 RFM 是"少数高频客户贡献大部分金额"的长尾;这里用三个对数正态群叠加模拟
n = 3000
seg = rng.choice(3, n, p=[0.60, 0.30, 0.10])
mu = np.array([[4.0, 0.5, 3.2], [3.0, 1.8, 5.0], [1.5, 3.0, 6.5]])[seg]
sd = np.array([[0.5, 0.4, 0.4], [0.5, 0.4, 0.4], [0.4, 0.3, 0.3]])[seg]
log_rfm = rng.normal(mu, sd)
return pd.DataFrame(np.exp(log_rfm), columns=["Recency", "Frequency", "Monetary"])
rfm = load_rfm()
print("原始分布(长尾,直接用会被 Monetary 主导):")
print(rfm.describe().loc[["mean", "std", "max"]].to_string(float_format=lambda v: f"{v:.1f}"))
# 调参点 1:先 log1p 压缩长尾,再标准化。
# 顺序错了(先标准化再 log)会把负值喂给 log1p,结果无意义
X_log = np.log1p(rfm)
X_scaled = StandardScaler().fit_transform(X_log)
print("\n--- k 的选择:惯性 + 轮廓系数(两者要一起看)---")
best_k, best_sil = None, -1
for k in range(2, 9):
km = KMeans(n_clusters=k, n_init=10, max_iter=300, random_state=SEED).fit(X_scaled)
sil = silhouette_score(X_scaled, km.labels_)
if sil > best_sil:
best_k, best_sil = k, sil
print(f"k={k} 惯性={km.inertia_:8.1f} 轮廓系数={sil:.4f}")
# 调参点 2:n_init 不要留默认的 1,KMeans 对初始中心很敏感
final = KMeans(n_clusters=best_k, n_init=20, max_iter=500, random_state=SEED).fit(X_scaled)
rfm["segment"] = final.labels_
profile = rfm.groupby("segment").agg(
客户数=("Recency", "size"),
平均近度=("Recency", "mean"),
平均频次=("Frequency", "mean"),
平均金额=("Monetary", "mean")).round(1)
profile["金额占比"] = (rfm.groupby("segment")["Monetary"].sum() / rfm["Monetary"].sum() * 100).round(1)
print(f"\n选定 k={best_k}(轮廓系数 {best_sil:.3f}),各群画像:")
print(profile.sort_values("平均金额", ascending=False).to_string())
# 不做 log 的对照:证明尺度处理不是可选项
raw_labels = KMeans(n_clusters=best_k, n_init=20, random_state=SEED).fit_predict(StandardScaler().fit_transform(rfm))
raw_sil = silhouette_score(StandardScaler().fit_transform(rfm), raw_labels)
print(f"\n[对照] 跳过 log1p 时轮廓系数 = {raw_sil:.4f}")
print(f" 做 log1p 后轮廓系数 = {best_sil:.4f}")
print("注意:轮廓系数未必升高——log 改变的不是可分性,而是'簇由谁主导'。")
print(" 不做 log 时 Monetary 的量级(可跨两三个数量级)会吃掉另外两维,")
print(" 簇实际是按金额切开的;做 log 后三维贡献相当,簇才是 RFM 三要素的组合。")
print(" 判断依据请用各簇的金额占比是否呈梯度,而不是只看轮廓系数。")
| 项目 | 内容 |
|---|---|
| 课题 8-2 | DBSCAN 异常交易发现(无监督视角) |
| 数据集 | Kaggle creditcardfraud,只用正常交易训练,欺诈样本仅用于事后验证 |
| 任务与指标 | 异常检测,指标为已知欺诈上的召回率与噪声比例。参考线:召回 ≥ 0.5,噪声比例 < 2% |
| 关键参数 | eps(由 k-距离图的拐点确定)、min_samples、metric |
| 通关判据 | 画出 k-距离图并说明 eps 的取法依据;噪声比例 < 2%;欺诈召回 ≥ 0.5 |
| 加分挑战 | 用 Isolation Forest 对比,说明"密度法"与"隔离法"在假设上的差异,以及在什么数据形态下会给出相反结论 |
| 建议耗时 | 4 小时(难度 2 星,对应第四章 4.10、第九章病症十四) |
参考实现:code/8-2_dbscan_anomaly.py
"""课题 8-2 异常交易识别(DBSCAN + k-距离选 eps)
目标:不预设簇数,用密度找出"离群交易";掌握 eps 的正确选法,而不是靠猜。
数据:data/creditcard/creditcard.csv(取正常样本做无监督异常检测);
没有就用 make_blobs 加 2% 均匀噪声。
依赖:scikit-learn、numpy、pandas
"""
from pathlib import Path
import numpy as np
import pandas as pd
from sklearn.cluster import DBSCAN
from sklearn.datasets import make_blobs
from sklearn.metrics import silhouette_score
from sklearn.neighbors import NearestNeighbors
from sklearn.preprocessing import StandardScaler
SEED = 42
DATA = Path("data/creditcard/creditcard.csv")
def load_points():
if DATA.exists():
df = pd.read_csv(DATA)
keep = [c for c in df.columns if c.startswith("V")][:6] # 取前 6 个 PCA 维度便于可视化
return df[keep].sample(8000, random_state=SEED).values
X, _ = make_blobs(n_samples=5000, centers=4, n_features=6, cluster_std=1.2, random_state=SEED)
rng = np.random.default_rng(SEED)
noise = rng.uniform(X.min() * 1.8, X.max() * 1.8, (150, 6)) # 3% 均匀噪声即"异常"
return np.vstack([X, noise])
X = StandardScaler().fit_transform(load_points())
print(f"样本 {X.shape[0]} × {X.shape[1]}")
# 调参点 1:eps 不要手填。画 k-距离曲线的"肘部",那里就是合适半径
k = 8 # k 一般取 维度数+1 到 2*维度数
dist, _ = NearestNeighbors(n_neighbors=k).fit(X).kneighbors(X)
k_dist = np.sort(dist[:, -1])[::-1]
for q in (0.90, 0.95, 0.98, 0.99):
print(f"第 {q:.0%} 分位的 {k}-距离 = {np.quantile(k_dist, q):.3f} ← 可作 eps 候选")
print("\n--- eps 敏感度(min_samples=8)---")
for eps in (0.3, 0.5, 0.7, 0.9, 1.2):
db = DBSCAN(eps=eps, min_samples=k).fit(X)
n_clusters = len(set(db.labels_)) - (1 if -1 in db.labels_ else 0)
noise_ratio = (db.labels_ == -1).mean()
sil = silhouette_score(X, db.labels_) if n_clusters >= 2 else float("nan")
print(f"eps={eps:<4} 簇数={n_clusters:<3} 噪声占比={noise_ratio:.2%} 轮廓系数={sil:.4f}")
# 调参点 2:min_samples 越大,簇越"保守",噪声越多;高维数据必须同步放大 eps
db = DBSCAN(eps=0.7, min_samples=k).fit(X)
labels = db.labels_
print(f"\n最终:簇数 {len(set(labels)) - (1 if -1 in labels else 0)},"
f"核心点 {(labels != -1).sum()},噪声点 {(labels == -1).sum()}")
sil_ok = silhouette_score(X, labels) if len(set(labels)) >= 2 else float("nan")
print(f"轮廓系数 = {sil_ok:.4f}(DBSCAN 不追求高轮廓系数,只要求簇内密度一致)")
print("\n判据核对:")
print(f" 噪声占比 {np.mean(labels == -1):.2%} —— 落在 1%~5% 说明 eps 量级合理;")
print(f" 最大簇占比 {pd.Series(labels[labels != -1]).value_counts(normalize=True).iloc[0]:.2%} "
f"—— 超过 80% 说明 eps 偏大,所有点被粘成一团。")
12.4.9 降维
降维要破除的最大误解是"图上分得开说明模型强"。两个课题都会让你亲手推翻这个想法。
| 项目 | 内容 |
|---|---|
| 课题 9-1 | MNIST 的 PCA 与 t-SNE 可视化 |
| 数据集 | MNIST 随机抽 6000 张,含标签(参考脚本默认用内置 digits 秒级跑通,设 USE_MNIST=1 切换到 MNIST) |
| 任务与指标 | 可视化与重构,指标为 2 维可分性、重构误差。参考线:PCA 保留 95% 方差所需维度数应在 100 到 150 之间 |
| 关键参数 | n_components、perplexity(5 到 50)、init='pca'、n_iter |
| 通关判据 | 用实验证明"t-SNE 的簇间距离不可信":固定数据只改 perplexity,簇的相对位置会大幅变化;给出该证据的图 |
| 加分挑战 | 用 UMAP 对比,说明 n_neighbors 与 min_dist 分别控制什么,并找出一个 t-SNE 会误导而 UMAP 不会的例子 |
| 建议耗时 | 3 小时(难度 1 星,对应第四章 4.11) |
参考实现:code/9-1_mnist_pca_tsne.py
"""课题 9-1 MNIST 的 PCA 与 t-SNE(降维到底在保什么)
目标:对比 PCA(保方差)与 t-SNE(保邻域),并量化"降维后还能不能分类"。
数据:默认 sklearn digits(内置、秒级);设 USE_MNIST=1 可切到 MNIST 前 6000 张。
依赖:scikit-learn、numpy
"""
import os
import time
import numpy as np
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression
from sklearn.manifold import TSNE
from sklearn.metrics import accuracy_score
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
SEED = 42
def load_mnist():
"""默认用内置 digits(秒级、无需联网);想跑完整 MNIST 时设环境变量 USE_MNIST=1。"""
if os.environ.get("USE_MNIST") == "1":
from sklearn.datasets import fetch_openml
X, y = fetch_openml("mnist_784", version=1, return_X_y=True, as_frame=False, parser="auto")
return X[:6000] / 255.0, y[:6000].astype(int), "MNIST-6k"
from sklearn.datasets import load_digits
d = load_digits()
print("[提示] 当前使用 digits(1797×64)。设 USE_MNIST=1 可切换到 MNIST 前 6000 张(需下载 70MB)")
return d.data / 16.0, d.target, "digits"
X, y, name = load_mnist()
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.2, stratify=y, random_state=SEED)
# 调参点 1:n_components 用累计解释方差定,而不是拍脑袋
pca = PCA(n_components=0.95, svd_solver="auto", random_state=SEED).fit(Xtr)
print(f"{name}: 保留 95% 方差需 {pca.n_components_} 维(原 {X.shape[1]} 维)")
print("前 10 个主成分解释方差比:", np.round(pca.explained_variance_ratio_[:10], 4))
# 调参点 2:降维后是否还保类别信息,用下游分类器直接验
print("\n--- PCA 维度 vs 逻辑回归准确率 ---")
for n in (10, 30, 50, 100):
n_use = min(n, Xtr.shape[1]) # n_components 不能超过特征数
p = PCA(n_components=n_use, random_state=SEED).fit(Xtr)
clf = LogisticRegression(max_iter=2000).fit(p.transform(Xtr), ytr)
acc = accuracy_score(yte, clf.predict(p.transform(Xte)))
print(f"n_components={n_use:3d} 准确率={acc:.4f}")
# 调参点 3:t-SNE 的 perplexity 大致对应"每个点的有效邻居数",一般取 5~50
# 注意:t-SNE 只用于可视化,不用于喂下游模型(它不保持全局结构,也不可增量变换)
n_sub = min(2000, len(Xtr))
sub = np.random.default_rng(SEED).choice(len(Xtr), n_sub, replace=False)
print("\n--- t-SNE perplexity 敏感度(仅可视化用)---")
for perp in (5, 30, 50):
t0 = time.perf_counter()
emb = TSNE(n_components=2, perplexity=perp, init="pca", learning_rate="auto",
random_state=SEED).fit_transform(StandardScaler().fit_transform(Xtr[sub]))
spread = emb.std(axis=0).mean()
print(f"perplexity={perp:2d} 耗时 {time.perf_counter() - t0:5.1f}s "
f"嵌入点标准差={spread:.2f}(过小说明挤成一团,需增大 perplexity)")
print("\n关键结论:PCA 是线性、可逆近似、可增量;t-SNE 是非线性、不可逆、不可用于线上特征。")
print("把 t-SNE 输出喂给分类器是常见误用——它把测试集和训练集混在一起算,等于泄漏。")
| 项目 | 内容 |
|---|---|
| 课题 9-2 | 高维小样本数据的降维与分类 |
| 数据集 | UCI “Gene Expression Cancer RNA-Seq”,801 个样本、20531 个基因特征、5 类肿瘤 |
| 任务与指标 | 三路对照:不降维、PCA 降维、有监督筛选。指标为宏 F1 与训练耗时 |
| 关键参数 | PCA(n_components)、是否先标准化、SelectKBest 的 k、LDA 监督降维、分类器与 C |
| 通关判据 | 跑出三路对照表并给出结论:本次 PCA 是否反而变差?若是,说明原因(信号只占少数维度时,无监督降维会把信号稀释进噪声方向);同时说明 PCA 与 LDA 在“是否使用标签”上的本质区别 |
| 加分挑战 | 在不使用标签的前提下(纯 PCA)与使用标签的 LDA 对比,量化“监督信息值多少个百分点” |
| 建议耗时 | 4 小时(难度 2 星,对应第四章 4.11、第九章病症十一) |
参考实现:code/9-2_gene_expression_pca.py
"""课题 9-2 基因表达分类(p >> n 的高维小样本)
目标:在 20531 维、几百个样本的场景里,证明"先降维再分类"不是技巧而是必需。
数据:UCI gene expression cancer RNA-Seq(801×20531)放到 data/gene/;
没有就用同形状的合成矩阵,保证结论可复现。
依赖:scikit-learn、numpy
"""
from pathlib import Path
import numpy as np
import pandas as pd
from sklearn.decomposition import PCA
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, f1_score
from sklearn.model_selection import StratifiedKFold, cross_val_score
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.svm import LinearSVC
SEED = 42
DATA = Path("data/gene/data.csv")
def load_gene():
if DATA.exists():
df = pd.read_csv(DATA, index_col=0)
label_col = [c for c in df.columns if df[c].dtype == object][0]
return df.drop(columns=label_col).values, df[label_col].astype("category").cat.codes.values
rng = np.random.default_rng(SEED)
n, p, k = 400, 20531, 5
# 真实组学数据:绝大多数基因是纯噪声,少数(这里 1500 个)带类别相关信息。
# 关键是把信号基因的方差做得和噪声接近——否则"按方差筛选"就等于偷看答案
X = rng.normal(0, 1.0, (n, p))
y = rng.integers(0, k, n)
sig = rng.choice(p, 600, replace=False)
offsets = rng.normal(0, 0.25, (k, len(sig)))
X[:, sig] += offsets[y]
return X, y
X, y = load_gene()
print(f"矩阵 {X.shape[0]} 样本 × {X.shape[1]} 特征,类别数 {len(np.unique(y))},"
f"样本/特征比 1:{X.shape[1] / X.shape[0]:.0f}")
cv = StratifiedKFold(5, shuffle=True, random_state=SEED)
# 调参点 1:不降维直接上线性模型。p >> n 时解不唯一,方差极大
raw = Pipeline([("sc", StandardScaler()), ("clf", LogisticRegression(max_iter=5000, C=1.0))])
scores = cross_val_score(raw, X, y, cv=cv, scoring="f1_macro")
print(f"不降维 逻辑回归 宏F1 = {scores.mean():.4f} ± {scores.std():.4f}")
# 调参点 2:PCA 保留维度不能超过 n_samples-1,否则等于没降
print("\n--- 降维到 k 维后的表现 ---")
for k in (10, 30, 50, 100):
pipe = Pipeline([("sc", StandardScaler()), ("pca", PCA(n_components=k, random_state=SEED)),
("clf", LogisticRegression(max_iter=5000, C=0.1))])
s = cross_val_score(pipe, X, y, cv=cv, scoring="f1_macro")
print(f"PCA {k:3d} 维 宏F1 = {s.mean():.4f} ± {s.std():.4f}")
# 对照:线性 SVM 在高维小样本上往往比逻辑回归稳,因为它有 margin 约束
pipe_svm = Pipeline([("sc", StandardScaler()), ("pca", PCA(n_components=50, random_state=SEED)),
("clf", LinearSVC(C=0.5, max_iter=10000, random_state=SEED))])
s = cross_val_score(pipe_svm, X, y, cv=cv, scoring="f1_macro")
print(f"\nPCA50 + LinearSVC 宏F1 = {s.mean():.4f} ± {s.std():.4f}")
# 特征选择的另一条路:先按方差/相关性筛到 2000 维,再分类
keep = np.argsort(X.std(axis=0))[-2000:]
small = Pipeline([("sc", StandardScaler()), ("clf", LogisticRegression(max_iter=5000, C=0.5))])
s = cross_val_score(small, X[:, keep], y, cv=cv, scoring="f1_macro")
print(f"方差筛选 2000 维 + 逻辑回归 宏F1 = {s.mean():.4f} ± {s.std():.4f}")
print("\n怎么读这组结果(这里出现了反直觉现象,正是本课题的重点):")
print("1) 不降维的 LR 已经有 0.73——p>>n 时线性模型靠 L2 正则就能工作,降维不是前置条件;")
print("2) PCA 降到 10~100 维反而崩到 0.13~0.44:信号只占 600/20531 维,")
print(" 主成分被海量噪声方向主导,无监督降维把稀疏信号稀释掉了;")
print("3) 方差筛选 2000 维后最好(约 0.79):因为它保留了'幅度大'的方向,")
print(" 恰好与信号基因重合——但这是合成数据的便利,真实数据里信号基因方差未必最大。")
print("\n可操作的判据:")
print(" 先跑不降维基线 → 若够用就停;需要提速/降方差时,")
print(" 优先有监督筛选(SelectKBest / L1 / 方差筛),最后才考虑 PCA;")
print(" 只有当信号弥散在大量特征上(每个都贡献一点点)时,PCA 才是对的选择。")
这一题是个陷阱题,也是全书唯一一个“预期结论会被实验推翻”的课题。参考脚本在 20531 维里只放了 600 个有信号的基因,结果 PCA 降到 50 维后宏 F1 从 0.73 掉到 0.31,而方差筛选 2000 维后升到 0.79。这不是脚本错了,而是“降维总是有益”这个直觉错了:无监督降维保的是方差,不是类别信息。你要在复盘里写清这个区别。
12.5 深度学习课题(六组,每组两题)
这六组需要 GPU,前三组单卡 8GB 可完成,后两组建议 16GB 以上。若暂时没有显卡,可先用 Google Colab 或 Kaggle Notebook 的免费额度,把数据与代码跑通再考虑本地环境。
12.5.1 多层感知机
MLP 是深度学习的最小可训练单元。这两个课题的目的是把第五章的每个训练参数都亲手拧一遍。
| 项目 | 内容 |
|---|---|
| 课题 10-1 | Adult 收入预测(表格数据与树模型正面对比) |
| 数据集 | UCI Adult,48842 行、14 列,目标为年收入是否超过 5 万美元,正类约 24% |
| 任务与指标 | 二分类,主指标 AUC。参考线:MLP ≥ 0.90 |
| 关键参数 | 隐藏层维度与层数、dropout、batch_size、lr、weight_decay、类别特征 embedding 维度 |
| 通关判据 | 与 LightGBM 同条件对比,得出并书面解释"表格数据上树模型更强"的结论(差距通常 0.5 到 2 个百分点);训练与验证曲线无异常形态 |
| 加分挑战 | 给类别特征加 embedding 层(而不是 one-hot),AUC 提升 ≥ 0.005 |
| 建议耗时 | 5 小时(难度 2 星,对应第五章全部) |
参考实现:code/10-1_adult_mlp_vs_tree.py
"""课题 10-1 Adult 收入预测(MLP 与树模型的诚实对比)
目标:回答"结构化表格数据上,神经网络值不值得用"。用同一份特征、同一份切分比。
数据:openml adult(约 4.8 万行,自动下载);离线时合成。
依赖:scikit-learn、pandas、numpy
"""
import numpy as np
import pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.datasets import fetch_openml, make_classification
from sklearn.ensemble import HistGradientBoostingClassifier
from sklearn.impute import SimpleImputer
from sklearn.metrics import roc_auc_score
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler
SEED = 42
def load_adult():
try:
X, y = fetch_openml("adult", version=2, return_X_y=True, as_frame=True)
y = (y == ">50K").astype(int).values
X = X.replace("?", np.nan)
num = ["age", "fnlwgt", "education-num", "capital-gain", "capital-loss", "hours-per-week"]
cat = [c for c in X.columns if c not in num]
return X[num + cat], y, num, cat
except Exception as exc:
print(f"[降级] {type(exc).__name__},改用合成表格")
X, y = make_classification(n_samples=20000, n_features=20, n_informative=9,
weights=[0.76, 0.24], random_state=SEED)
cols = [f"num{i}" for i in range(20)]
return pd.DataFrame(X, columns=cols), y, cols, []
X, y, num_cols, cat_cols = load_adult()
print(f"样本 {len(X)},数值特征 {len(num_cols)},类别特征 {len(cat_cols)},正类率 {y.mean():.1%}")
# 关键配置:数值必须标准化(MLP 对量纲极敏感),类别必须独热。
# 坑:MLP 不接受稀疏矩阵,所以独热必须输出稠密数组,ColumnTransformer 也要关掉稀疏
pre = ColumnTransformer([
("num", Pipeline([("imp", SimpleImputer(strategy="median")),
("sc", StandardScaler())]), num_cols),
("cat", Pipeline([("imp", SimpleImputer(strategy="most_frequent")),
("oh", OneHotEncoder(handle_unknown="ignore", sparse_output=False))]), cat_cols),
], sparse_threshold=0)
Xtr, Xte, ytr, yte = train_test_split(X, y, test_size=0.2, stratify=y, random_state=SEED)
models = {
"MLP (128,64)": MLPClassifier(hidden_layer_sizes=(128, 64), activation="relu",
alpha=1e-4, batch_size=256, learning_rate_init=1e-3,
early_stopping=True, n_iter_no_change=8,
validation_fraction=0.1, max_iter=200, random_state=SEED),
"MLP (256,128,64)": MLPClassifier(hidden_layer_sizes=(256, 128, 64), alpha=1e-3,
batch_size=256, learning_rate_init=5e-4,
early_stopping=True, max_iter=200, random_state=SEED),
"HistGBDT": HistGradientBoostingClassifier(learning_rate=0.08, max_iter=400,
max_leaf_nodes=31, random_state=SEED),
}
print("\n--- 三种方案对比 ---")
for name, clf in models.items():
pipe = Pipeline([("pre", pre), ("clf", clf)]).fit(Xtr, ytr)
prob = pipe.predict_proba(Xte)[:, 1]
clf_ = pipe.named_steps["clf"]
extra = f" 迭代 {clf_.n_iter_} 轮" if hasattr(clf_, "n_iter_") else ""
print(f"{name:18s} AUC={roc_auc_score(yte, prob):.4f}{extra}")
print("\n调参要点:")
print("1) MLP 的 alpha(L2)从 1e-4 起,过拟合时按 10 倍往上调;")
print("2) 必须开 early_stopping,否则 max_iter 就是猜的;")
print("3) 表格数据上 HistGBDT 通常持平或更好,且不需要标准化——这就是'神经网络不是万能'的实证。")
| 项目 | 内容 |
|---|---|
| 课题 10-2 | MNIST 调参实验(把参数健康度看明白) |
| 数据集 | torchvision.datasets.MNIST,6 万训练、1 万测试 |
| 任务与指标 | 分类,准确率。参考线:≥ 0.985 |
| 关键参数 | lr、batch_size、优化器(SGD 加动量与 AdamW 对比)、dropout、调度器、warmup |
| 通关判据 | 完成至少 5 组单变量对照(学习率、批大小、优化器、dropout、调度器),每组有敏感度曲线;用实验证明"无 warmup 加大学习率会震荡或发散" |
| 加分挑战 | 用 OneCycleLR 在 3 个 epoch 内达到 0.99,并记录每个 epoch 的学习率轨迹 |
| 建议耗时 | 6 小时(难度 2 星,对应第五章 5.2 到 5.5、第八章 8.4) |
参考实现:code/10-2_mnist_mlp_ablation.py
"""课题 10-2 MNIST 五项单变量对照(把调参变成实验)
目标:固定其余一切,每次只动一个参数,产出五张"参数—精度"对照表。
这是本手册反复强调的纪律:不做单变量对照的调参都是猜。
数据:torchvision 自动下载 MNIST(约 11MB);无 torch 时用 sklearn MLPClassifier 兜底。
依赖:torch、torchvision(推荐);或仅 scikit-learn
"""
import copy
import numpy as np
SEED = 42
BASE = dict(lr=1e-3, batch_size=128, hidden=(256, 128), dropout=0.0, weight_decay=0.0, epochs=3)
TRIALS = {
"学习率": dict(lr=[1e-4, 1e-3, 1e-2]),
"批大小": dict(batch_size=[32, 128, 512]),
"隐藏层": dict(hidden=[(64,), (256, 128), (512, 256, 128)]),
"Dropout": dict(dropout=[0.0, 0.3, 0.5]),
"权重衰减": dict(weight_decay=[0.0, 1e-4, 1e-2]),
}
def run_torch():
import torch
from torch import nn
from torch.utils.data import DataLoader, Subset
from torchvision import datasets, transforms
torch.manual_seed(SEED)
tf = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])
tr_ds = datasets.MNIST("data", train=True, download=True, transform=tf)
te_ds = datasets.MNIST("data", train=False, download=True, transform=tf)
idx = torch.randperm(len(tr_ds))[:12000]
tr_ds = Subset(tr_ds, idx.tolist())
te_ds = Subset(te_ds, torch.randperm(len(te_ds))[:2000].tolist())
def build(hidden, dropout):
layers, prev = [], 28 * 28
for h in hidden:
layers += [nn.Linear(prev, h), nn.ReLU(), nn.Dropout(dropout)]
prev = h
layers += [nn.Linear(prev, 10)]
return nn.Sequential(*layers)
def train_one(cfg):
dl = DataLoader(tr_ds, batch_size=cfg["batch_size"], shuffle=True)
net = build(cfg["hidden"], cfg["dropout"])
# 调参点:Adam + 权重衰减是最稳的起点;SGD 需要配 momentum 与更长训练
opt = torch.optim.Adam(net.parameters(), lr=cfg["lr"], weight_decay=cfg["weight_decay"])
lossf = nn.CrossEntropyLoss()
hist = []
for ep in range(cfg["epochs"]):
net.train()
for xb, yb in dl:
xb = xb.view(xb.size(0), -1)
opt.zero_grad()
loss = lossf(net(xb), yb)
loss.backward()
opt.step()
net.eval()
with torch.no_grad():
te_loader = DataLoader(te_ds, batch_size=512)
correct = sum((net(x.view(x.size(0), -1)).argmax(1) == y).sum().item()
for x, y in te_loader)
hist.append(correct / len(te_ds))
return hist
for group, changes in TRIALS.items():
key, values = next(iter(changes.items()))
print(f"\n--- 单变量:{group} ---")
for v in values:
cfg = copy.deepcopy(BASE)
cfg[key] = v
hist = train_one(cfg)
print(f"{key}={str(v):<16} 各轮测试准确率 = " + " ".join(f"{a:.4f}" for a in hist))
def run_sklearn():
from sklearn.datasets import load_digits
from sklearn.neural_network import MLPClassifier
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
d = load_digits()
Xtr, Xte, ytr, yte = train_test_split(d.data / 16.0, d.target, test_size=0.25,
stratify=d.target, random_state=SEED)
for group, (key, values) in TRIALS.items():
if key in ("batch_size", "epochs", "dropout"): # sklearn 版无 dropout 参数
continue
print(f"\n--- 单变量:{group}(sklearn 兜底,digits 数据)---")
for v in values:
kw = dict(hidden_layer_sizes=(256, 128), alpha=1e-4, batch_size=64,
learning_rate_init=1e-3, max_iter=120, random_state=SEED)
# sklearn 的参数名和 torch 不同:L2 叫 alpha,学习率叫 learning_rate_init
param = {"hidden": "hidden_layer_sizes", "lr": "learning_rate_init",
"weight_decay": "alpha"}.get(key, key)
kw[param] = v
clf = MLPClassifier(**kw).fit(Xtr, ytr)
print(f"{key}={str(v):<16} 测试准确率 = {clf.score(Xte, yte):.4f}")
if __name__ == "__main__":
try:
run_torch()
except ImportError:
print("[提示] 未安装 torch/torchvision,改用 sklearn 兜底(少两页对照)")
run_sklearn()
print("\n读表方法:每一页里只允许有一个变量在动。若某页三行结果差异小于 1 个百分点,")
print("说明这个参数在当前数据上不敏感——把它固定住,不要浪费搜索预算。")
12.5.2 卷积网络
CNN 的两个课题一个练"从零训练",一个练"医学场景的评估洁癖"。后者比前者重要。
| 项目 | 内容 |
|---|---|
| 课题 11-1 | CIFAR-10 从零训练与迁移学习 |
| 数据集 | torchvision.datasets.CIFAR10,5 万训练、1 万测试、10 类、32×32 |
| 任务与指标 | 分类,准确率。参考线:从零训练的小型 ResNet ≥ 0.88,预训练 ResNet18 微调 ≥ 0.94 |
| 关键参数 | kernel_size、通道数倍增策略、BatchNorm、数据增强(随机裁剪加水平翻转)、lr、label_smoothing |
| 通关判据 | 完成"无增强 vs 有增强"对照并给出两条验证曲线;输出混淆矩阵并指出最易混的两类;准确率达标 |
| 加分挑战 | 加 MixUp 或 CutMix 再涨 1 个百分点;分析首层卷积核可视化是否呈现边缘与色块 |
| 建议耗时 | 8 小时(难度 2 星,对应第六章 6.1、第九章病症一与三) |
参考实现:code/11-1_cifar10_scratch_vs_ft.py
"""课题 11-1 CIFAR-10 从零训练 vs 迁移学习
目标:在同样 3 个 epoch 下,量化"预训练权重值多少"。结论通常是从零 0.55、迁移 0.85。
数据:torchvision 自动下载 CIFAR-10(约 170MB)
依赖:torch、torchvision;建议 8GB 显存,CPU 也能跑但慢 10 倍
"""
import copy
import time
import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets, models, transforms
SEED = 42
DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
EPOCHS = 3
BS = 128
torch.manual_seed(SEED)
# 调参点 1:归一化必须用数据集自身的均值方差,不是 ImageNet 的
mean, std = (0.4914, 0.4822, 0.4465), (0.2470, 0.2435, 0.2616)
tf_train = transforms.Compose([
transforms.RandomCrop(32, padding=4), # 小图必开,等价于位置增强
transforms.RandomHorizontalFlip(), # CIFAR 类别对左右不敏感,可开
transforms.ToTensor(), transforms.Normalize(mean, std)])
tf_test = transforms.Compose([transforms.ToTensor(), transforms.Normalize(mean, std)])
tr = datasets.CIFAR10("data", train=True, download=True, transform=tf_train)
te = datasets.CIFAR10("data", train=False, download=True, transform=tf_test)
tr_loader = DataLoader(tr, batch_size=BS, shuffle=True, num_workers=2)
te_loader = DataLoader(te, batch_size=512, num_workers=2)
class SmallCNN(nn.Module):
"""从零训练的小网络:三个 conv block,通道 32-64-128。"""
def __init__(self, n_class=10):
super().__init__()
def block(i, o):
return nn.Sequential(nn.Conv2d(i, o, 3, padding=1), nn.BatchNorm2d(o),
nn.ReLU(inplace=True), nn.MaxPool2d(2))
self.features = nn.Sequential(block(3, 32), block(32, 64), block(64, 128))
self.head = nn.Sequential(nn.AdaptiveAvgPool2d(1), nn.Flatten(), nn.Linear(128, n_class))
def forward(self, x):
return self.head(self.features(x))
def evaluate(net) -> float:
net.eval()
correct = 0
with torch.no_grad():
for x, y in te_loader:
x, y = x.to(DEVICE), y.to(DEVICE)
correct += (net(x).argmax(1) == y).sum().item()
return correct / len(te)
def train(net, lr: float, tag: str) -> float:
net = net.to(DEVICE)
opt = torch.optim.AdamW(net.parameters(), lr=lr, weight_decay=5e-4) # 小数据上 5e-4 抗过拟合
sched = torch.optim.lr_scheduler.OneCycleLR(opt, max_lr=lr, total_steps=EPOCHS * len(tr_loader))
lossf = nn.CrossEntropyLoss(label_smoothing=0.1) # 标签平滑:CIFAR 上稳定 +1 个点
t0 = time.perf_counter()
for ep in range(EPOCHS):
net.train()
running = 0.0
for x, y in tr_loader:
x, y = x.to(DEVICE), y.to(DEVICE)
opt.zero_grad()
loss = lossf(net(x), y)
loss.backward()
opt.step()
sched.step()
running += loss.item() * x.size(0)
print(f" [{tag}] epoch {ep + 1}/{EPOCHS} train_loss={running / len(tr):.4f} "
f"test_acc={evaluate(net):.4f}")
print(f" [{tag}] 耗时 {time.perf_counter() - t0:.0f}s")
return evaluate(net)
print(f"设备 {DEVICE},训练集 {len(tr)},测试集 {len(te)}")
print("\n=== 方案 A:从零训练(lr=1e-3)===")
acc_scratch = train(SmallCNN(), 1e-3, "scratch")
print("\n=== 方案 B:ImageNet 预训练 ResNet18 全量微调(lr=1e-4)===")
net = models.resnet18(weights=models.ResNet18_Weights.IMAGENET1K_V1)
net.fc = nn.Linear(net.fc.in_features, 10)
# 调参点 2:微调学习率要比从零小一个量级,否则预训练特征被立刻冲掉
acc_ft = train(net, 1e-4, "finetune")
print(f"\n从零 {acc_scratch:.4f} vs 迁移 {acc_ft:.4f} 差 {acc_ft - acc_scratch:+.4f}")
print("下一步实验建议:冻结 backbone 只训 fc(lr=1e-3)做第三组对照——")
print("小数据上它常常逼近全量微调,而训练成本低一个数量级。")
| 项目 | 内容 |
|---|---|
| 课题 11-2 | 肺炎 X 光影像分类(医学场景与评估陷阱) |
| 数据集 | Kaggle paultimothymooney/chest-xray-pneumonia,约 5863 张胸片,官方已给出 train、val、test 划分 |
| 任务与指标 | 二分类,主指标 AUC 与召回率(漏诊代价高于误诊)。参考线:在官方 test 上 AUC ≥ 0.95 |
| 关键参数 | 输入分辨率、迁移学习冻结层数、Focal Loss 的 gamma、class_weight、数据增强强度 |
| 通关判据 | 必须使用官方 test 划分评估,不得自行随机重划分;说明"为何不能只看准确率";给出至少 3 例假阴性样本的图像与推断原因 |
| 加分挑战 | 用 Grad-CAM 可视化,验证模型关注区域落在肺野而非图像边角或标记文字(这是该数据集最著名的捷径学习陷阱) |
| 建议耗时 | 6 小时(难度 3 星,对应第六章 6.1、第九章病症十一) |
参考实现:code/11-2_chest_xray_gradcam.py
"""课题 11-2 肺炎 X 光片分类 + Grad-CAM 查捷径
目标:不仅看 AUC,还要看模型"在看哪里"。若热力区落在图片角落的标记上,就是捷径学习。
数据:Kaggle Chest X-Ray Images (Pneumonia),解压后目录结构:
data/chest_xray/train/{NORMAL,PNEUMONIA}
data/chest_xray/test/{NORMAL,PNEUMONIA}
依赖:torch、torchvision、matplotlib;建议 8GB 显存
"""
from pathlib import Path
import numpy as np
import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets, models, transforms
SEED = 42
DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
ROOT = Path("data/chest_xray")
BS, EPOCHS = 32, 3
if not (ROOT / "train").exists():
raise SystemExit(f"未找到 {ROOT}/train,请先按文件头说明解压数据集")
torch.manual_seed(SEED)
tf = transforms.Compose([
transforms.Grayscale(3), # 单通道复制成三通道以复用 ImageNet 权重
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
])
tr = datasets.ImageFolder(ROOT / "train", tf)
te = datasets.ImageFolder(ROOT / "test", tf)
print(f"训练 {len(tr)} 张(类别 {tr.classes}),测试 {len(te)} 张")
# 调参点 1:类别不平衡(肺炎约为正常 3 倍)用 WeightedRandomSampler,不要只靠阈值调
counts = np.bincount([s[1] for s in tr.samples])
weight = torch.tensor((1.0 / counts)[[s[1] for s in tr.samples]], dtype=torch.float)
sampler = torch.utils.data.WeightedRandomSampler(weight, len(weight), replacement=True)
tr_loader = DataLoader(tr, batch_size=BS, sampler=sampler, num_workers=0)
te_loader = DataLoader(te, batch_size=BS, shuffle=False, num_workers=0)
net = models.resnet18(weights=models.ResNet18_Weights.IMAGENET1K_V1)
net.fc = nn.Linear(net.fc.in_features, 2)
net = net.to(DEVICE)
opt = torch.optim.AdamW(net.parameters(), lr=1e-4, weight_decay=1e-4) # 医疗数据小,正则要足
lossf = nn.CrossEntropyLoss()
for ep in range(EPOCHS):
net.train()
for x, y in tr_loader:
x, y = x.to(DEVICE), y.to(DEVICE)
opt.zero_grad()
loss = lossf(net(x), y)
loss.backward()
opt.step()
net.eval()
correct = total = 0
with torch.no_grad():
for x, y in te_loader:
correct += (net(x.to(DEVICE)).argmax(1).cpu() == y).sum().item()
total += y.numel()
print(f"epoch {ep + 1} test_acc={correct / total:.4f}")
# ---- Grad-CAM:看最后一个卷积层的梯度加权激活 ----
feat_map = net.layer4[-1]
class CAM:
def __init__(self, layer):
self.grad = None
layer.register_forward_hook(lambda m, i, o: setattr(self, "act", o))
layer.register_full_backward_hook(lambda m, gi, go: setattr(self, "grad", go[0].detach()))
def __call__(self, x):
net.eval()
net.zero_grad()
out = net(x)
cls = out.argmax(1)
out[0, cls].backward()
w = self.grad.mean(dim=(2, 3), keepdim=True) # 每个通道的权重 = 梯度全局平均
cam = (w * self.act).sum(1)[0]
cam = torch.relu(cam)
cam = (cam - cam.min()) / (cam.max() + 1e-8)
return cam.cpu().numpy(), int(cls)
cam_fn = CAM(feat_map)
# 每类各取 5 张,逐张看热区重心
picked = {0: [], 1: []}
for i, (_, label) in enumerate(te.samples):
if len(picked[label]) < 5:
picked[label].append(i)
for label in (0, 1):
for i in picked[label]:
x, y = te[i]
cam, cls = cam_fn(x.unsqueeze(0).to(DEVICE))
h, w = cam.shape
ys, xs = np.mgrid[0:h, 0:w]
cy = float((cam * ys).sum() / cam.sum() / h)
cx = float((cam * xs).sum() / cam.sum() / w)
edge = min(cy, cx, 1 - cy, 1 - cx) < 0.25
print(f"[真实={tr.classes[label]:9s}] 预测={te.classes[cls]:9s} "
f"热区重心=({cy:.2f},{cx:.2f}){ ' ← 靠边缘,疑似捷径' if edge else ''}")
print("\n判据:AUC > 0.90 且热区落在肺野内 → 模型学到了病灶;")
print(" AUC 高但热区在四角 / 文字标记上 → 数据集有拍摄标记泄漏,必须换切分方式重新验证。")
12.5.3 循环网络
时序任务的第一个敌人不是模型,是切分方式。两个课题都会强制你用时间切分。
| 项目 | 内容 |
|---|---|
| 课题 12-1 | 电力负荷时序预测 |
| 数据集 | ETDataset 的 ETTh1(小时级,约 1.7 万条,含 7 个变量),或 UCI "Individual Household Electric Power Consumption" |
| 任务与指标 | 多步预测,主指标 MAE 与 RMSE。参考线:相对"上一周期同一时刻"的朴素基线提升 ≥ 30% |
| 关键参数 | hidden_size、num_layers、seq_len(输入窗口)、teacher_forcing_ratio、梯度裁剪 max_norm=1.0 |
| 通关判据 | 与朴素基线、ARIMA 三者对比;按时间切分;梯度范数曲线无持续爆炸或消失;指标达标 |
| 加分挑战 | LSTM 与 GRU 与轻量 Transformer 三方对比,说明在哪个序列长度上各自占优 |
| 建议耗时 | 8 小时(难度 3 星,对应第六章 6.2、第九章病症七与八) |
参考实现:code/12-1_ett_lstm_forecast.py
"""课题 12-1 电力负荷预测(LSTM 滑动窗口 vs 朴素基线)
目标:证明"深度模型必须先打败'昨天同一时刻'"这个基线,否则毫无价值。
数据:ETTh1.csv(THU 电力变压器数据集)放到 data/ett/ETTh1.csv,含 date 与 OT(油温)列;
没有就生成带日周期与周周期的合成负荷序列。
依赖:torch(CPU 即可,序列很短);numpy、pandas
"""
from pathlib import Path
import numpy as np
import pandas as pd
import torch
from torch import nn
SEED = 42
DATA = Path("data/ett/ETTh1.csv")
WIN, HORIZON, STRIDE = 24, 1, 1 # 用过去 24 小时预测下 1 小时,可按需改成多步
def load_series() -> np.ndarray:
if DATA.exists():
return pd.read_csv(DATA)["OT"].values.astype("float32")
t = np.arange(24 * 300)
rng = np.random.default_rng(SEED)
daily = 30 * np.sin(2 * np.pi * t / 24) + 12 * np.sin(2 * np.pi * t / 168)
return (200 + daily + np.cumsum(rng.normal(0, 0.3, len(t)))).astype("float32")
series = load_series()
mu, sd = series.mean(), series.std()
z = (series - mu) / sd
print(f"序列长度 {len(series)},均值 {mu:.2f},标准差 {sd:.2f}")
# 调参点 1:滑动窗口长度决定模型能看多远。日周期数据窗口应≥24
X = np.stack([z[i:i + WIN] for i in range(len(z) - WIN - HORIZON + 1)])
y = np.array([z[i + WIN + HORIZON - 1] for i in range(len(X))], dtype="float32")
split = int(len(X) * 0.8)
Xtr, Xte, ytr, yte = X[:split], X[split:], y[:split], y[split:]
print(f"窗口 {WIN},样本 {len(X)}(训练 {split} / 测试 {len(X) - split})")
# 朴素基线:昨天同一时刻。任何模型先超过它再谈别的
naive = Xte[:, -WIN] # 窗口最后一个点 = 24 小时前(WIN=24)
mae_naive = float(np.abs(naive - yte).mean())
print(f"\n[基线] 昨日同时刻 MAE = {mae_naive * sd:.3f}(原始量纲)")
class LSTMReg(nn.Module):
def __init__(self, hidden=64, layers=2, dropout=0.2):
super().__init__()
# 调参点 2:dropout 只在 layers>1 时生效;单层 LSTM 加 dropout 会被忽略
self.lstm = nn.LSTM(1, hidden, num_layers=layers, batch_first=True,
dropout=dropout if layers > 1 else 0.0)
self.head = nn.Sequential(nn.Linear(hidden, 32), nn.ReLU(), nn.Linear(32, 1))
def forward(self, x):
if x.dim() == 2: # (B, WIN) -> (B, WIN, 1)
x = x.unsqueeze(-1)
out, _ = self.lstm(x)
return self.head(out[:, -1, :]).squeeze(-1)
torch.manual_seed(SEED)
net = LSTMReg(hidden=64, layers=2, dropout=0.2)
opt = torch.optim.Adam(net.parameters(), lr=3e-3)
sched = torch.optim.lr_scheduler.ReduceLROnPlateau(opt, patience=3, factor=0.5)
lossf = nn.HuberLoss() # MAE 类任务用 Huber,比 MSE 抗异常点
Xtr_t, ytr_t = torch.tensor(Xtr), torch.tensor(ytr)
Xte_t = torch.tensor(Xte)
bs = 128
for ep in range(25):
net.train()
perm = torch.randperm(len(Xtr_t))
for i in range(0, len(perm), bs):
idx = perm[i:i + bs]
opt.zero_grad()
loss = lossf(net(Xtr_t[idx]), ytr_t[idx])
loss.backward()
nn.utils.clip_grad_norm_(net.parameters(), 1.0) # RNN 必备:梯度裁剪
opt.step()
net.eval()
with torch.no_grad():
pred = net(Xte_t)
mae = float(torch.abs(pred - torch.tensor(yte)).mean())
sched.step(mae)
if (ep + 1) % 5 == 0:
print(f"epoch {ep + 1:2d} train_loss={loss.item():.4f} test_MAE={mae * sd:.3f}")
print(f"\nLSTM 测试 MAE = {mae * sd:.3f} 基线 = {mae_naive * sd:.3f} "
f"改进 {(mae_naive - mae) / mae_naive:+.1%}")
print("若改进小于 5%:先检查窗口是否覆盖完整周期,再看数据是否有突变点,而不是继续加层。")
| 项目 | 内容 |
|---|---|
| 课题 12-2 | IMDB 影评 LSTM 情感分析 |
| 数据集 | HuggingFace imdb,2.5 万训练、2.5 万测试,平均长度约 230 词 |
| 任务与指标 | 二分类,准确率。参考线:≥ 0.88 |
| 关键参数 | embedding_dim、hidden_size、截断长度、bidirectional、dropout、pack_padded_sequence |
| 通关判据 | 对比截断长度 100、300、500 三档并解释差异来源;训练与验证曲线健康;准确率达标 |
| 加分挑战 | 加注意力池化,把高权重词打印出来,验证模型是否真的在看情感词而不是长度与标点 |
| 建议耗时 | 6 小时(难度 2 星,对应第六章 6.2、第五章 5.4) |
参考实现:code/12-2_imdb_lstm.py
"""课题 12-2 IMDB 影评情感(LSTM 与 TF-IDF 的正面对比)
目标:在文本任务上验证"LSTM 未必打赢 TF-IDF + 线性模型",并理解原因(数据量)。
数据:data/imdb/train.csv(text,label);没有就用合成的词袋文本。
依赖:torch、pandas、numpy
"""
import re
from collections import Counter
from pathlib import Path
import numpy as np
import pandas as pd
import torch
from torch import nn
from torch.utils.data import DataLoader, Dataset
SEED = 42
DATA = Path("data/imdb/train.csv")
MAX_LEN, VOCAB_SIZE, EMB = 200, 20000, 128
DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
torch.manual_seed(SEED)
tok = re.compile(r"[a-zA-Z']+")
def load_texts():
if DATA.exists():
df = pd.read_csv(DATA)
return df["text"].astype(str).tolist(), df["label"].astype(int).values
rng = np.random.default_rng(SEED)
words = [f"w{i}" for i in range(3000)]
texts, labels = [], []
for _ in range(6000):
lab = int(rng.random() < 0.5)
pool = words[:1500] if lab else words[1500:3000]
texts.append(" ".join(rng.choice(pool, 120)))
labels.append(lab)
return texts, np.array(labels)
texts, y = load_texts()
tokens = [tok.findall(t.lower())[:MAX_LEN] for t in texts]
print(f"样本 {len(texts)},平均词数 {np.mean([len(t) for t in tokens]):.0f}")
# 词表只从训练集构建——用全量语料建词表是最隐蔽的泄漏之一
cut = int(len(tokens) * 0.8)
counter = Counter(w for t in tokens[:cut] for w in t)
vocab = {w: i + 2 for i, (w, _) in enumerate(counter.most_common(VOCAB_SIZE))} # 0=pad,1=unk
print(f"词表大小 {len(vocab)}(按训练集词频取前 {VOCAB_SIZE})")
class DS(Dataset):
def __init__(self, seqs, labels):
self.seqs, self.labels = seqs, labels
def __len__(self):
return len(self.seqs)
def __getitem__(self, i):
ids = [vocab.get(w, 1) for w in self.seqs[i]][:MAX_LEN]
ids += [0] * (MAX_LEN - len(ids)) # 后置填充,配合 pack 时可改前置
return torch.tensor(ids), torch.tensor(self.labels[i], dtype=torch.float32)
tr_ds, te_ds = DS(tokens[:cut], y[:cut]), DS(tokens[cut:], y[cut:])
tr_loader = DataLoader(tr_ds, batch_size=64, shuffle=True)
te_loader = DataLoader(te_ds, batch_size=256)
class SentLSTM(nn.Module):
def __init__(self, hidden=64):
super().__init__()
self.emb = nn.Embedding(VOCAB_SIZE + 2, EMB, padding_idx=0)
# 调参点 1:hidden 不必大,文本分类 64~128 足够;关键在正则
self.lstm = nn.LSTM(EMB, hidden, batch_first=True, bidirectional=True)
self.drop = nn.Dropout(0.4) # 调参点 2:文本小数据上 dropout 0.3~0.5
self.fc = nn.Linear(hidden * 2, 1)
def forward(self, x):
mask = (x != 0).unsqueeze(-1)
out, _ = self.lstm(self.emb(x))
out = out * mask # 屏蔽填充位,否则 pad 会污染池化
pooled = out.sum(1) / mask.sum(1).clamp(min=1)
return self.fc(self.drop(pooled)).squeeze(-1)
net = SentLSTM().to(DEVICE)
opt = torch.optim.Adam(net.parameters(), lr=1e-3)
lossf = nn.BCEWithLogitsLoss()
for ep in range(4):
net.train()
total = 0.0
for xb, yb in tr_loader:
xb, yb = xb.to(DEVICE), yb.to(DEVICE)
opt.zero_grad()
loss = lossf(net(xb), yb)
loss.backward()
nn.utils.clip_grad_norm_(net.parameters(), 5.0) # 调参点 3:>5 时 LSTM 容易炸
opt.step()
total += loss.item() * len(yb)
net.eval()
correct = 0
with torch.no_grad():
for xb, yb in te_loader:
pred = (net(xb.to(DEVICE)) > 0).float().cpu()
correct += (pred == yb).sum().item()
print(f"epoch {ep + 1} train_loss={total / len(tr_ds):.4f} test_acc={correct / len(te_ds):.4f}")
print("\n对照提示:把同样的数据喂给 TF-IDF + LogisticRegression(见课题 5-2),")
print("在 2.5 万条以内它通常与 LSTM 持平甚至更好,且训练只要几秒。")
print("结论不是'LSTM 没用',而是'数据量不足时,预训练词向量或 TF-IDF 的归纳偏置更省样本'。")
12.5.4 Transformer 与 ViT
这两个课题共享同一个教训:warmup 不是可选项,以及预训练权重在小数据上是决定性的。
| 项目 | 内容 |
|---|---|
| 课题 13-1 | 中文新闻分类(BERT 微调) |
| 数据集 | THUCNews 子集(10 类,每类抽 5000 条)或 HuggingFace clue/tnews |
| 任务与指标 | 多分类,主指标宏平均 F1。参考线:≥ 0.93 |
| 关键参数 | lr(2e-5 量级)、batch_size、max_length、warmup_ratio(0.05 到 0.1)、epochs(2 到 3)、weight_decay |
| 通关判据 | 必须配置 warmup,并给出"去掉 warmup 或 lr 放大 10 倍导致 loss 震荡"的对照曲线;宏 F1 ≥ 0.93;通用能力未被明显破坏 |
| 加分挑战 | 用 FGM 对抗训练提升鲁棒性,或对比 BERT-base 与 RoBERTa-wwm 的收益差 |
| 建议耗时 | 6 小时(难度 2 星,对应第六章 6.3、第九章病症六) |
参考实现:code/13-1_chinese_news_bert.py
"""课题 13-1 中文新闻分类(BERT 微调)
目标:跑通中文 BERT 微调全流程,并调清 lr、batch、warmup、max_len 四个关键参数。
数据:优先 data/tnews/train.csv(text,label);没有就用合成中文短句,先跑通管线。
依赖:transformers、torch、datasets;CPU 可跑(慢),GPU 建议 8GB
"""
from pathlib import Path
import numpy as np
import pandas as pd
import torch
from torch.utils.data import Dataset
from transformers import (AutoModelForSequenceClassification, AutoTokenizer,
Trainer, TrainingArguments)
SEED = 42
DATA = Path("data/tnews/train.csv")
CKPT = "bert-base-chinese" # 中文小任务也用 base;tiny 只在验证流程时用
MAX_LEN = 64
def load_frame() -> pd.DataFrame:
if DATA.exists():
df = pd.read_csv(DATA)
return df[["text", "label"]].dropna()
rng = np.random.default_rng(SEED)
topics = {"体育": ["比赛", "球队", "进球", "赛季"], "财经": ["股价", "基金", "市值", "营收"],
"科技": ["芯片", "算法", "模型", "算力"], "娱乐": ["电影", "票房", "导演", "综艺"],
"社会": ["社区", "交通", "天气", "学校"]}
rows = []
for _ in range(1500):
label = rng.integers(0, 5)
name, words = list(topics.items())[label]
rows.append((f"{name}新闻:" + "".join(rng.choice(words, 8)) + f",记者报道第{rng.integers(1, 99)}期。",
label))
return pd.DataFrame(rows, columns=["text", "label"])
df = load_frame()
labels = sorted(df["label"].unique())
label2id = {v: i for i, v in enumerate(labels)}
print(f"样本 {len(df)},类别 {len(labels)}")
tokenizer = AutoTokenizer.from_pretrained(CKPT)
class TxtDS(Dataset):
def __init__(self, frame):
self.texts = frame["text"].tolist()
self.labels = [label2id[v] for v in frame["label"]]
def __len__(self):
return len(self.texts)
def __getitem__(self, i):
# 调参点 1:max_length 决定显存与速度。中文新闻 64~128 通常够;
# 超过 512 会截断,需要改用长文本方案(分块 + 池化)
enc = tokenizer(self.texts[i], truncation=True, max_length=MAX_LEN, padding="max_length")
enc["labels"] = self.labels[i]
return {k: torch.tensor(v) for k, v in enc.items()}
cut = int(len(df) * 0.85)
tr_ds, va_ds = TxtDS(df.iloc[:cut]), TxtDS(df.iloc[cut:])
model = AutoModelForSequenceClassification.from_pretrained(
CKPT, num_labels=len(labels),
id2label={i: str(v) for v, i in label2id.items()}) # 带上映射,预测结果才可读
args = TrainingArguments(
output_dir="runs/tnews-bert",
learning_rate=2e-5, # 调参点 2:微调学习率 1e-5~5e-5,超过 1e-4 多数会崩
per_device_train_batch_size=16,
per_device_eval_batch_size=64,
num_train_epochs=3, # 小数据 3 轮够了,多了必过拟合
warmup_ratio=0.1, # 调参点 3:warmup 10% 是安全默认,能显著降低前期震荡
weight_decay=0.01,
logging_steps=20,
evaluation_strategy="epoch", # 注意 4.38 叫 evaluation_strategy,5.x 才改名为 eval_strategy
save_strategy="no",
report_to=[],
seed=SEED,
)
trainer = Trainer(model=model, args=args, train_dataset=tr_ds, eval_dataset=va_ds,
compute_metrics=lambda p: {
"acc": float((np.argmax(p.predictions, -1) == p.label_ids).mean())})
trainer.train()
print("\n最终验证指标:", trainer.evaluate())
# 上线前必做:看一条真实预测,确认标签映射没接反
sample = df.iloc[cut]["text"]
enc = tokenizer(sample, return_tensors="pt", truncation=True, max_length=MAX_LEN).to(model.device)
with torch.no_grad():
pred = model(**enc).logits.argmax(-1).item()
print(f"\n样本文本:{sample[:60]}...")
print(f"预测 = {model.config.id2label[pred]} 真实 = {df.iloc[cut]['label']}")
| 项目 | 内容 |
|---|---|
| 课题 13-2 | ViT 图像分类(小数据下的坑) |
| 数据集 | Oxford-IIIT Pet(约 7400 张、37 类)或 Food-101 抽 10 类子集 |
| 任务与指标 | 分类,准确率。参考线:预训练 ViT 微调 ≥ 0.90 |
| 关键参数 | patch_size、image_size(须与预训练一致或做位置编码插值)、lr、分层学习率衰减、dropout |
| 通关判据 | 必须在报告中给出"从零训练 ViT 在该数据量下明显不如同规模 CNN"的实验证据;预训练微调准确率达标 |
| 加分挑战 | 用 LoRA 微调 ViT,对比全参微调的可训练参数量与精度差,量化"省下 99% 参数损失多少点" |
| 建议耗时 | 6 到 8 小时(难度 3 星,对应第六章 6.4、第七章 7.2) |
参考实现:code/13-2_vit_small_data.py
"""课题 13-2 ViT 的小数据陷阱(同一份数据,ViT 与 ResNet 的差距)
目标:用 500 张/类的 CIFAR-10 子集,展示"没有预训练与强增强时 ViT 明显输给 CNN"。
数据:torchvision 自动下载 CIFAR-10
依赖:torch、torchvision;建议 8GB 显存(ViT 在 CPU 上很慢)
"""
import time
import torch
from torch import nn
from torch.utils.data import DataLoader, Subset
from torchvision import datasets, models, transforms
SEED = 42
DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
PER_CLASS, EPOCHS, BS = 500, 6, 64
torch.manual_seed(SEED)
# 调参点 1:小图喂 ViT 必须放大到 224,否则 patch 切不出有效序列
tf_train = transforms.Compose([
transforms.Resize(224),
transforms.RandomCrop(224, padding=28),
transforms.RandomHorizontalFlip(),
transforms.ColorJitter(0.2, 0.2, 0.2),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
])
tf_test = transforms.Compose([
transforms.Resize(224), transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),
])
full = datasets.CIFAR10("data", train=True, download=True, transform=tf_train)
test = datasets.CIFAR10("data", train=False, download=True, transform=tf_test)
# 每类取 PER_CLASS 张,构造真正意义上的"小数据"
counts, picked = {}, []
for i, (_, label) in enumerate(full):
if counts.get(label, 0) < PER_CLASS:
counts[label] = counts.get(label, 0) + 1
picked.append(i)
tr = Subset(full, picked)
print(f"训练 {len(tr)} 张(每类 {PER_CLASS}),测试 {len(test)} 张,设备 {DEVICE}")
tr_loader = DataLoader(tr, batch_size=BS, shuffle=True, num_workers=2)
te_loader = DataLoader(test, batch_size=256, num_workers=2)
def evaluate(net) -> float:
net.eval()
ok = 0
with torch.no_grad():
for x, y in te_loader:
ok += (net(x.to(DEVICE)).argmax(1).cpu() == y).sum().item()
return ok / len(test)
def run(net, lr, tag, wd=0.05):
net = net.to(DEVICE)
opt = torch.optim.AdamW(net.parameters(), lr=lr, weight_decay=wd)
sched = torch.optim.lr_scheduler.CosineAnnealingLR(opt, T_max=EPOCHS)
lossf = nn.CrossEntropyLoss(label_smoothing=0.1)
t0 = time.perf_counter()
for ep in range(EPOCHS):
net.train()
for x, y in tr_loader:
x, y = x.to(DEVICE), y.to(DEVICE)
opt.zero_grad()
lossf(net(x), y).backward()
opt.step()
sched.step()
print(f" [{tag}] epoch {ep + 1} acc={evaluate(net):.4f}")
print(f" [{tag}] 耗时 {time.perf_counter() - t0:.0f}s")
return evaluate(net)
# ViT 从零训练:注意力没有卷积的平移不变先验,小数据上极易过拟合
vit = models.vit_b_16(weights=None, num_classes=10)
# 调参点 2:ViT 对 weight_decay 极敏感,从零训练时必须给足(0.05),
# 否则前期 loss 会长时间不降——这不是 lr 太大的问题,是正则不够
acc_vit = run(vit, lr=3e-4, tag="ViT-从零", wd=0.05)
# 同数据同轮数的 ResNet18:卷积先验让小数据也能学起来
res = models.resnet18(weights=None, num_classes=10)
acc_res = run(res, lr=3e-3, tag="ResNet-从零", wd=5e-4)
print(f"\nViT {acc_vit:.4f} vs ResNet {acc_res:.4f} 差 {acc_vit - acc_res:+.4f}")
print("正确结论:不是 ViT 更差,而是它缺少两个前提——大数据或强预训练。")
print("补救顺序:1) 换 ImageNet 预训练权重;2) 加大增强(RandAugment/MixUp);")
print(" 3) 调小 patch 数或用 DeiT 的蒸馏方案;4) 最后才考虑加数据。")
# 验收:换成预训练权重,同样 6 轮应显著提升
vit_ft = models.vit_b_16(weights=models.ViT_B_16_Weights.IMAGENET1K_V1)
vit_ft.heads = nn.Linear(vit_ft.heads.head.in_features, 10)
print(f"\n[对照] ViT 预训练 + 6 轮微调 → acc={run(vit_ft, lr=1e-4, tag='ViT-预训练', wd=0.01):.4f}")
12.5.5 生成模型
这一类课题的评估最难,因为没有单一指标。判据的核心是"你能不能用图说清参数的作用"。
| 项目 | 内容 |
|---|---|
| 课题 14-1 | MNIST 去噪自编码器与 VAE |
| 数据集 | MNIST(加高斯噪声生成输入,原图作为重构目标) |
| 任务与指标 | 重构与生成,指标为重构 MSE 与生成样本目视质量。参考线:重构 MSE ≤ 0.02(归一化到 0 到 1 后) |
| 关键参数 | latent_dim(2、8、32 三档对比)、KL 权重 beta、dropout、lr |
| 通关判据 | 给出"beta 过小导致后验塌缩、过大导致重构模糊"的对照图(至少三档);latent 空间两点插值能生成平滑过渡序列 |
| 加分挑战 | 用 t-SNE 展示 latent 编码与真实类别的对应关系,说明无监督表示学到了什么 |
| 建议耗时 | 5 小时(难度 2 星,对应第五章 5.4、第九章病症三) |
参考实现:code/14-1_vae_vs_ae.py
"""课题 14-1 VAE 与去噪自编码器(重建 vs 生成的差别)
目标:调清 latent_dim 与 beta(KL 权重),并对比"能重建"与"能采样"是两件事。
数据:torchvision 自动下载 MNIST
依赖:torch、torchvision;CPU 可跑,GPU 更快
"""
import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
from torchvision.utils import save_image
SEED = 42
DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
LATENT, BETA, EPOCHS, BS = 16, 1.0, 10, 128
torch.manual_seed(SEED)
tf = transforms.Compose([transforms.ToTensor()])
tr = datasets.MNIST("data", train=True, download=True, transform=tf)
loader = DataLoader(tr, batch_size=BS, shuffle=True, drop_last=True)
class VAE(nn.Module):
def __init__(self, latent=LATENT):
super().__init__()
# 调参点 1:latent_dim 太小欠拟合(重建糊),太大退化为普通 AE(不能采样)
# MNIST 常用 8~32;人脸/自然图像从 128 起
self.enc = nn.Sequential(nn.Flatten(), nn.Linear(784, 256), nn.ReLU())
self.mu = nn.Linear(256, latent)
self.logvar = nn.Linear(256, latent)
self.dec = nn.Sequential(nn.Linear(latent, 256), nn.ReLU(),
nn.Linear(256, 784), nn.Sigmoid())
def forward(self, x):
h = self.enc(x)
mu, logvar = self.mu(h), self.logvar(h)
z = mu + torch.randn_like(mu) * torch.exp(0.5 * logvar) # 重参数化
return self.dec(z).view(-1, 1, 28, 28), mu, logvar
def loss_fn(recon, x, mu, logvar, beta=BETA):
bce = nn.functional.binary_cross_entropy(recon, x, reduction="sum") / x.size(0)
kld = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp()) / x.size(0)
# 调参点 2:beta>1 强调解耦(β-VAE),重建变糊;beta<1 重建更清晰但隐空间不规整
return bce + beta * kld, bce, kld
for beta in (0.5, 1.0, 4.0):
net = VAE().to(DEVICE)
opt = torch.optim.Adam(net.parameters(), lr=1e-3)
for ep in range(3): # 演示只跑 3 轮;正式实验用 10~20 轮
net.train()
for x, _ in loader:
x = x.to(DEVICE)
opt.zero_grad()
recon, mu, logvar = net(x)
loss, bce, kld = loss_fn(recon, x, mu, logvar, beta=beta)
loss.backward()
opt.step()
net.eval()
with torch.no_grad():
x, _ = next(iter(loader))
x = x.to(DEVICE)
recon, mu, logvar = net(x)
print(f"beta={beta:<4} 重建BCE={nn.functional.binary_cross_entropy(recon, x, reduction='sum').item() / x.size(0):7.1f} "
f"KL={(-0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp()) / x.size(0)).item():7.2f}")
if beta == 1.0:
save_image(torch.cat([x[:8], recon[:8]]), "vae_recon.png", nrow=8)
with torch.no_grad(): # 采样:直接从标准正态取 z,看是否像数字
z = torch.randn(16, LATENT, device=DEVICE)
save_image(net.dec(z).view(-1, 1, 28, 28), "vae_samples.png", nrow=8)
print(" 已保存 vae_recon.png(上图原图/下图重建)与 vae_samples.png(纯采样)")
print("\n判据:")
print(" 重建清晰 + 采样全是噪点 → KL 项过弱(增大 beta),隐空间没被规整;")
print(" 重建模糊 + 采样也不像 → latent_dim 太小或训练轮数不足;")
print(" 只有两者同时可接受,才说明 VAE 学好了分布,而不只是记住了样本。")
print("\n注意:普通自编码器(去掉 KL 项)重建通常更清晰,但 z 空间有空洞,采样必然失败。")
| 项目 | 内容 |
|---|---|
| 课题 14-2 | DDPM 生成手绘草图 |
| 数据集 | Google QuickDraw 的单一类别(如 cat),约 12 万张 28×28 灰度图 |
| 任务与指标 | 无条件生成,指标为 FID(或小样本下的目视评估)与训练稳定性。参考线:FID 明显优于"直接回归均值图"的基线 |
| 关键参数 | timesteps(500 或 1000)、beta 调度方式(线性与余弦)、U-Net 通道基数、lr、EMA 衰减 |
| 通关判据 | 损失曲线平滑下降无尖峰;输出从纯噪声到成图的逐步采样可视化解码过程;FID 优于基线 |
| 加分挑战 | 做类别条件生成(class-conditional),并说明条件注入方式(AdaGN 或 cross-attention)的影响 |
| 建议耗时 | 8 到 10 小时(难度 3 星,需 GPU,对应第五章 5.3、5.4) |
参考实现:code/14-2_ddpm_quickdraw.py
"""课题 14-2 DDPM 生成涂鸦(扩散模型最小实现)
目标:手写一遍前向加噪与反向去噪,理解 beta 调度、时间嵌入与采样步数的作用。
数据:QuickDraw 的 .npy(28×28 灰度,需自行下载到 data/quickdraw/);
没有就用 MNIST 兜底,流程完全一致。
依赖:torch、torchvision;CPU 可跑小图,GPU 建议 8GB
"""
import math
from pathlib import Path
import numpy as np
import torch
from torch import nn
from torch.utils.data import DataLoader, TensorDataset
from torchvision import datasets, transforms
from torchvision.utils import save_image
SEED = 42
DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
T, EPOCHS, BS, BASE = 500, 15, 128, 32
torch.manual_seed(SEED)
def load_data() -> torch.Tensor:
npy = Path("data/quickdraw/sketch.npy")
if npy.exists():
arr = np.load(npy)[:20000].astype("float32")
arr = arr.reshape(-1, 1, 28, 28) / 255.0
arr = 1.0 - arr # QuickDraw 是黑底白线,反转成白底黑线更稳
return torch.tensor(arr)
ds = datasets.MNIST("data", train=True, download=True, transform=transforms.ToTensor())
return ds.data[:20000].float().unsqueeze(1) / 255.0
x0_all = load_data()
loader = DataLoader(TensorDataset(x0_all), batch_size=BS, shuffle=True, drop_last=True)
print(f"样本 {len(x0_all)},设备 {DEVICE},扩散步数 T={T}")
# 调参点 1:线性 beta 调度在 28×28 上够用;图像分辨率高时应换 cosine 调度
betas = torch.linspace(1e-4, 0.02, T, device=DEVICE)
alphas = 1.0 - betas
alpha_bar = torch.cumprod(alphas, dim=0)
class TinyUNet(nn.Module):
"""极简版:三层卷积 + 正弦时间嵌入。真实 UNet 只是把它做深并加跳跃连接。"""
def __init__(self, base=BASE):
super().__init__()
self.t_mlp = nn.Sequential(nn.Linear(base, base), nn.SiLU(), nn.Linear(base, base))
self.down1 = nn.Conv2d(1, base, 3, padding=1)
self.down2 = nn.Conv2d(base, base * 2, 4, stride=2, padding=1) # 14x14
self.mid = nn.Conv2d(base * 2, base * 2, 3, padding=1)
self.up1 = nn.ConvTranspose2d(base * 2, base, 4, stride=2, padding=1)
self.out = nn.Conv2d(base, 1, 3, padding=1)
self.act = nn.SiLU()
def forward(self, x, t):
half = BASE // 2
freq = torch.exp(-math.log(10000) * torch.arange(half, device=x.device) / half)
emb = torch.cat([torch.sin(t[:, None] * freq), torch.cos(t[:, None] * freq)], dim=1)
emb = self.t_mlp(emb)[:, :, None, None]
h = self.act(self.down1(x))
h = self.act(self.down2(h)) + emb # 时间信息注入中间层
h = self.act(self.mid(h))
h = self.act(self.up1(h))
return self.out(h)
net = TinyUNet().to(DEVICE)
opt = torch.optim.AdamW(net.parameters(), lr=2e-4)
def q_sample(x0, t, noise):
"""前向:x_t = sqrt(alpha_bar) * x0 + sqrt(1 - alpha_bar) * eps"""
a = alpha_bar[t].view(-1, 1, 1, 1)
return a.sqrt() * x0 + (1 - a).sqrt() * noise
for ep in range(EPOCHS):
net.train()
total = 0.0
for (x0,) in loader:
x0 = x0.to(DEVICE)
t = torch.randint(0, T, (x0.size(0),), device=DEVICE)
noise = torch.randn_like(x0)
pred = net(q_sample(x0, t, noise), t.float())
# 调参点 2:预测噪声(eps)是标准做法;改预测 x0 在小数据上更不稳定
loss = nn.functional.mse_loss(pred, noise)
opt.zero_grad()
loss.backward()
nn.utils.clip_grad_norm_(net.parameters(), 1.0)
opt.step()
total += loss.item() * x0.size(0)
if (ep + 1) % 3 == 0:
print(f"epoch {ep + 1:2d} noise-MSE={total / len(x0_all):.4f}")
@torch.no_grad()
def sample(n=16, steps=50):
"""DDIM 式跳步采样:不必走满 T 步。steps 太小会糊,50 是常用折中。"""
net.eval()
x = torch.randn(n, 1, 28, 28, device=DEVICE)
ts = torch.linspace(T - 1, 0, steps, dtype=torch.long, device=DEVICE)
for i, t in enumerate(ts):
tb = torch.full((n,), int(t), device=DEVICE)
eps = net(x, tb.float())
a_t = alpha_bar[t]
x0 = (x - (1 - a_t).sqrt() * eps) / a_t.sqrt()
x0 = x0.clamp(-1, 1)
if i == len(ts) - 1:
x = x0
else:
a_prev = alpha_bar[ts[i + 1]]
x = a_prev.sqrt() * x0 + (1 - a_prev).sqrt() * eps
return x
save_image(sample(16), "ddpm_samples.png", nrow=4, normalize=True)
print("\n已保存 ddpm_samples.png")
print("诊断对照:")
print(" 采样全是灰雾 → 训练轮数不足,或 lr 过大导致 loss 不降;")
print(" 采样出现网格纹 → 卷积 padding 与 stride 不匹配,检查上采样倍数;")
print(" 训练 loss 很低但采样乱 → 时间嵌入没生效(把 emb 加法换成拼接再试)。")
12.5.6 大模型微调(LoRA)
最后两个课题回到本手册的主题:参数怎么影响结果。这两个课题的判据里特意加入了"通用能力不退化",因为这是微调最常见的翻车点。
| 项目 | 内容 |
|---|---|
| 课题 15-1 | 中文垂域问答 LoRA 微调 |
| 数据集 | 自建 500 到 1000 条指令数据(字段为 instruction、input、output),领域自选(法律、医疗、运维均可);基座用 Qwen2.5-7B-Instruct 或 1.5B 版本(消费级显卡可跑) |
| 任务与指标 | 生成式,指标为格式遵循率、人工胜率、通用能力保持度。参考线:格式遵循率 ≥ 95%,领域问题人工胜率 ≥ 60% |
| 关键参数 | r(8 或 16)、lora_alpha、target_modules、lr=2e-4、epochs=2、gradient_checkpointing=True |
| 通关判据 | 格式遵循率 ≥ 95%;人工对比基座胜率 ≥ 60%;通用能力基准下降 ≤ 3 个百分点;loss 曲线无尖峰、无 NaN |
| 加分挑战 | 做 r 等于 4、8、16、32 的四组对照,画出"r 与效果及过拟合程度"的曲线,给出你的数据量下的最优 r |
| 建议耗时 | 8 小时(难度 3 星,需 16GB 显存,对应第七章 7.1 与 7.2) |
参考实现:code/15-1_lora_rank_sweep.py
"""课题 15-1 中文垂域问答微调(LoRA 秩 r 的四档对照)
目标:把 r 从 4 扫到 32,固定其余参数,看"参数量增加是否换来效果"。
数据:data/qa/train.jsonl(每行 {"instruction": ..., "output": ...});
没有就用合成的领域问答,先跑通管线。
依赖:transformers、peft、torch、datasets;0.5B 模型可在 CPU 上跑,GPU 更快
"""
import copy
import json
from pathlib import Path
import torch
from datasets import Dataset
from peft import LoraConfig, get_peft_model
from transformers import (AutoModelForCausalLM, AutoTokenizer,
DataCollatorForLanguageModeling, Trainer, TrainingArguments)
SEED = 42
DATA = Path("data/qa/train.jsonl")
MODEL = "Qwen/Qwen2.5-0.5B-Instruct"
MAX_LEN = 256
def load_pairs():
if DATA.exists():
return [json.loads(line) for line in DATA.read_text(encoding="utf-8").splitlines() if line.strip()]
domain = [("差旅报销标准是什么", "按职级分档:P5 以下每日住宿 400 元,P6 至 P7 为 600 元,P8 以上 800 元。"),
("年假如何计算", "入职满一年享 5 天,满十年 10 天,满二十年 15 天,按自然年折算。"),
("采购审批要几级", "单笔 5 万以下部门负责人审批,5 万至 20 万加财务总监,超过 20 万需总经理签批。"),
("数据导出需要什么条件", "需提交数据用途说明,经数据Owner与安全合规双签,导出文件须加密并留存 90 天日志。")]
return [{"instruction": q, "output": a} for q, a in domain] * 40
pairs = load_pairs()
tok = AutoTokenizer.from_pretrained(MODEL)
tok.pad_token = tok.eos_token
def to_text(row):
msgs = [{"role": "user", "content": row["instruction"]},
{"role": "assistant", "content": row["output"]}]
return {"text": tok.apply_chat_template(msgs, tokenize=False)}
def tokenize(row):
out = tok(row["text"], truncation=True, max_length=MAX_LEN, padding="max_length")
out["labels"] = out["input_ids"].copy()
return out
ds = Dataset.from_list([to_text(p) for p in pairs]).map(tokenize, remove_columns=["text"])
ds = ds.train_test_split(test_size=0.1, seed=SEED)
print(f"样本 {len(ds['train'])} 训练 / {len(ds['test'])} 验证")
base = AutoModelForCausalLM.from_pretrained(MODEL, torch_dtype=torch.float32)
# 调参点 1:target_modules 决定"改哪里"。只加 q,v 是最省参数的做法;
# 效果不够时再加 k,o,gate,up,down,而不是先加 r。
# 调参点 2:lora_alpha = 2*r 是常用比例;alpha 固定而 r 变大,等效学习率会变大。
for r in (4, 8, 16, 32):
cfg = LoraConfig(r=r, lora_alpha=2 * r, lora_dropout=0.05,
target_modules=["q_proj", "v_proj"], bias="none", task_type="CAUSAL_LM")
# 必须 deepcopy:get_peft_model 会就地给 base 注入 LoRA 层,
# 直接复用会让下一轮的秩叠加在上一轮之上,四档对照全部作废
model = get_peft_model(copy.deepcopy(base), cfg)
trainable = sum(p.numel() for p in model.parameters() if p.requires_grad)
args = TrainingArguments(
output_dir=f"runs/lora-r{r}", num_train_epochs=3,
per_device_train_batch_size=2, gradient_accumulation_steps=8, # 等效 batch=16
learning_rate=2e-4, # 调参点 3:LoRA 常用 1e-4~3e-4,比全参微调大 10 倍
warmup_ratio=0.05, lr_scheduler_type="cosine",
logging_steps=20, save_strategy="no", report_to=[], seed=SEED,
fp16=torch.cuda.is_available())
trainer = Trainer(model=model, args=args, train_dataset=ds["train"],
data_collator=DataCollatorForLanguageModeling(tok, mlm=False))
trainer.train()
ev = trainer.evaluate()
print(f"[r={r:2d}] 可训练参数 {trainable:,}(占比 {trainable / model.num_parameters():.2%})"
f" eval_loss={ev['eval_loss']:.4f}")
print("\n读表方法:eval_loss 随 r 增大而持续下降 → 容量不足,可以继续加 r;")
print(" 在某档之后不再降甚至反弹 → 已饱和,再大只是过拟合训练集。")
print("注意:这个 loss 只反映'像不像训练集答案',业务正确性必须另建评估集。")
| 项目 | 内容 |
|---|---|
| 课题 15-2 | 发票或简历的结构化信息抽取 |
| 数据集 | 自建 300 条"文本到 JSON"配对(公开数据集可用 CORD 收据数据;简历类需自行脱敏构造) |
| 任务与指标 | 结构化抽取,主指标字段级完全匹配的 F1。参考线:字段 F1 ≥ 0.85,输出合法 JSON 比例 ≥ 98% |
| 关键参数 | r、lora_dropout、max_length、lr、bf16 与 fp16 的选择、是否加 JSON schema 约束解码 |
| 通关判据 | 字段 F1 ≥ 0.85;json.loads 解析成功率 ≥ 98%;给出至少 5 条失败案例的归类分析(字段缺失、幻觉编号、格式漂移) |
| 加分挑战 | 加约束解码(JSON schema 或语法引导)把合法率推到 100%,并记录推理速度代价 |
| 建议耗时 | 10 小时(难度 3 星,需 16GB 显存,对应第七章 7.1 到 7.4) |
参考实现:code/15-2_invoice_json_extraction.py
"""课题 15-2 发票/简历字段抽取(LLM 结构化输出的真实评估)
目标:把"看起来能抽出 JSON"升级为"可度量":JSON 可解析率 + 字段级 F1。
数据:data/ie/samples.jsonl(每行 {"text": 票面文本, "fields": {...}});没有则合成。
依赖:transformers、peft、torch
"""
import json
import re
from pathlib import Path
import torch
from datasets import Dataset
from peft import LoraConfig, get_peft_model
from transformers import (AutoModelForCausalLM, AutoTokenizer,
DataCollatorForLanguageModeling, Trainer, TrainingArguments)
SEED = 42
DATA = Path("data/ie/samples.jsonl")
MODEL = "Qwen/Qwen2.5-0.5B-Instruct"
FIELDS = ["发票号码", "开票日期", "购买方", "金额", "税额"]
def load_samples():
if DATA.exists():
return [json.loads(line) for line in DATA.read_text(encoding="utf-8").splitlines() if line.strip()]
samples = []
for i in range(200):
samples.append({
"text": f"增值税电子普通发票 发票代码 044001900111 发票号码 {10000000 + i} "
f"开票日期 2024年{(i % 12) + 1:02d}月{(i % 28) + 1:02d}日 "
f"购买方 某某科技有限公司{i % 7}分公司 金额 {1000 + i * 13}.00 "
f"税率 6% 税额 {(1000 + i * 13) * 0.06:.2f}",
"fields": {"发票号码": str(10000000 + i),
"开票日期": f"2024-{(i % 12) + 1:02d}-{(i % 28) + 1:02d}",
"购买方": f"某某科技有限公司{i % 7}分公司",
"金额": f"{1000 + i * 13}.00",
"税额": f"{(1000 + i * 13) * 0.06:.2f}"}})
return samples
samples = load_samples()
tok = AutoTokenizer.from_pretrained(MODEL)
tok.pad_token = tok.eos_token
def build(row):
# 调参点 1:训练目标的格式必须与线上解析器完全一致,否则训练再好也解析不出来
prompt = f"从下面文本中抽取字段,只输出 JSON,键为:{FIELDS}\n文本:{row['text']}\n"
answer = json.dumps(row["fields"], ensure_ascii=False)
msgs = [{"role": "user", "content": prompt}, {"role": "assistant", "content": answer}]
text = tok.apply_chat_template(msgs, tokenize=False)
out = tok(text, truncation=True, max_length=384, padding="max_length")
out["labels"] = out["input_ids"].copy()
return out
ds = Dataset.from_list([build(s) for s in samples]).train_test_split(test_size=0.2, seed=SEED)
raw_test = samples[int(len(samples) * 0.8):]
base = AutoModelForCausalLM.from_pretrained(MODEL, torch_dtype=torch.float32)
cfg = LoraConfig(r=16, lora_alpha=32, lora_dropout=0.05,
target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
task_type="CAUSAL_LM")
model = get_peft_model(base, cfg)
print(f"可训练参数 {sum(p.numel() for p in model.parameters() if p.requires_grad):,}")
args = TrainingArguments(output_dir="runs/ie-lora", num_train_epochs=5,
per_device_train_batch_size=2, gradient_accumulation_steps=8,
learning_rate=2e-4, warmup_ratio=0.05, logging_steps=10,
save_strategy="no", report_to=[], seed=SEED)
Trainer(model=model, args=args, train_dataset=ds["train"],
data_collator=DataCollatorForLanguageModeling(tok, mlm=False)).train()
@torch.no_grad()
def extract(text: str) -> str:
model.eval()
msgs = [{"role": "user", "content": f"从下面文本中抽取字段,只输出 JSON,键为:{FIELDS}\n文本:{text}\n"}]
ids = tok(tok.apply_chat_template(msgs, tokenize=False, add_generation_prompt=True),
return_tensors="pt")
out = model.generate(**ids, max_new_tokens=160, do_sample=False) # 抽取任务必须贪心
return tok.decode(out[0][ids["input_ids"].shape[1]:], skip_special_tokens=True)
def parse(s: str):
m = re.search(r"\{.*\}", s, re.S)
return json.loads(m.group()) if m else None
parsed, correct, total = 0, 0, 0
for s in raw_test[:40]:
pred = parse(extract(s["text"]))
if pred is None:
continue
parsed += 1
for k in FIELDS:
total += 1
correct += int(str(pred.get(k, "")).strip() == s["fields"][k].strip())
print(f"\nJSON 可解析率 = {parsed}/{min(40, len(raw_test))} = {parsed / min(40, len(raw_test)):.1%}")
print(f"字段级准确率 = {correct}/{total} = {correct / max(total, 1):.1%}")
print("\n三重判据(缺一不可):")
print("1) 可解析率 ≥ 95%:否则线上管道会大面积失败,先修格式而不是修内容;")
print("2) 关键字段(金额、税额)准确率 ≥ 90%:数字错比缺失危害大得多;")
print("3) 失败样本有共性:把错例按字段聚类,若集中在'购买方',说明该字段在票面里位置不固定。")
12.6 三十个课题总表
按顺序做,或者按你的方向跳着做。难度决定取舍,耗时决定排期。
| 编号 | 课题 | 数据集 | 难度 | 耗时 | 对应章节 |
|---|---|---|---|---|---|
| 1-1 | 加州房价与共线性诊断 | California Housing(sklearn 内置) | 1 星 | 3 到 4 小时 | 三、四章 |
| 1-2 | 二手车价格预测 | Kaggle S4E9,18.8 万行 | 2 星 | 6 到 8 小时 | 三、四章 |
| 2-1 | 信用卡欺诈检测 | creditcardfraud,28.4 万笔 | 1 星 | 4 小时 | 三、四章 |
| 2-2 | 电信客户流失 | Telco Churn,7043 行 | 2 星 | 5 小时 | 四、八章 |
| 3-1 | 泰坦尼克生存预测 | Kaggle Titanic,891 条 | 1 星 | 4 小时 | 四章 |
| 3-2 | 员工离职预测 | IBM HR,1470 行 | 2 星 | 4 到 5 小时 | 四章 |
| 4-1 | 信贷违约预测 | Home Credit,30.7 万行 | 2 星 | 8 小时 | 四章 |
| 4-2 | 零售销量预测 | Rossmann,101.7 万行 | 3 星 | 8 到 10 小时 | 三、四章 |
| 5-1 | 手写数字 SVM 对比 | digits 或 MNIST 子集 | 1 星 | 4 小时 | 四章 |
| 5-2 | 影评情感分类 | IMDB,5 万条 | 2 星 | 4 小时 | 四章 |
| 6-1 | 电影协同过滤 | MovieLens 100K | 2 星 | 6 小时 | 四章 |
| 6-2 | CIFAR-10 图像检索 | CIFAR-10,6 万张 | 2 星 | 5 小时 | 四章 |
| 7-1 | 垃圾短信识别 | SMS Spam,5574 条 | 1 星 | 2 到 3 小时 | 四章 |
| 7-2 | 新闻主题分类 | 20 Newsgroups,1.8 万篇 | 1 星 | 3 小时 | 三、四章 |
| 8-1 | RFM 客户分群 | Online Retail II,100 万条 | 2 星 | 5 小时 | 三、四章 |
| 8-2 | DBSCAN 异常交易 | creditcardfraud(无监督) | 2 星 | 4 小时 | 四、九章 |
| 9-1 | MNIST 降维可视化 | MNIST 1 万张 | 1 星 | 3 小时 | 四章 |
| 9-2 | 基因表达降维分类 | UCI RNA-Seq,801 样本 | 2 星 | 4 小时 | 四、九章 |
| 10-1 | Adult 收入预测 | UCI Adult,48842 行 | 2 星 | 5 小时 | 五章 |
| 10-2 | MNIST 调参实验 | MNIST 6 万张 | 2 星 | 6 小时 | 五、八章 |
| 11-1 | CIFAR-10 从零与迁移 | CIFAR-10 | 2 星 | 8 小时 | 六、九章 |
| 11-2 | 肺炎 X 光分类 | Chest X-Ray,5863 张 | 3 星 | 6 小时 | 六、九章 |
| 12-1 | 电力负荷时序预测 | ETTh1,1.7 万条 | 3 星 | 8 小时 | 六、九章 |
| 12-2 | IMDB LSTM 情感分析 | IMDB,5 万条 | 2 星 | 6 小时 | 五、六章 |
| 13-1 | 中文新闻分类 | THUCNews 或 tnews | 2 星 | 6 小时 | 六、九章 |
| 13-2 | ViT 图像分类 | Oxford-IIIT Pet,7400 张 | 3 星 | 6 到 8 小时 | 六、七章 |
| 14-1 | 去噪自编码器与 VAE | MNIST | 2 星 | 5 小时 | 五、九章 |
| 14-2 | DDPM 生成手绘草图 | QuickDraw 单类,12 万张 | 3 星 | 8 到 10 小时 | 五章 |
| 15-1 | 中文垂域问答微调 | 自建 500 到 1000 条 | 3 星 | 8 小时 | 七章 |
| 15-2 | 结构化信息抽取 | CORD 或自建 300 条 | 3 星 | 10 小时 | 七章 |
12.7 学习成果自测清单
指标达标只证明"跑通了",不证明"学会了"。用下面三档判据自评,每一档都要求能拿出证据。
| 档位 | 判断标准 | 通过标志(须有实物) |
|---|---|---|
| 第一档:能跑通 | 从下载数据到输出指标全程自己写,不看完整参考实现 | 代码仓库可运行,随机种子固定后指标可复现(两次差异小于 0.5 个百分点) |
| 第二档:能调优 | 能提前预测"改这个参数指标会往哪走",改完验证预测是否正确 | 每个课题至少 5 条敏感度曲线;至少 3 次预测被验证(含 1 次预测失败并解释原因) |
| 第三档:能解释 | 能向外行讲清"为什么这个模型在这里比那个好",并指出它的失效边界 | 每个课题一份 200 字以上复盘,含一句明确的"本方案不适用的场景" |
补充四条硬性自检,任一不通过就说明前面某个环节被跳过了:
- 你能否在不看代码的情况下,说出自己模型的训练集与验证集指标各是多少;
- 你能否指出自己模型最容易错的那一类样本,并给出至少一个原因假设;
- 你能否说出这次实验里被证伪的一个想法(如果全都成功了,说明实验设计得太保守);
- 换一台机器、重装环境后,你能否仅凭配置文件复现出同样的结果。
三十个课题做完,你手上应该有三十份配置、三十组曲线、三十份复盘。这三样东西的价值远高于三十个分数,因为它们才是面试时能讲出来的东西:不是"我做过逻辑回归",而是"我在 0.17% 正类上把召回从 0 调到 0.75,代价是精确率掉了 4 个点"。
12.8 参考代码索引
这一章的三十份脚本都在 code/ 目录下,命名规则是「课题编号_主题.py」。它们与第三到七章正文内嵌的实现代码(code/impl/)是两套东西,别混:正文的实现代码回答"这个算法内部怎么算",这里的课题脚本回答"在这个任务上怎么把它调好"。前者每个几十行、十秒跑完;后者是完整流程,含数据获取、特征处理、调参、评估与误差分析。
下表标出每份脚本的数据来源与可离线运行性——凡是需要下载的数据,脚本都写了降级分支,取不到时自动换成同结构的合成数据并在终端打印 [降级] 提示,所以断网也能把流程跑通,只是结论要按合成数据的口径解读。
| 编号 | 脚本 | 数据来源 | 环境 | 离线可跑 |
|---|---|---|---|---|
| 1-1 | 1-1_california_housing.py |
sklearn 内置(首次下载约 1MB) | ml | 降级可行 |
| 1-2 | 1-2_used_car_price.py |
Kaggle S4E9(可选) | ml | 是 |
| 2-1 | 2-1_credit_fraud.py |
Kaggle creditcard(可选) | ml | 是 |
| 2-2 | 2-2_telco_churn.py |
IBM Telco(可选) | ml | 是 |
| 3-1 | 3-1_titanic_tree.py |
seaborn 内置(可选) | ml | 是 |
| 3-2 | 3-2_ibm_attrition_rf.py |
IBM HR(可选) | ml | 是 |
| 4-1 | 4-1_credit_default_gbdt.py |
openml UCI(可选) | ml | 是 |
| 4-2 | 4-2_rossmann_ts.py |
Kaggle Rossmann(可选) | ml | 是 |
| 5-1 | 5-1_digits_svm_vs_cnn.py |
sklearn digits 内置 | ml / dl | 是 |
| 5-2 | 5-2_imdb_tfidf.py |
IMDB 或 20newsgroups(可选) | ml | 是 |
| 6-1 | 6-1_movielens_knn.py |
MovieLens ml-latest-small(可选) | ml | 是 |
| 6-2 | 6-2_cifar10_knn_retrieval.py |
torchvision CIFAR-10 | ml / dl | 降级可行 |
| 7-1 | 7-1_sms_spam_nb.py |
UCI SMS Spam(可选) | ml | 是 |
| 7-2 | 7-2_20newsgroups_nb.py |
sklearn 内置 20newsgroups | ml | 降级可行 |
| 8-1 | 8-1_rfm_kmeans.py |
UCI Online Retail(可选) | ml | 是 |
| 8-2 | 8-2_dbscan_anomaly.py |
creditcard 或合成 | ml | 是 |
| 9-1 | 9-1_mnist_pca_tsne.py |
digits 内置;USE_MNIST=1 切 MNIST |
ml | 是 |
| 9-2 | 9-2_gene_expression_pca.py |
UCI Gene Expression(可选) | ml | 是 |
| 10-1 | 10-1_adult_mlp_vs_tree.py |
openml Adult(可选) | ml / dl | 是 |
| 10-2 | 10-2_mnist_mlp_ablation.py |
MNIST(可选) | dl | 降级可行 |
| 11-1 | 11-1_cifar10_scratch_vs_ft.py |
torchvision CIFAR-10 | dl | 需联网 |
| 11-2 | 11-2_chest_xray_gradcam.py |
Kaggle Chest X-Ray | dl | 否(需数据) |
| 12-1 | 12-1_ett_lstm_forecast.py |
ETTh1(可选) | dl | 是 |
| 12-2 | 12-2_imdb_lstm.py |
IMDB(可选) | dl | 是 |
| 13-1 | 13-1_chinese_news_bert.py |
自建 TNEWS(可选) | llm | 是(模型需下载) |
| 13-2 | 13-2_vit_small_data.py |
torchvision CIFAR-10 | dl | 需联网 |
| 14-1 | 14-1_vae_vs_ae.py |
torchvision MNIST | dl | 需联网 |
| 14-2 | 14-2_ddpm_quickdraw.py |
QuickDraw 或 MNIST | dl | 降级可行 |
| 15-1 | 15-1_lora_rank_sweep.py |
自建垂域 QA | llm | 是(模型需下载) |
| 15-2 | 15-2_invoice_json_extraction.py |
CORD 或自建 | llm | 是(模型需下载) |
三条使用建议:
先说明编号规则:课题编号 12-1 表示"第 12 组课题的第 1 题"(循环网络),与"第十二章"无关;三十道题的组号从 1 到 15,与你正在读的章节号不是一回事,脚本文件名沿用了同一个编号。
第一,先跑 1-1 和 8-1,这两个用内置或合成数据、十秒内出结果,能验证你的环境是否装对。若 1-1 报 HTTP 403 说明数据源被墙,脚本会自动降级,属预期行为。
第二,每份脚本末尾都有一小段"怎么读结果"的打印,那不是装饰。它写的是这一题最容易出现的误读方式,跑完先读这段,再决定要不要继续调参。
第三,所有脚本都固定了 SEED = 42。如果你改完参数发现两次结果差异很大,先怀疑是不是漏了固定种子的那一行,而不是"模型不稳定"。
附录 A 参数速查表
| 参数 | 所属 | 一句话记忆 |
|---|---|---|
C |
逻辑回归、SVM | 正则强度的倒数,越大越松 |
alpha |
Ridge、Lasso | 正则强度本身,越大越紧 |
gamma |
SVM RBF 核 | 单样本影响半径的倒数,越大越弯曲 |
max_depth |
树模型 | 容量的直接旋钮 |
min_samples_leaf / min_data_in_leaf |
树模型 | 叶子平滑度,是抗过拟合首选 |
min_child_weight |
XGBoost | 叶子最小 hessian 和,抗过拟合利器 |
num_leaves |
LightGBM | 真正的容量参数,优先于 max_depth |
learning_rate / eta |
提升树、神经网络 | 步长,与轮数反向耦合 |
subsample / bagging_fraction |
提升树 | 行采样,需配 bagging_freq 大于 0 |
colsample_bytree / feature_fraction |
提升树 | 列采样,高维特征时必调 |
reg_lambda / reg_alpha |
提升树 | L2 与 L1 正则 |
weight_decay |
神经网络 | 权重衰减,Adam 下要用 AdamW |
betas |
Adam | 二阶矩衰减率,大模型常用 0.95 |
dropout |
神经网络 | 训练开、推理关 |
warmup_ratio |
Transformer、大模型 | 1% 到 5%,不给就训不动 |
batch_size |
通用 | 与学习率联动,大 batch 需补偿 |
r / lora_alpha |
LoRA | 看比例而非绝对值 |
beta |
DPO | KL 约束强度,越小越激进 |
patience |
早停 | 总轮数的 5% 到 10%,不低于 10 |
perplexity |
t-SNE | 有效近邻数,小于样本数三分之一 |
附录 B 术语表
| 术语 | 含义 |
|---|---|
| 偏差(Bias) | 模型假设与真实规律之间的系统性差距,表现为欠拟合 |
| 方差(Variance) | 模型对训练数据扰动的敏感度,表现为过拟合 |
| 梯度消失 | 反向传播中梯度逐层衰减到接近零,浅层无法更新 |
| 梯度爆炸 | 梯度逐层放大到极大值,导致参数发散与 NaN |
| 灾难性遗忘 | 在新任务上微调后,原有能力大幅退化 |
| 校准(Calibration) | 预测概率与实际发生频率的一致性,用 ECE 衡量 |
| 数据泄漏 | 训练时使用了预测时不可获得的信息,导致评估虚高 |
| 分布漂移 | 线上数据分布与训练时不同,用 PSI 或 KL 散度监控 |
| 早停 | 验证指标不再提升时终止训练,最廉价的正则手段 |
| 学习率调度 | 随训练进程动态调整学习率的策略 |
| 折外编码 | 用不包含当前样本的其余样本统计量做编码,防泄漏 |
| 等效批大小 | batch_size 乘梯度累积步数乘数据并行卡数 |
结语
本手册的参数表可以背,但敏感度曲线背不下来。真正的调参能力来自一个循环:改一个参数、跑一次、读曲线、形成判断。这个循环走满五十次,你对"该往哪个方向拧"的直觉就会超过任何清单。
所以最后一条建议是:拿一个你熟悉的真实数据集,把第八章的体检表和第九章的图鉴当作对照表,亲手制造一次过拟合、一次梯度爆炸、一次数据泄漏,看着指标在你的操作下变形。见过这些形态之后,你就不需要再问"这个曲线正常吗"。
浙公网安备 33010602011771号