机器学习商业应用：期末复习笔记.

版本：v1.2，2026-10-21（初版 2026-10-19）· 按课程顺序编排 · 正文中文，术语中文（English），代码语法保持原样，注释简洁中文。

这套资料用于先建立知识框架，再练习纸笔作答，最后筛选本人手写的 A4 双面速查表（cheat sheet）。公式、代码输出和判断题都应能脱离电脑解释。

本次修订补充了“场景 → 数据含义 → 代码 → 输出 → 结果用途”的说明，重点包括 NumPy 索引/聚合/广播、Pandas 筛选/分组，以及预处理和模型流水线。建议读代码时先说清一行或一个轴代表什么，再看输出形状和数字；前文已有的数据会明确续用，新增模拟例子会说明其用途。

本次网页修订补齐示例的控制台输出、表格与实际绘图。代码块后的“运行输出”来自对应教学代码；只赋值而不显示的示例增加了必要的 print。模型输出用于理解模拟数据，不代表真实业务表现；不同库版本可能存在末位数值差异。综合自测题仍保留独立作答与答案对照。

1. 考试信息与范围

依据官方期末考试要求：

• 时间：2026 年 10 月 26 日，10:00–11:15，共 75 分钟。
• 地点：经世楼；MIS 班 E202，FIN 班 E203。
• 形式：纸笔、闭卷；题型为判断题、选择题、简答题。
• 可带一张 A4 纸，双面，必须本人手写；打印、打字、复印版本不允许使用。
• 本资料和自编题不是老师发布的题库；复习侧重与模拟卷分值均为学习建议，不代表官方命题权重。

2. 按课程顺序的知识框架

课程主线可以连成：商业问题 → 数据探索 → 规则基线 → 数据划分 → 预处理 → 训练 → 验证与调参 → 最终测试 → 解释与业务行动。第 2–5 章是工具，第 6–9 章建立完整流程，第 10–12 章扩展模型与训练方法。

3. 配套资料

每章配有概念、公式或语法、示例、易错点与自测。代码块中以 df、X_train 等开头而未构造数据的片段，按其上下文读取；不要把不同章节片段无差别拼成一个程序。

4. 范围边界

官方明确排除的独立章节：多项式回归与正则化（Polynomial Regression and Regularization）、逻辑回归（Logistic Regression）、支持向量机（Support Vector Machine）、聚类（Clustering）、代码管理（Code Management）、数据应用（Data App）。不需要为这些章节准备单独的公式与 API 清单。

同一术语若出现在范围内章节，仍需理解其当时的用途。例如：概览中的无监督学习、树的复杂度约束、投票中使用不同模型，不能因为另一个独立章节被排除而全部跳过。

课程的 ROC/AUC、正规方程推导、OLS 与 R²等页面带有 optional 标记。optional 不等于考试页明确排除；先掌握正文，再学习这些标注拓展的细节。R²在作业 4 明确使用，本资料将基本公式与解释列为主线。作业 4 的 Data App 部分依然属于官方排除章节。

5. 三轮复习法

第一轮：理解结构

按 01→12 阅读。每章结束后，不看笔记回答：“输入是什么？输出是什么？核心规则是什么？什么条件下会失效？”此时只标记不熟的知识，不急着把整章抄到 A4 上。

第二轮：纸笔练习

做章末自测及综合题。公式题写符号含义、代入式和结果；代码题写对象类型、shape 或输出；判断题即使答对，也要能解释为什么。遇到错误时回到对应章节，而不是仅背正确选项。

第三轮：压缩与模拟

将经常混淆的公式、条件和短代码压缩到手写提纲。做一次 75 分钟限时练习，记录查表耗时，删去熟悉而占位置的内容，补入真实错点。

6. 考前七个复习单元

下表保留从 10/19 到考前一天的七单元安排，不假设每天固定时长。若现在才开始，可合并已过去日期的单元，按掌握情况缩短熟悉部分，仍保持课程顺序。

7. 一套 75 分钟自编模拟练习

从综合自测中抽取以下题目。此安排只用于练习节奏，官方未公布题量与分值。

简答评分可按“结论正确、理由完整、适用条件、具体例子”四项各 2 分；综合题按步骤分配分值，不只看最终数字。

8. 最后检查清单

• 能按课程顺序概括 12 个主题。
• 能区分训练、验证、测试与 Kaggle 的无标签测试文件。
• 能手算 shape、标准化、树不纯度、分类指标、回归误差、一次 GD 更新。
• 能解释数据泄漏、过拟合、重要性与因果之间的边界。
• 能比较规则、树、线性回归、SGD 训练、随机森林与提升方法。
• A4 已本人手写，双面内容可读；不是打印本资料。

来源快照读取于 2026-10-19。考试通知如有更新，以课程考试页为准。

返回复习导航

本章目标：能把商业问题翻译成预测任务，解释完整工作流程，并区分特征、目标与数据集的用途。按照课程期末范围，学习类型的概念属于本章；聚类算法的具体推导不在本次范围内。

1. 从商业目标出发

人工智能（Artificial Intelligence, AI）是广义领域；机器学习（Machine Learning, ML）关注从数据中学习模式。模型（Model）描述输入与输出之间的关系；业务价值取决于预测之后采取的行动。

点击率（Click-Through Rate, CTR）的描述性定义：

$CTR=\frac{\text{点击次数}}{\text{展示次数}}$

“预测单次展示是否点击”是分类；“预测未来一天的 CTR 数值”可设为回归。任务类型由目标变量及其含义决定，不能只看业务名称。

模型准确不自动等于商业成功：错误的成本、干预费用、可操作性和部署后的数据变化都影响最终收益。

2. 读懂一张数据表

假设每行记录一位客户：

• 样本/实例（Sample / Instance）：一行观察记录。必须先明确“一行代表什么”，才能计算比例和解释模型。
• 特征/属性（Feature / Attribute）：用于预测的输入，例如年龄、付款方式、距上次购买的天数。
• 目标/标签（Target / Label）：希望预测的输出，例如 churn。
• 标识符（Identifier）：识别记录的字段。customer_id 通常不能直接解释为有意义的数值大小。

常用记号：$X$ 为特征矩阵，$y$ 为目标向量；有 $n$ 个样本、$p$ 个特征时，$X$ 的形状为 $(n,p)$，$y$ 通常为 $(n,)$。

0/1 可以编码类别；邮政编码看似数字，却通常是类别或标识。存储类型（Dtype）与统计含义不是同一件事。

3. 三种学习方式

监督学习再区分：

• 分类（Classification）：预测有限类别，如流失/不流失、评级 A/B/C。
• 回归（Regression）：预测数值，如价格、需求量。目标是计数也可能作为回归问题，关键是任务设定。

“分类”与“聚类（Clustering）”不同：分类利用已知标签学习；聚类寻找未预先标注的群组。

4. 课程中的完整工作流程

这是一种概念顺序，实际工作会反复迭代。实施建模时，应在会学习数据统计量的步骤之前划分数据；填补均值、缩放参数等由训练数据学习，避免把验证集或测试集信息带入训练。

“垃圾进，垃圾出”（Garbage In, Garbage Out, GIGO）强调数据质量会限制结果。异常值（Outlier）可能是错误，也可能是真实的重要客户；不能看到极端值就自动删除。

特征工程的三个层次：

1. 特征转换（Feature Transformation）：分箱、对数变换、缩放、类别编码。
2. 特征提取/创建（Feature Extraction / Creation）：从原始信息构造有用表示，如距上次购买的天数。
3. 特征选择（Feature Selection）：选择与任务相关的输入。相关性或重要性分析只能提供证据，不能直接证明因果关系。

5. 训练、验证、测试各做什么

泛化（Generalization）指模型对未见数据的适用能力。过拟合（Overfitting）常表现为训练集很好、未见数据明显变差；欠拟合（Underfitting）常表现为训练和验证都较差。

参数（Parameter）由训练算法学习；超参数（Hyperparameter）通常由建模者设置并通过验证选择，例如树的 max_depth。

部署（Deployment）后仍需监控：客户行为、业务流程、数据分布可能变化；原来的好模型不保证永久有效。

6. 最小代码：识别输入与目标

import pandas as pd

df = pd.DataFrame({
    "age": [28, 55, 40],
    "days_since_purchase": [12, 90, 30],
    "churn": [0, 1, 0],
})

X = df[["age", "days_since_purchase"]]  # 输入特征
y = df["churn"]                       # 预测目标
print(X.shape, y.shape)                 # (3, 2) (3,)

不需要在本章背完整训练代码，先能解释每一列为何出现在 $X$ 或 $y$ 中。若把 churn 同时放入 $X$，模型等于提前看到了答案，会造成目标泄漏（Target Leakage）。

怎样读上面的输入与输出？ 假设我们在月末预测下月流失，每行是一位客户在该月末的状态；age 是年龄（年），days_since_purchase 是距上次购买的天数，历史标签 churn=1 表示其随后一个月实际流失。X 的两列是预测时已知的信息，y 的三个数分别对应同样三行客户。

训练结束后，面对一位尚不知道下月结果的新客户，只能提供同样定义的两列：

new_customer = pd.DataFrame({
    "age": [35], "days_since_purchase": [60],
})
print(new_customer.shape)  # (1, 2)：一个客户、两个特征

这只是准备预测输入，还没运行模型。之后 model.predict(new_customer) 才会返回一个类别；真实下月结果到来后，才能与它比较。若额外放入“下月是否流失”或“下月购买次数”，实际预测时拿不到这些列，训练流程便失去了使用价值。

7. 纸笔例题与解答

题目。 某企业有 1,000 位客户，其中 200 位在下月流失。数据中有年龄、历史消费次数、下月是否流失。企业希望提前安排挽留活动。

1. 一行、特征、目标各是什么？属于哪类学习？
2. “全部预测不流失”的准确率是多少？是否足够证明方案有价值？
3. 能否将“下月实际投诉次数”用于月初预测？

解答。

1. 一行为一位客户；年龄、历史消费次数为候选特征；下月流失为目标。存在已知标签，属于监督分类。
2. 准确率为 $800/1000=80\%$，但一个流失客户也没有找出。必须结合漏掉流失客户的损失、挽留成本和业务目标评价。
3. 月初尚不知道这一信息，直接使用会引入未来信息泄漏。特征必须在实际预测时可获得。

8. 易错点

• 模型预测“概率”仍然可以属于分类；分类并非只能直接输出 0/1。
• 数字标签不一定是回归目标，类别编码也不会自动拥有距离含义。
• 测试集反复用于挑选方案后，就不再是独立的最终检验。
• 模型发现关联不等于证明因果，尤其不能直接推出某种干预必然有效。
• EDA、清洗、训练、部署不是一次完成后永不回头的流水线。

9. 自测

1. 预测房价与预测房屋是否售出，分别是什么任务？
2. 客户年龄和客户编号都存为整数，能否同样解释其大小？
3. 调整树深度应主要依据哪个数据集的表现？
4. 为什么一个 95% 准确率的模型仍可能没有商业价值？
5. 上线模型后为什么还要收集新数据？

简答： 1. 回归、分类。2. 不能，编号通常仅用于识别。3. 验证集或交叉验证。4. 可能只是多数类基线，或错误/行动成本抵消收益。5. 检查分布与业务变化，并支持模型更新。

课程来源

• Introduction to AI and ML
• Machine Learning Workflow Overview 课件
• Final Exam：范围与规则

本章纸笔例题为复习自编，不是教师公布的试题。

返回复习导航

本章目标：看懂短代码、逐行追踪变量和输出，解释容器与控制流程。课程链接的 Python Cheatsheet 是参考大全，本章围绕课堂列出的基础主题整理。

1. 类型、运算与字符串

先括号，再幂，再乘除与取余，再加减；不确定时使用括号。-2 ** 2 是 -(2 ** 2)=-4，(-2) ** 2=4。

price = 12.5
quantity = 3
revenue = price * quantity
print(f"Revenue = {revenue:.2f}")  # Revenue = 37.50
text = "machine learning"
print(text.upper())               # 大写，不修改原字符串

运行输出：

Revenue = 37.50
MACHINE LEARNING

格式化字符串（f-string）用 {表达式} 插值，.2f 表示保留两位小数。input() 的返回值为字符串，数值计算前需要适当转换。int(3.9) 得到 3，不是四舍五入。

2. 四类容器

Python 3.7 起，字典保留插入顺序；读取 d[1] 仍表示键为 1，不是“第 2 个元素”。集合 set 可增删，不能按位置索引；不可变集合另有 frozenset，不必与基础 set 混淆。空的 {} 是字典。

可变性说的是对象本身能否改变，而非变量能否重新绑定。元组中若含列表，那个列表仍可变；基础题通常只使用简单元素。

items = [10, 20, 30]
items.append(40)                 # 加入一个元素
items.extend([50, 60])           # 逐个加入多个元素
last = items.pop()               # 删除并返回末尾元素
prices = {"tea": 5, "coffee": 8}
prices["tea"] = 6               # 更新已有键
prices.get("juice", 0)          # 缺失键返回默认值
unique_items = set([1, 1, 2])    # {1, 2}

# 显示本例需要观察的结果
print("items:", items, "last:", last)
print("prices:", prices, "unique_items:", unique_items)

运行输出：

items: [10, 20, 30, 40, 50] last: 60
prices: {'tea': 6, 'coffee': 8} unique_items: {1, 2}

append([3,4]) 加入一个嵌套列表；extend([3,4]) 加入两个元素。x.sort() 原地排序，返回 None；sorted(x) 返回新的排序列表。

3. 索引与切片

索引（Indexing）从 0 开始，负数从末尾计数。切片（Slicing）的形式为 x[start:stop:step]，包含起点、不包含终点。

x = [10, 20, 30, 40, 50]
print(x[0], x[-1])     # 10 50
print(x[1:4])          # [20, 30, 40]
print(x[::2])          # [10, 30, 50]
print(x[::-1])         # [50, 40, 30, 20, 10]

运行输出：

10 50
[20, 30, 40]
[10, 30, 50]
[50, 40, 30, 20, 10]

列表的 + 是连接，* 是重复：[1,2]+[3,4] → [1,2,3,4]；[1,2]*2 → [1,2,1,2]。这与 NumPy 的逐元素运算不同。

a = [1, 2, 3]
b = a               # 同一个列表
c = a[:]            # 浅复制
b[0] = 9
print(a, c)         # [9, 2, 3] [1, 2, 3]

运行输出：

[9, 2, 3] [1, 2, 3]

浅复制（Shallow Copy）复制外层容器；若内部含可变对象，内部对象可能仍共享。本课基本一维数值例子中，修改切片元素不会改变原列表。

4. 条件与循环

score = 75
if score >= 90:
    grade = "A"
elif score >= 60:
    grade = "Pass"
else:
    grade = "Fail"

# 显示本例需要观察的结果
print(grade)

运行输出：

Pass

if/elif/else 链只执行第一个成立的分支。缩进决定语句归属。0、None、空字符串及空容器通常为假；非空字符串 "False" 为真。

names = ["Amy", "Bo"]
scores = [80, 90]
for i, name in enumerate(names):
    print(i, name)                   # 索引与值
for name, score in zip(names, scores):
    print(name, score)               # 对应元素配对
for key, value in {"a": 1, "b": 2}.items():
    print(key, value)                # 字典键值对

运行输出：

0 Amy
1 Bo
Amy 80
Bo 90
a 1
b 2

zip() 默认在最短输入耗尽时结束。直接 for key in d 遍历字典的键；.values() 遍历值，.items() 遍历键值对。

5. 推导式、函数与导入

推导式（Comprehension）把简单循环表达为一个构造容器的表达式：

squares = [x ** 2 for x in range(5) if x % 2 == 0]  # [0, 4, 16]
mapping = {x: x ** 2 for x in range(3)}             # {0: 0, 1: 1, 2: 4}
remainders = {x % 2 for x in range(5)}              # {0, 1}
labels = ["high" if x >= 3 else "low" for x in range(5)]

# 显示本例需要观察的结果
print(labels)

运行输出：

['low', 'low', 'low', 'high', 'high']

末尾 if 表示筛选哪些元素进入结果；前面的 a if 条件 else b 表示每个元素取什么值。

def revenue(price, quantity=1):
    total = price * quantity       # 局部变量
    return total

answer = revenue(8, quantity=3)     # 24
print(answer)

import math
print(math.sqrt(9))                # 3.0

运行输出：

24
3.0

函数（Function）通过参数（Argument / Parameter）接收输入，通过 return 交回结果；没有执行 return 值 时返回 None。print() 显示内容，不能替代 return。函数内创建的普通局部变量（Local Variable）只在局部作用域可用。

包/模块（Package / Module）通过 import 引入；import numpy as np 是为模块取别名，不改变其功能。避免把变量命名为 list、sum 等内置名称，以免遮蔽原功能。

把函数与推导式用于一个订单问题

需求：计算两笔订单各自的金额，再求合计。 每个元组表示 (单价, 数量)，单位分别是元/件和件；沿用上面的 revenue(price, quantity) 函数。

orders = [(8, 3), (5, 1)]
amounts = [revenue(price, qty) for price, qty in orders]
print(amounts)       # [24, 5]，一笔订单对应一个金额
print(sum(amounts))  # 29，两笔订单合计

运行输出：

[24, 5]
29

把推导式拆开读：for price, qty in orders 逐笔拆出两个输入；revenue(price, qty) 计算该笔金额；最外层 [...] 收集返回值。函数若只 print(total) 而不 return total，屏幕仍会显示金额，但 amounts 会收集到 [None, None]，无法用于后面的求和。这就是“显示结果”和“把结果交给下一步计算”的区别。

6. Notebook 中的文字与公式

代码单元（Code Cell）运行 Python；Markdown 单元记录解释。常用 Markdown：# 标题、**粗体**、- 列表、[文字](网址)。LaTeX 行内公式用 $...$，独立公式用 $$...$$。这些是写作和解释工具，不会自动执行 Python。

7. 纸笔例题与解答

题目：写出最后的 total 与 out。

total = 0
out = []
for n in range(1, 7):
    if n == 5:
        break
    if n % 2 == 0:
        continue
    total += n
    out.append(n ** 2)

解答： n=1 时累加 1、加入 1；n=2 跳过；n=3 累加 3、加入 9；n=4 跳过；n=5 退出，因此 total=4，out=[1,9]。虽然 range 包含 6，循环没有执行到 6。

8. 易错点与自测

常见错误：把 = 当比较；忘记切片/range 的终点不包含；把 pass 当成跳过本轮；把 print 当返回值；把列表连接当数值相加；把字典插入顺序当位置索引。

1. len({1,1,2}) 是多少？type({}) 是什么？
2. a=[3,1,2]; b=a.sort() 后，a 和 b 是什么？
3. [x+1 for x in range(4) if x>1] 是什么？
4. 函数只执行 print(3)，把调用结果赋给 x，x 是什么？
5. list(range(5,0,-2)) 是什么？

简答： 1. 2，dict。2. [1,2,3] 与 None。3. [3,4]。4. None。5. [5,3,1]。

课程来源

• Python Basics
• Python 课堂小组练习
• 教师 Python Cheatsheet
• Python 官方：数据结构（核对字典顺序与集合可变性）

纸笔例题与自测为复习自编。

返回复习导航

本章目标：先判断形状（Shape），再判断数值；能把每个轴（Axis）和聚合结果翻译成业务含义。课程咖啡店练习使用 sales.shape == (3,4,5)，依次代表门店、周、产品。

1. 数组结构与创建

多维数组（N-dimensional Array, ndarray）使用统一的数据类型描述元素，支持向量化（Vectorization）运算。数值分析中通常使用数值 dtype，不要把 Python 列表与数组的运算规则混为一谈。

import numpy as np

a = np.array([[1, 2, 3], [4, 5, 6]])
print(a.shape, a.ndim, a.size)    # (2, 3) 2 6
zeros = np.zeros((2, 3))         # 全零数组
ones = np.ones((2, 3))           # 全一数组
steps = np.arange(1, 6, 2)       # [1, 3, 5]，不含终点
points = np.linspace(0, 1, 3)    # [0., 0.5, 1.]，默认含终点
flat = a.reshape(-1)            # 自动推算唯一未知维度

# 显示本例需要观察的结果
print("zeros:\n", zeros)
print("ones:\n", ones)
print("steps:", steps, "points:", points, "flat:", flat)

运行输出：

(2, 3) 2 6
zeros:
 [[0. 0. 0.]
 [0. 0. 0.]]
ones:
 [[1. 1. 1.]
 [1. 1. 1.]]
steps: [1 3 5] points: [0.  0.5 1. ] flat: [1 2 3 4 5 6]

文件中的数值可用 np.loadtxt("numbers.txt", delimiter=",") 读取，再按已知结构 reshape。不能把 24 个元素直接重塑成 (5,5)。

(5,) 是一维数组，既不是 (1,5) 行矩阵，也不是 (5,1) 列矩阵。a.T 交换二维数组的行列；一维数组转置后仍是一维，要得到列矩阵需 a.reshape(-1,1)。

2. 索引：一个整数会消去一个轴

2.1 先把三维数组理解成三张门店报表

你管理一家咖啡连锁店，记录了 3 家门店、4 周、5 种产品的销量。一个数字表示“某家店在某一周卖出某种产品的数量”，单位为件/杯，不是金额。下面沿用课程数据，后文的 sales、stores、products 均来自这里。

import numpy as np

np.random.seed(409)  # 复现课堂销量
sales = np.random.randint(20, 80, size=(3, 4, 5))
stores = ["Downtown", "Campus", "Airport"]
products = ["Latte", "Espresso", "Cold Brew", "Sandwich", "Cookie"]

可以把整个数组想成三张叠起来的表：先选哪家店的一张表，再选表中哪一周的行，最后选哪种产品的列。NumPy 只保存数字和位置；这些门店名、产品名是我们另行记录的对应关系。

数组用逗号区分不同轴，写作 sales[门店选择, 周选择, 产品选择]。: 表示该轴全部保留。整数固定一个位置，结果不再需要用那个轴区分不同对象；切片保留一段位置，也保留该轴。“消去轴”不是删除原数组的数据，而是返回结果少了一个维度。

2.2 从业务问题逐个翻译成索引

问题 A：校园店长要看自己店四周的完整报表。 门店固定为 1，周和产品全部保留：

campus = sales[1, :, :]  # 等价于 sales[1]
print(campus.shape)     # (4, 5)：周 × 产品
print(campus)

运行输出：

(4, 5)
[[21 59 61 76 61]
 [30 36 58 38 66]
 [36 62 56 47 30]
 [50 28 59 47 64]]

输出如下，4 行分别是第 1–4 周，5 列仍按 products 排列：

[[21 59 61 76 61]
 [30 36 58 38 66]
 [36 62 56 47 30]
 [50 28 59 47 64]]

例如第一行第三个数 61 是校园店第 1 周的冷萃销量。此时只剩“周”和“产品”两个维度，不再需要门店轴。省略末尾的轴选择时，它们默认全部保留，因此 sales[1] 也得到同样的表。

问题 B：校园店的冷萃每周分别卖出多少杯？ 固定门店 1、产品 2，只让周变化：

campus_cold_brew = sales[1, :, 2]
print(campus_cold_brew)        # [61 58 56 59]
print(campus_cold_brew.shape)  # (4,)
print(campus_cold_brew.sum())  # 234，全月冷萃销量

运行输出：

[61 58 56 59]
(4,)
234

1 选校园店，: 选四周，2 选冷萃。输出的四个数是四周的销量，可以接着画周趋势；若问题改成“全月共多少杯”，才再调用 .sum()。索引负责取出记录，求和负责汇总记录。

问题 C：机场店第 2–3 周，两种食品分别卖了多少？ 1:3 取周索引 1、2，-2: 取末尾两种产品：

airport_food = sales[2, 1:3, -2:]
print(airport_food.shape)  # (2, 2)：两周 × 两种食品
print(airport_food)

运行输出：

(2, 2)
[[52 47]
 [34 56]]

结果为 [[52,47],[34,56]]：第 1 行对应第 2 周，第 2 行对应第 3 周；第 1 列是 Sandwich，第 2 列是 Cookie。也就是第 2 周卖了 52 个三明治、47 块曲奇，第 3 周分别为 34、56。虽然两个轴长度都为 2，它们的含义完全不同；仅看 (2,2) 并不能知道行列代表什么。

问题 D：市中心店第 4 周卖了多少杯冷萃？ 三个位置都固定，结果是一个数字：

units = sales[0, 3, 2]
print(units)  # 40 杯

运行输出：

40

2.3 对照速查：先说需求，再判断剩下哪些轴

2.4 为什么有时只取一周，也要保留周轴？

sales[:,1,:] 和 sales[:,1:2,:] 都取第 2 周的数据，但前者为 (3,5)，后者为 (3,1,5)。后续函数若要求统一接收“门店 × 周 × 产品”，应使用后者。这样同一函数既可处理一周，也可处理多周。

one_week_table = sales[:, 1, :]     # 门店 × 产品
one_week_block = sales[:, 1:2, :]   # 门店 × 周 × 产品
print(one_week_table.shape)        # (3, 5)
print(one_week_block.shape)        # (3, 1, 5)

运行输出：

(3, 5)
(3, 1, 5)

切片包含起点、不包含终点；“第 2 周”对应索引 1，不是 2。对结果继续索引时，要按结果的新轴顺序理解：campus[0,2] 是校园店第 1 周的冷萃销量，已不再需要传入门店索引。

2.5 布尔索引：哪些周需要重点关注？

接问题 B，假设店长想找出“冷萃销量少于 60 杯的周”，用于进一步排查活动、客流或营业天数：

week_numbers = np.arange(1, 5)  # 现实周次 1–4
low = campus_cold_brew < 60
print(low)                    # [False True True True]
print(week_numbers[low])       # [2 3 4]：对应周次
print(campus_cold_brew[low])    # [58 56 59]：对应销量

运行输出：

[False  True  True  True]
[2 3 4]
[58 56 59]

布尔掩码（Boolean Mask）中的每个 True 保留相同位置的元素。只输出 [58,56,59] 会丢掉“是哪几周”的说明，因此同时筛选周次。阈值 60 是本例的业务筛选条件，不是统计异常值的通用界限。

3. 逐元素运算、复制与矩阵运算

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
print(a + b)         # [5, 7, 9]
print(a * b)         # [4, 10, 18]
print(a ** 2)        # [1, 4, 9]
print(a @ b)         # 32：1*4 + 2*5 + 3*6

运行输出：

[5 7 9]
[ 4 10 18]
[1 4 9]
32

逐元素（Element-wise）运算按位置进行；* 不是矩阵乘法，@ 才表示矩阵乘法/向量点积。二维矩阵 (m,k) @ (k,n) 得到 (m,n)，中间维度必须相同。这也是后续线性回归矩阵公式的基础。

NumPy 的基本切片通常是视图（View），修改它会影响原数组；要独立数据应 .copy()。布尔索引、整数数组索引通常生成复制，不能把所有索引结果都当成视图。

a = np.array([1, 2, 3, 4])
b = a[1:3]             # 共享原数组数据
b[0] = 99
print(a)               # [1, 99, 3, 4]
c = a[1:3].copy()      # 独立复制
c[0] = 0
print(a)               # 仍为 [1, 99, 3, 4]

运行输出：

[ 1 99  3  4]
[ 1 99  3  4]

4. 聚合：axis 指定“被合并掉的维度”

聚合（Aggregation）包括 sum、mean、min、max、std 等。a.sum() 默认汇总所有元素，不指定 axis 并不等于默认按 axis=0 汇总。

对于二维数组：axis=0 合并各行，保留每列一个结果；axis=1 合并各列，保留每行一个结果。“沿哪个方向”容易记错，直接检查被删除的形状位置更稳妥。

a = np.array([[1, 2, 3], [4, 5, 6]])
print(a.sum())                    # 21
print(a.sum(axis=0))              # [5, 7, 9]，形状 (3,)
print(a.sum(axis=1))              # [6, 15]，形状 (2,)
print(a.mean(axis=0))             # [2.5, 3.5, 4.5]
print(a.sum(axis=1, keepdims=True))  # [[6], [15]]，形状 (2, 1)

运行输出：

21
[5 7 9]
[ 6 15]
[2.5 3.5 4.5]
[[ 6]
 [15]]

三维咖啡店案例：

keepdims=True 将被汇总的轴保留为长度 1，常用于后续广播。np.median(a) 求中位数；np.std(a) 默认用总体标准差口径，即 ddof=0，与 Pandas .std() 默认口径不同。

把汇总结果读成一张新报表

需求：查看每家店全月各产品销量，比较产品构成。 每家店与每种产品仍要分别显示，只有“周”要合并，所以对原数组的轴 1 求和：

month_by_store_product = sales.sum(axis=1)
print(month_by_store_product.shape)  # (3, 5)：门店 × 产品
print(month_by_store_product[1, 2])  # 234：校园店全月冷萃

store_total = month_by_store_product.sum(axis=1, keepdims=True)
product_share = month_by_store_product / store_total
print(store_total.shape)            # (3, 1)：每店一个总销量
print(round(product_share[1, 2], 4)) # 0.2376：校园店冷萃占比

运行输出：

(3, 5)
234
(3, 1)
0.2376

第一步的 axis=1 是原数组的周轴；第二步的 axis=1 是新二维报表的产品轴。轴号取决于当前对象，不会永久绑定“周”。store_total 保留为 (3,1)，能让每店的五种产品分别除以自己店的总量。例如校园店冷萃占比是 234/985，不是除以三店合计销量。

如果只关心“第 2 周三家店各卖了多少”，先筛出这一周，再把产品合计：

week2 = sales[:, 1, :]          # (3, 5)：门店 × 产品
week2_units = week2.sum(axis=1) # 合计每家店的五种产品
print(week2_units)             # [215 228 243]

运行输出：

[215 228 243]

结果依次对应 Downtown、Campus、Airport。这里先索引再聚合；若先把四周全部相加，就不能再回答单独第 2 周的问题。

5. 最大值与最大值位置

max() 返回数值，argmax() 返回最大值的位置；argmin() 同理。默认 argmax() 将整个数组按顺序展开后返回位置，指定 axis 则返回该轴上的位置；并列时返回首先出现的位置。

a = np.array([[8, 2, 6], [3, 9, 1]])
print(a.max())              # 9
print(a.argmax())           # 4：展开后的索引
print(a.argmax(axis=0))     # [0, 1, 0]：每列最大值所在行
print(a.argmax(axis=1))     # [0, 1]：每行最大值所在列

运行输出：

9
4
[0 1 0]
[0 1]

需求：向老板报告“哪种产品销量最高、卖了多少”。 分成“汇总销量→找位置→取名字”三步，更容易检查：

product_units = sales.sum(axis=(0, 1))  # 各产品跨门店、周合计
best_index = product_units.argmax()
print(best_index)                      # 4，是位置，不是销量
print(products[best_index], product_units[best_index])  # Cookie 623

运行输出：

4
Cookie 623

压缩写法 products[sales.sum(axis=(0,1)).argmax()] 只返回名称。products 顺序必须与产品轴一致，否则数字算对也会贴错产品标签。

6. 广播（Broadcasting）：从右向左比较

两数组逐元素运算时，从最右边的维度开始对齐。对应长度相等，或至少一个为 1，才可兼容；缺失的左侧维度视作 1。

sales: (3, 4, 5)
price:       (5,)  → (1, 1, 5) → 可广播，结果 (3, 4, 5)
cost:        (3,)  → (1, 1, 3) → 末轴 5 与 3 不兼容
cost.reshape(3,1,1)           → 每门店一个系数，兼容

数组广播不是“看到相同数字就自动找到对应轴”。price 对齐末轴产品维度；门店系数必须显式放在门店轴上。

np.random.seed(409)
sales = np.random.randint(20, 80, size=(3, 4, 5))
price = np.array([3.5, 3.0, 4.5, 6.5, 2.0])
cost = np.array([1.0, 1.2, 0.9])

revenue = sales * price                 # 数量 × 对应产品单价
store_units = sales.sum(axis=(1, 2))    # [934, 985, 1012]
store_revenue = revenue.sum(axis=(1, 2)) # [3628., 3881.5, 3902.5]
adjusted = sales * cost.reshape(3, 1, 1)

# 显示本例需要观察的结果
print("store_units:", store_units)
print("store_revenue:", store_revenue)
print("adjusted shape:", adjusted.shape)

运行输出：

store_units: [ 934  985 1012]
store_revenue: [3628.  3881.5 3902.5]
adjusted shape: (3, 4, 5)

把广播展开成一个具体位置的计算： revenue[0,3,2] = sales[0,3,2] * price[2] = 40 * 4.5 = 180，表示市中心店第 4 周冷萃收入 180 美元。五个单价沿产品轴对应，自动用于所有门店、所有周；不是把总收入乘五次。

若只做“校园店销量统一放大 20%”的情景演示，则 cost[1]=1.2 应作用于 sales[1,:,:] 里的每一个数。reshape(3,1,1) 中的 3 对准门店，两个 1 允许系数沿周与产品重复使用。例如校园店第 1 周冷萃为 61*1.2=73.2 个等效单位，这是调整后的情景量，不是实际发生了小数杯销量。

本例 cost 是课程给定的门店系数练习。adjusted 的业务含义由系数定义决定，不能仅凭变量名就称其为利润；利润还需要成本金额等信息。

销量最高不等于收入最高，收入最高也不等于利润最高。课堂数据中 Cookie 销量最高、Sandwich 收入最高，说明选择指标前必须明确问题。

7. 纸笔例题与解答

题目。 x=np.array([[2,4,6],[1,3,5]])，p=np.array([10,20,30])。求 (x*p).sum(axis=1)，并写出中间和最终形状。

解答。 x 为 (2,3)，p 的 (3,) 对齐最后一轴，乘积为 [[20,80,180],[10,60,150]]，形状 (2,3)。沿 axis=1 合并产品轴，得到 [280,220]，形状 (2,)。若行代表门店，这就是每店收入。

8. 易错点与自测

常见错误：把 size 当行数；把 (n,) 当列矩阵；把 axis=0 当“保留轴 0”；把最大值位置当最大值；基本切片修改后忘记原数组同步变化；广播时从左对齐。

1. (3,4,5) 有几个轴、多少元素？
2. sales[:,1:2,2] 的形状是什么？
3. sales.mean(axis=(0,2), keepdims=True) 的形状是什么？
4. (4,1) 与 (3,) 相加结果形状是什么？
5. 要计算每周收入，怎样从 revenue 汇总？

简答： 1. 3 个轴、60 个元素。2. (3,1)。3. (1,4,1)。4. (4,3)。5. revenue.sum(axis=(0,2))，形状 (4,)。

课程来源

• NumPy 课程页
• NumPy In-Class Exercise
• 教师教程：NumPy

咖啡店设置与核对值来自课堂练习；纸笔例题及末尾自测为复习自编。

返回复习导航

本章目标：能读懂索引、筛选与分组代码，并说明结果的统计单位和分母。Pandas 的标签（Label）会影响对齐和选择，不能一律按 NumPy 的位置运算理解。

1. Series 与 DataFrame

序列（Series）是一维带标签的数据；数据框（DataFrame）是二维表，可有多种列类型。

贯穿本章的自编小数据（每行是一笔交易，索引标签刻意不从 0 开始）：

import pandas as pd

df = pd.DataFrame({
    "branch": ["A", "A", "B", "B"],
    "product": ["tea", "coffee", "tea", "coffee"],
    "quantity": [2, 1, 3, 2],
    "price": [5, 8, 5, 8],
}, index=[10, 20, 30, 40])
df["sales"] = df["quantity"] * df["price"]

这里一行是一笔只含一种产品的交易，quantity 为购买件数，price 为单价（元/件），sales 为交易金额（元）。建立派生列后，完整表为：

后面的索引、筛选与分组都对这四笔交易操作。标签 20 表示第二条记录的标识，不是“第 20 行”。读取实际文件时用 pd.read_csv("filename.csv")，再确认一行到底代表交易、客户还是酒店。

2. 先检查结构，再计算

describe() 常见数值统计：count、mean、std、min、25%、50%、75%、max。其中 count 是非缺失数；50% 为中位数，不一定等于均值。Pandas .std() 默认为样本标准差（ddof=1）。

“类别特征存为字符串”是完整描述；只说 object/string 描述了存储，没描述业务含义。

3. loc 与 iloc

print(df.loc[20, "sales"])              # 8，标签为 20 的行
print(df.iloc[1, 4])                     # 8，第 2 行第 5 列
print(df.loc[20:30, ["branch", "sales"]]) # 包含标签 20、30
print(df.iloc[1:3, [0, 4]])              # 包含位置 1、2

运行输出：

8
8
   branch  sales
20      A      8
30      B     15
   branch  sales
20      A      8
30      B     15

什么时候用哪一个？ 已知交易标签 20，要查询其金额，用 df.loc[20,"sales"]，得到 8 元；只想抽查当前表第二行，用 df.iloc[1]。排序后第二行可能换成另一笔交易，而交易标签 20 仍表示原来的那笔。df.iloc[1,4] 的列位置 4 对应 sales，因为新增后它是第 5 列。

df.loc[1] 查找标签 1，本例不存在，不能代替 df.iloc[1]。以上标签切片示例使用有序且唯一的索引；复杂重复或无序索引可能有额外限制。

避免含糊的链式赋值：需要修改选中行的某列时，使用一次 .loc[条件, 列名] = 值，例如 df.loc[df["branch"]=="A", "price"] = 6。

4. 条件筛选（Filtering）

mask = (df["branch"] == "B") & (df["quantity"] >= 2)
result = df.loc[mask, ["product", "sales"]]
tea_or_large = df[(df["product"] == "tea") | (df["sales"] >= 16)]
not_a = df[~(df["branch"] == "A")]
selected = df[df["product"].isin(["tea", "coffee"])]

# 显示本例需要观察的结果
print(result.to_string())

运行输出：

product  sales
30     tea     15
40  coffee     16

这段代码回答的问题是：B 店购买至少两件商品的交易，买了什么、花了多少？ mask 依次为 [False,False,True,True]；.loc 先选中标签 30、40，再只显示 product 和 sales 两列，结果是 tea/15 元与 coffee/16 元。这里仍是两条明细；再对结果的 sales 求和，得到这些符合条件交易的合计金额。本例 B 店两笔交易恰好都符合条件，所以也等于 B 店总收入；一般情况下不能把筛选后的收入当成全店收入。

逐元素逻辑使用 &、|、~，每个比较条件加括号；不能把整列用 Python 的 and/or 合并。mask 是一列布尔值，True 的行被保留。

5. 频数、去重与分母

value_counts() 默认排除缺失值；normalize=True 默认分母也是非缺失观测数量。count() 与行数只在该列无缺失时相同。

课程作业中的关键口径： Marriott 数据仅包含 2020 年等级发生变化的酒店，而案例给出的全球酒店数为 7,737。因此：

$\text{全球酒店升级比例}=\frac{\text{升级酒店数}}{7737}$

若除以该数据集行数，得到的是“发生等级变化的酒店中升级的比例”，回答的是另一个问题。这里使用的是作业的历史案例数字，不代表当前酒店总数。

6. 分组聚合（GroupBy）

分组操作遵循“拆分—计算—组合”（Split–Apply–Combine）。先定义每组是谁，再明确每个输出统计量的单位。

totals = df.groupby("branch")["sales"].sum()   # A=18，B=31
means = df.groupby("branch")["sales"].mean()   # A=9，B=15.5
summary = df.groupby("branch").agg(
    total_sales=("sales", "sum"),
    avg_sales=("sales", "mean"),
    orders=("sales", "size"),
)
table = df.pivot_table(
    index="branch", columns="product", values="sales", aggfunc="sum"
)  # 行为门店，列为产品，值为销售额

# 显示本例需要观察的结果
print(summary.to_string())
print(table.to_string())

运行输出：

total_sales  avg_sales  orders
branch                                
A                18        9.0       2
B                31       15.5       2
product  coffee  tea
branch              
A             8   10
B            16   15

同一份数据，三个不同问题： sum() 回答“每店总共收入多少”，A 为 10+8=18 元；mean() 回答“每笔交易平均多少钱”，A 为 18/2=9 元；size() 回答“有几笔交易”，A 为 2 笔。它们都按门店分组，但统计单位不同。

透视表 table 把门店放到行、产品放到列，得到：

这适合回答“B 店比 A 店多出的收入主要来自哪类产品”。注意列按结果中的名称读取，不能默认 coffee/tea 的顺序与原表首次出现顺序一致。

groupby(...).size() 计组内总行数；某列的 .count() 计其非缺失值数。pivot_table() 是作业中用于比较两个分类维度的工具；注意指定 aggfunc，其默认通常是均值。

df.groupby("branch").max() 会独立计算各列最大值，结果同一行内的不同字段未必来自同一笔交易。要找销售额最大的一整行，应先取得其索引：

best_rows = df.loc[df.groupby("branch")["sales"].idxmax()]

# 显示本例需要观察的结果
print(best_rows.to_string())

运行输出：

branch product  quantity  price  sales
10      A     tea         2      5     10
40      B  coffee         2      8     16

本例索引唯一且每组均有有效金额，得到 A 的 tea 交易和 B 的 coffee 交易。并列最大值时 idxmax() 取首次出现的位置；题目若要求所有并列记录，需要另外处理。

7. 派生列、排序、删除与输出

df["sales"] = df["quantity"] * df["price"]   # 向量化派生列
df["large"] = df["sales"] >= 15             # 布尔列
df["branch_lower"] = df["branch"].apply(str.lower)
ranked = df.sort_values("sales", ascending=False)
reset = ranked.reset_index(drop=True)          # 丢弃原索引标签
small = df.drop(columns=["large", "branch_lower"])
row_removed = df.drop(index=[20])              # 按标签删行
# small.to_csv("result.csv", index=False)      # 需要导出时执行

# 显示本例需要观察的结果
print(ranked[["branch", "sales"]].to_string())
print("reset index:", reset.index.tolist())

运行输出：

branch  sales
40      B     16
30      B     15
10      A     10
20      A      8
reset index: [0, 1, 2, 3]

sort_values()、drop() 等通常返回新对象，默认不原地改变 df；赋给变量，或明确使用支持的 inplace=True。不要写 df = df.sort_values(..., inplace=True)，因为原地操作通常返回 None。

排序不会自动把标签改成 0,1,...；可用 ignore_index=True 或 reset_index(drop=True)。reset_index() 不带 drop=True 时通常将原索引保存为一列。

数值字符串的转换与合并属于常用辅助语法：pd.to_numeric(s, errors="coerce") 把无法解析的值转为缺失；s.astype(float) 要求值能被相应转换。pd.concat([a,b], axis=0) 按行拼接，axis=1 按列拼接并按行标签对齐。

8. 标签对齐（Alignment）

Pandas 的 Series 运算通常先按标签配对，而非按显示位置配对：

a = pd.Series([10, 20], index=["x", "y"])
b = pd.Series([1, 2], index=["y", "x"])
print(a + b)    # x=12，y=21

运行输出：

x    12
y    21
dtype: int64

例如把 a 看成两个门店原收入，b 看成补录收入：门店 x 的原收入 10 必须加上标签 x 的 2，得到 12；不能因为 1 显示在 b 的第一行，就把它加给 x。标签对齐解决的是“同一对象相加”，不是“显示在同一位置的数相加”。

给 DataFrame 赋一列 Series 也会按行标签对齐；缺少对应标签时可能产生缺失值。例如本章 df 的索引是 10,20,30,40，直接赋入默认索引 0,1,2,3 的 Series 就不会按行号自动匹配。若只想按位置赋值，必须先明确长度和顺序，再使用数组等无标签值。

9. 纸笔例题与解答

题目。 用本章交易表，计算 B 店销售额比 A 店高多少百分比；再求 B 店占全部销售额的比例。这两题分母分别是什么？

解答。 A 店 18，B 店 31。相对 A 的增幅为 $(31-18)/18\approx72.22\%$；B 的销售额占比为 $31/(18+31)\approx63.27\%$。第一题分母是比较基准 A，第二题分母是总销售额。不能用 B/A 的 172.22% 直接声称“高 172.22%”。

10. 易错点与自测

常见错误：按位置理解 loc；筛选时遗漏括号；把 count 当所有行数；把逐列最大值当真实的一行；对无标签对应的 Series 赋值；只报告数字却不解释单位和分母。

1. 本章 df.iloc[1:3] 选中哪些行标签？
2. df["sales"] 与 df[["sales"]] 的维度有何不同？
3. 10 笔交易中金额缺失 2 笔，len(df) 与金额的 .count() 各是多少？
4. groupby("branch")["sales"].mean() 是每店总销售额吗？
5. 两个 Series 的标签相同但顺序相反，相加时按什么配对？

简答： 1. 20、30。2. 一维 Series、二维 DataFrame。3. 10 与 8。4. 不是，是每店每笔有效交易的平均金额。5. 按标签配对。

课程来源

• Pandas 课程页
• 教师教程：Pandas
• Assignment 1：Exploratory Data Analysis

四行交易表、纸笔例题与自测为复习自编；Marriott 分母来自课程作业案例。

返回复习导航

本章目标：根据问题选图，能解释图中元素与分布，并读懂 Matplotlib 和 Pandas 绘图代码。复习时优先练习“这张图回答什么问题”，再记必要 API。

1. 图形对象、绘图区与坐标轴

注意：Axes 在这里是一个绘图区对象的名称，不是“多个 Figure”。一张 Figure 可以有多个 Axes，而每个 Axes 可以有 x 与 y 坐标轴。

2. 最小绘图模板

import matplotlib.pyplot as plt

weeks = [1, 2, 3, 4]
sales = [100, 120, 115, 140]
fig, ax = plt.subplots(figsize=(6, 4))
ax.plot(weeks, sales, marker="o", color="blue", label="Store A")
ax.set_title("Weekly sales increase from 100 to 140")
ax.set_xlabel("Week")
ax.set_ylabel("Sales (units)")
ax.set_xticks(weeks)
ax.legend()
fig.tight_layout()  # 减少标签遮挡
plt.show()

figsize=(宽,高) 的默认单位是英寸，不是像素。label= 定义图例文字，通常还需要调用 legend() 才显示。线型可用 linestyle="dashed"，点形可用 marker="s"。

正文用中文解释即可；代码中的英文图标签便于跨环境显示。无需把绘图样式、颜色列表都抄到 cheatsheet。

3. 一张图里放多个子图

默认 squeeze=True 时：

fig, axes = plt.subplots(1, 2, figsize=(10, 4))
axes[0].plot([1, 2, 3], [4, 6, 5])
axes[0].set_title("Trend")
axes[1].bar(["A", "B"], [15, 20])
axes[1].set_title("Comparison")
fig.tight_layout()
plt.show()

如果创建的是 plt.subplots(2,3)，右下角用 axes[1,2]，因为索引从 0 开始。

4. 不同问题选什么图

折线连接意味着相邻点有顺序意义。若数据只是任意排列的国家或客户，连线很容易让人误以为存在时间或连续变化；比较类别通常用柱状图更直接。

类别频数可以先 value_counts()，再画柱状图。即使某个库允许给直方图传入类别，也应理解直方图的核心用途是将数值划分区间。

5. 柱状图与直方图的区别

柱状图的一根柱通常对应一个类别；直方图的一根柱对应一个数值区间（Bin）。直方图的箱数或箱宽会影响看到的分布形状。

import matplotlib.pyplot as plt
import pandas as pd

df = pd.DataFrame({
    "store": ["A", "A", "B", "B", "B"],
    "sales": [10, 12, 8, 15, 20],
    "customers": [5, 6, 4, 7, 10],
})
fig, axes = plt.subplots(1, 2, figsize=(10, 4))
df.groupby("store")["sales"].sum().plot.bar(ax=axes[0])
axes[0].set_title("Total sales by store")
axes[0].set_ylabel("Sales")
df["sales"].plot.hist(bins=[0, 10, 15, 25], ax=axes[1])
axes[1].set_title("Distribution of transaction sales")
axes[1].set_xlabel("Sales per transaction")
fig.tight_layout()
plt.show()

这两幅图分别回答什么？ 假设上表一行是一笔交易，sales 是金额（元）。左图先按门店合计，柱高为 A=22、B=43 元，比较的是门店总收入；右图不分门店，将五笔金额 [10,12,8,15,20] 放入金额区间，比较的是交易金额分布。

右图显式指定区间边界 [0,10,15,25]，三根柱分别计 [0,10)、[10,15)、[15,25]，频数是 1、2、2 笔。柱高为 2 表示该区间有两笔交易，不表示收入为 2 元。ax=axes[1] 只决定画在右侧绘图区，不会筛选第二家门店。

Pandas 绘图默认基于 Matplotlib；传入 ax= 可以把图画在指定绘图区。默认频数直方图的柱高是落入区间的观测数；若改为密度（Density）图，应按面积解释，不能仍当作原始频数。

分布的基本读法：均值容易受极端值影响；右偏（Right-skewed）意味着较长尾部向右；少量分箱可能隐藏细节，过多分箱可能突出随机噪声。

6. 箱线图：必须记对的公式

设第一四分位数为 $Q_1$，中位数为 $Q_2$，第三四分位数为 $Q_3$：

$IQR=Q_3-Q_1$

$\text{下围栏}=Q_1-1.5IQR,\qquad\text{上围栏}=Q_3+1.5IQR$

• 箱体：从 $Q_1$ 到 $Q_3$，表示中间约 50% 的数据范围。
• 箱内横线：中位数（Median），不是均值（Mean）。
• 须（Whiskers）：默认延伸到围栏内最远的实际观测值，不一定正好等于围栏。
• 围栏外的点：按这一规则标记为异常点（Outliers / Fliers），不等于数据错误，也不意味着必须删除。

教师教程把异常值阈值写成了“中位数 ± 1.5IQR”；这里按 Matplotlib 默认定义使用上面的 $Q_1/Q_3$ 围栏。不同软件或手算规则的四分位数定义可能不同，计算题应先看题目指定的约定。

import numpy as np

values = np.array([1, 2, 3, 4, 5, 6, 7, 8, 20])
q1, median, q3 = np.percentile(values, [25, 50, 75])
iqr = q3 - q1
lower, upper = q1 - 1.5 * iqr, q3 + 1.5 * iqr
outliers = values[(values < lower) | (values > upper)]
print(q1, median, q3, lower, upper, outliers)
# 3.0 5.0 7.0 -3.0 13.0 [20]

运行输出：

3.0 5.0 7.0 -3.0 13.0 [20]

不要把“作图时把异常点单独画出来”理解为“已经从原数据中删除”。对比不同分组时，箱体位置反映分布位置，箱体高度反映中间数据的离散程度；样本量不同仍需谨慎解释。

7. 散点图与相关性

fig, ax = plt.subplots()
df.plot.scatter(x="customers", y="sales", ax=ax)
ax.set_title("Sales and customer count")
plt.show()

# 多个数值特征的成对关系
pd.plotting.scatter_matrix(df[["customers", "sales"]], figsize=(6, 6))
plt.show()

相关系数（Correlation Coefficient）$r$ 的范围为 $[-1,1]$。正相关表示一个变量较大时另一个往往也较大；负相关相反；$|r|$ 接近 1 表示较强的线性关系。

$r=0$ 表示没有线性相关，不表示完全没有关系，也不保证独立（Independence）。 例如对称的 U 形关系可能线性相关很弱。散点图还能揭示分群、曲线、异常点，单个相关系数可能看不到这些结构。

相关性（Correlation）不能证明因果关系（Causation）。销售额与顾客数量相关不代表只增加顾客数量便必然按同样幅度提升利润；还需考虑客单价、成本及其他变量。

8. 纸笔例题与解答

题目。 对数组 [1,2,3,4,5,6,7,8,20]，使用 NumPy 默认百分位计算方式，已得 $Q_1=3$、$Q_2=5$、$Q_3=7$。求四分位距、上下围栏、上下须端点及异常值。

解答。 $IQR=4$，围栏为 $3-6=-3$ 和 $7+6=13$。围栏内最小观测为 1，最大为 8，所以须端点为 1、8。20 超过上围栏，是异常点。须端点不是 −3、13；中位数为 5，不能把它当均值。

9. 易错点与自测

常见错误：把 Axes 与 Axis 混淆；子图索引维度写错；把任意行号当时间；把直方图区间当类别；把箱内线当均值；把围栏当须端点；由相关性直接推出因果。

1. 比较四家门店总收入，优先选哪种图？
2. 检查客户收入分布是否右偏，优先选哪种图？
3. plt.subplots(2,2) 返回的 axes，右下角如何索引？
4. $Q_1=10$、$Q_3=18$ 时，上围栏是多少？值 29 是否越界？
5. 两个变量相关系数为 0，是否可以断定彼此独立？

简答： 1. 柱状图。2. 直方图，也可辅以箱线图。3. axes[1,1]。4. $18+1.5(18-10)=30$；29 没有越界。5. 不能，可能存在非线性关系。

课程来源

• Matplotlib 课程页
• 教师教程：Matplotlib 与 Pandas Charting
• Matplotlib 官方 boxplot 文档（核对默认围栏和须）
• Assignment 1：图表需服务于商业问题

本章小数据、纸笔例题与自测为复习自编。

返回复习导航

本章对应课堂的规则预测（Rule-Based Prediction）与启发式挑战（Heuristic Challenge）。复习目标：能解释为什么先做基线，能根据分组统计写规则，能识别提交文件和评估方式中的错误。

1. 从业务判断到基线

基线（Baseline）是衡量后续方法是否值得使用的参照。分类问题可以始终预测训练集中的多数类；回归问题可以始终预测训练目标的均值。基线并不保证很准，但提供了“复杂模型究竟改善了多少”的比较起点。

无模型预测（Model-Free Prediction）在本课中指直接由人编写规则，而不调用学习算法拟合参数。例如，根据训练数据的分组存活率，写出“女性预测存活、男性预测未存活”。规则仍然利用了数据中的信息。

启发式（Heuristic）是依据经验或数据现象制定的简便规则，不意味着它在所有样本上都正确。

2. Kaggle 的三个文件

Kaggle 的 test.csv 不等于本地测试集（Local Test Set）。 本地测试集通常从有标签的 train.csv 划出，因此我们能计算分数；Kaggle 测试文件的真实标签由平台保管，单靠该文件不能计算准确率。

Titanic 提交表需要 PassengerId 和 Survived 两列，其中 Survived 为整数 0 或 1。不要把 DataFrame 的索引额外导出成第三列。

3. 课堂 Titanic 的两条规则

课堂数据中，整体存活率约为 38.4%，所以多数类基线是全部预测 0。女性存活率约 74.2%，男性约 18.9%，由此得到第二条按性别预测的规则。

这些比例描述的是课堂给出的训练样本。它们不是业务规律的证明，也不保证未来数据保持同样比例。复习重点是从统计结果到规则的推理方式，无需死记某次排行榜分数。

准确率（Accuracy）的定义为：

两种规则必须在相同评估数据上比较。训练集准确率与另一规则的测试集准确率不能直接作为公平胜负依据。

4. 最小代码：先看分布，再写规则

以下为自建教学数据，并非完整 Titanic 数据。

import pandas as pd

train = pd.DataFrame({
    "Sex": ["male"] * 6 + ["female"] * 4,
    "Survived": [0] * 6 + [1, 1, 1, 0],
})

print(train["Survived"].value_counts(normalize=True))
print(train.groupby("Sex")["Survived"].mean())

# 训练多数类为 0
pred_constant = pd.Series(0, index=train.index)
pred_gender = train["Sex"].eq("female").astype(int)

print(pred_constant.eq(train["Survived"]).mean())  # 0.7
print(pred_gender.eq(train["Survived"]).mean())    # 0.9

运行输出：

Survived
0    0.7
1    0.3
Name: proportion, dtype: float64
Sex
female    0.75
male      0.00
Name: Survived, dtype: float64
0.7
0.9

因为 Survived 是 0/1，组内均值正好等于组内正类比例。上述两个分数只是训练样本上的描述，尚不能证明性别规则在新数据上一定更好。

下面演示提交格式，运行后会在当前目录生成 submission.csv。

test = pd.DataFrame({
    "PassengerId": [892, 893, 894],
    "Sex": ["male", "female", "male"],
})

submission = pd.DataFrame({
    "PassengerId": test["PassengerId"],
    "Survived": test["Sex"].eq("female").astype(int),
})

assert len(submission) == len(test)
assert submission["PassengerId"].equals(test["PassengerId"])
assert submission["Survived"].isin([0, 1]).all()
submission.to_csv("submission.csv", index=False)

导出的 CSV 内容：

PassengerId,Survived

892,0

893,1

894,0

这里假定 Sex 已检查且只有 male、female。实际数据若有缺失或其他取值，应事先指定合理的默认规则，不能让未知值无意中被当成男性。

若要练习课堂的 .apply()，等价写法为：

def survival_by_gender(sex):
    return int(sex == "female")  # 已确认仅有两类

prediction = test["Sex"].apply(survival_by_gender)

5. 启发式挑战的完整思路

以酒店取消（Cancellation）为例，先明确正类 Canceled = 1，再执行以下步骤：

1. 看总体取消比例，建立全部不取消的常数基线。
2. 按渠道、押金类型等分组，看取消率以及每组样本数。
3. 对提前预订天数等数值变量尝试有业务意义的区间。
4. 把发现写成少量可解释的条件，明确条件冲突时的优先级。
5. 在保留的验证数据上比较规则，并记录改动理由。
6. 为所有待预测订单输出结果，检查 ID 与提交格式。

例如，lead_time > 100 与 deposit_type == "No Deposit" 是两个条件，组合时要用括号：

bookings = pd.DataFrame({
    "booking_id": ["B01", "B02", "B03"],
    "lead_time": [30, 120, 150],  # 预订到入住的天数
    "deposit_type": ["No Deposit", "No Deposit", "Non Refund"],
})
risky = (bookings["lead_time"] > 100) & (
    bookings["deposit_type"] == "No Deposit"
)
rule_prediction = risky.astype(int)
print(rule_prediction.tolist())  # [0, 1, 0]，1 表示预测取消

运行输出：

[0, 1, 0]

上面三行是自建订单：B01 没超过 100 天，输出 0；B02 同时满足两个条件，输出 1；B03 虽提前 150 天，但押金类型不匹配，仍输出 0。& 要求两项都成立，.astype(int) 再把布尔值转成提交需要的 0/1。此处只有预测，没有真实取消标签，所以不能直接计算这三行的准确率。

阈值 100 只是示意，不是课程指定的最优阈值。样本很少的组出现 100% 取消率，并不能说明该规则值得推广。

6. 手算例题：高准确率是否足够

自建例题。 验证集有 100 个订单，其中 80 个未取消、20 个取消。规则 A 全部预测未取消；规则 B 正确找出 12 个取消订单，同时把 6 个未取消订单误报为取消。

规则 A 的正确数为 80，准确率为 80%。规则 B 的正确数为：

$12+(80-6)=86,\qquad \operatorname{Accuracy}_B=86\%.$

规则 B 在这个验证集上准确率更高。若误报和漏报损失不同，还应比较业务成本；第 09 章会计算这一点。规则 A 的 80% 也说明了类别不平衡（Class Imbalance）可能让“不做区分”的预测看起来很好。

7. 常见失分点

• 删除 Kaggle 测试数据的缺失行：会造成部分 ID 没有预测。应采用适当填充等方式保留待预测行。
• 独热编码后只比较列数：即使列数相同，列名或顺序也可能不同。
• 用测试数据决定均值、阈值或类别映射：标准流程应从训练数据学习这些内容，再应用到后续数据。
• 不断根据公共排行榜调规则：也可能对公共测试部分过拟合，排行榜分数并非永远可信的独立检验。
• 看到模型训练准确率更高就认为优于规则：应比较同一验证集或同一交叉验证设置下的结果。
• 认为规则简单就没有过拟合：大量试阈值、试组合也可能拟合验证集噪声。

8. 纸笔自测

1. train.csv 中 90% 的标签为 0。全部预测 0 是否说明模型已能识别正类？
2. Kaggle 的 test.csv 没有目标列，为什么仍称为测试数据？我们能直接计算准确率吗？
3. 导出提交文件时 index=False 的作用是什么？
4. 两条规则分别在不同验证划分上得到 0.81 和 0.82，能直接断定第二条更好吗？
5. 某训练组只有 2 个样本且全为正类，把未来所有该组样本预测为正类有什么风险？

自测答案

1. 不能。它在相同类比例的样本上可得到 90% 准确率，但正类召回率为 0。
2. 平台用隐藏标签评估提交结果；本地没有真实标签，不能直接计算准确率。
3. 不把 DataFrame 行索引写入 CSV，避免多出不需要的列。
4. 不能。样本难度和随机划分不同，应在同一评估设置下比较。
5. 组内比例非常不稳定，可能只是偶然现象；需要更多证据和独立验证。

9. 来源与复习边界

• 课程：Kaggle and Model-Free Prediction
• 课程：Rule-Based Prediction
• 课程：Heuristic Challenge

排行榜反复调试与验证集可比性属于帮助理解泛化的整理说明。考试具体题目与各章权重尚未公布。

返回复习导航

本章四条主线是缺失值（Missing Values）、异常值（Outliers）、标准化（Standardization）和类别编码（Categorical Encoding）。所有操作都要回答：为什么这样处理、从哪些数据学习规则、预测新样本时怎样保持一致。

1. 缺失值：先检查，再决定

缺失率是某列缺失数量除以样本总数。isna() 与 isnull() 在这里作用相同；字符串 "?"、"unknown" 不会自动成为缺失值，需要按数据定义清理。

import numpy as np
import pandas as pd

df = pd.DataFrame({
    "age": [20.0, 30.0, np.nan, 40.0],
    "city": ["A", "B", np.nan, "A"],
})
print(df.isna().sum())   # 两列都缺 1 个
print(df.isna().mean())  # 两列缺失率都为 0.25

运行输出：

age     1
city    1
dtype: int64
age     0.25
city    0.25
dtype: float64

填充值是估计，不等于真实值；填充后缺失数变成 0，不代表数据问题完全解决。

# 只演示各语句的作用，不要求依次执行
rows_kept = df.dropna(subset=["age"])
column_removed = df.drop(columns=["city"])
filled = df.assign(age=df["age"].fillna(df["age"].median()))

# 显示本例需要观察的结果
print(filled.to_string())

运行输出：

age city
0  20.0    A
1  30.0    B
2  30.0  NaN
3  40.0    A

dropna() 默认会删除含有任意缺失值的行；删除后如果特征 X 和目标 y 不同步，可能发生样本错配。应保留一致的行标识与索引。

2. 拟合与转换：训练数据决定规则

拟合（Fit）学习数据相关的参数；转换（Transform）使用已学到的参数处理数据。

先划分数据，再仅在训练部分拟合。 验证集、测试集使用同一个已拟合的预处理器。交叉验证中，每一折都必须只用该折的训练部分重新拟合预处理器。

如果先对全体数据填充、标准化，再做交叉验证，验证折的信息已进入预处理参数，形成数据泄漏（Data Leakage）。即使操作没用到目标值，也可能使评估偏乐观。

from sklearn.impute import SimpleImputer

train_age = np.array([[10.0], [20.0], [np.nan], [30.0]])
test_age = np.array([[np.nan], [100.0]])

imputer = SimpleImputer(strategy="mean")
train_filled = imputer.fit_transform(train_age)
test_filled = imputer.transform(test_age)
print(imputer.statistics_)  # [20.]
print(test_filled.ravel())  # [20., 100.]

运行输出：

[20.]
[ 20. 100.]

测试集的 100 不参与计算填充值。课程早期决策树示例为了演示曾使用测试集自身的均值；完整建模时采用这里的训练统计原则。

字符串类别不能用默认的均值填充器。应明确写成：

cat_imputer = SimpleImputer(strategy="most_frequent")
cat_values = cat_imputer.fit_transform(df[["city"]])

# 显示本例需要观察的结果
print(cat_values)

运行输出：

[['A']
 ['B']
 ['A']
 ['A']]

追踪填补前后的一条客户记录。 把本节 train_age 理解为四位历史客户的年龄列，第四位为 30 岁，第三位未填；test_age 是两位待预测客户，其中第一位未填、第二位为 100 岁。训练数据的已知年龄为 10、20、30，故只学到一个填充值 20。输出仍为四行训练数据、两行测试数据，行序不变，仅缺失位置被替换。

fit_transform(train_age) 同时做“学规则”和“应用规则”；transform(test_age) 只做后者。填补器没有推断出新客户实际 20 岁，它只给模型提供按既定规则补齐的输入。

3. 异常值：偏离常态不等于错误

异常值可能来自单位错误、录入错误，也可能是真实的高价值客户或极端事件。删除前应先解释其来源及业务意义。

标准分数（Z-score）为：

$z=\frac{x-\mu}{\sigma}.$

z=2 表示高于均值两个标准差；z=-1 表示低于均值一个标准差。课堂用 $|z|\geq 3$ 作为一种异常识别规则，它是启发式标准，并非所有分布都适用的真理。

s = pd.Series([10.0, 12.0, 14.0, 16.0])
z = (s - s.mean()) / s.std(ddof=0)
suspect = z.abs() >= 3

# 显示本例需要观察的结果
print("z:", z.round(3).tolist())
print("suspect:", suspect.tolist())

运行输出：

z: [-1.342, -0.447, 0.447, 1.342]
suspect: [False, False, False, False]

计算口径提醒： Pandas 的 .std() 默认 ddof=1；NumPy 的 np.std() 默认 ddof=0。小样本时结果可能明显不同。题目给定标准差时直接使用给定值；需要复现计算时统一口径。

箱线图（Box Plot）的常见异常界限：

$IQR=Q_3-Q_1,$

$\text{下界}=Q_1-1.5IQR,\qquad \text{上界}=Q_3+1.5IQR.$

不是“中位数上下各 $1.5IQR$”。箱须通常画到界限以内最远的实际观测值，不一定正好画到公式计算出的界限。

课堂示范删除异常值后重新计算 z-score，是因为数据的均值和标准差已改变。不能由此推导出“应反复删除，直到所有点都合格”；反复筛选可能持续损失真实样本。

建模时也不能为了得到好看的测试分数，看到预测困难的测试点就删去。若训练数据确需过滤，规则应有业务依据，并保持 X 与 y 对齐。

4. 标准化：统一尺度，不改变分布形状

标准化后的训练特征通常均值为 0、方差为 1；它不会自动把偏斜分布变成正态分布（Normal Distribution）。常数列无法除以非零标准差，库会作相应处理；不要把“所有列方差必为 1”当作无条件结论。

为什么要标准化：年龄、收入、面积的量纲和数量级不同，可能影响梯度下降的优化速度，也会影响依赖距离或系数尺度的算法。

决策树通常不需要标准化，因为对一个特征作保持次序的线性变换不会改变可切分的样本次序。课程流水线保留标准化，是为了展示通用预处理结构。

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
train_z = scaler.fit_transform(train_filled)
test_z = scaler.transform(test_filled)

沿用上面的年龄数据，填补后的训练列是 [10,20,20,30]，均值为 20，总体标准差约 7.071。因而测试中的缺失年龄先补成 20，再转成 0；100 岁则转成约 11.314：

print(np.round(train_z.ravel(), 3))  # [-1.414 0. 0. 1.414]
print(np.round(test_z.ravel(), 3))   # [0. 11.314]

运行输出：

[-1.414  0.     0.     1.414]
[ 0.    11.314]

顺序是“先补年龄，再按训练尺度换算”。100 岁变成很大的标准分数，提醒我们检查该输入是否合理；缩放不会自动删去它，也不会强制把它限制在某个区间。

注意：测试集变换后不要求均值也等于 0、方差也等于 1，因为使用的是训练集参数。若为了达到这两个数重新 fit 测试集，就改变了模型看到的坐标系。

手算例题。 训练集某特征均值为 50，标准差为 10。新样本值 65 对应 $z=(65-50)/10=1.5$。树中若有条件 z <= -0.5，还原为原单位即 $x\leq 50-0.5\times10=45$。

5. 类别编码：整数标签不等于数值大小

顺序编码（Ordinal Encoding）把类别映射成整数。如果类别本身有顺序，例如低、中、高，指定有意义的顺序通常合理。如果类别没有顺序，例如城市 A、B、C，编码成 0、1、2 可能引入不合理的大小关系或限制切分方式。

独热编码（One-Hot Encoding）为每个类别建立指示列。例如城市 B 表示为 [0, 1, 0]。通常不应把它理解成连续数量。

city = pd.Series(["A", "B", "C", "A"], name="city")
print(pd.get_dummies(city, dtype=int))

运行输出：

A  B  C
0  1  0  0
1  0  1  0
2  0  0  1
3  1  0  0

类别很多时，独热编码会产生大量列。可以依据业务知识合并类别；不要仅为减少列数任意合并有明显业务差异的取值。课程提到降维，但不需要在本章自行扩展到主成分分析的推导。

独立对训练集和测试集调用 get_dummies()，可能得到不同的列集合。更稳妥的通用方式是拟合编码器后重用它：

from sklearn.preprocessing import OneHotEncoder

encoder = OneHotEncoder(handle_unknown="ignore", sparse_output=False)
train_cat = np.array([["A"], ["B"], ["A"]])
test_cat = np.array([["B"], ["C"]])

encoder.fit(train_cat)
print(encoder.get_feature_names_out(["city"]))
print(encoder.transform(test_cat))
# B -> [0., 1.]；未知 C -> [0., 0.]

运行输出：

['city_A' 'city_B']
[[0. 1.]
 [0. 0.]]

为什么 B 变成 [0,1]，C 变成 [0,0]？ 训练时只出现 A、B，因此输出两列 city_A、city_B，而不是为未来每个可能的城市预留一列。新客户来自 B，就填“不是 A、是 B”；C 在训练中没见过，指定忽略未知类别后，两列都为 0。增加新样本不会自动增加第三列，否则已训练模型的输入列数就对不上了。

handle_unknown="ignore" 解决未知类别的转换报错问题，不会让模型自动学会未知类别的行为。上述“全零”是该原始特征对应的编码块，不是把整个样本变成零。

6. 预处理顺序与代码阅读

典型数值分支：缺失填充 → 标准化。典型类别分支：缺失填充 → 独热编码。两条分支合并后送入模型，见第 09 章的完整流水线（Pipeline）。

从字符串转换数值时，pd.to_numeric(..., errors="coerce") 会把无法解析的值变成缺失值，因此后续仍需检查与处理。Pclass 虽然存成整数，也可以按业务意义作为类别特征；数据类型与特征的统计含义不是一回事。

7. 纸笔自测

1. 训练收入为 [10, 20, 30, NaN]，测试收入为 [100, NaN]。均值填充时，测试缺失值应填多少？
2. 标准化能否消除偏态？标准化后的测试集均值必须为 0 吗？
3. $Q_1=20,Q_3=40$，常用箱线图异常上下界是多少？
4. 为什么应把填充器放进交叉验证的流水线，而不是先填完整份数据？
5. 对城市编码为 0、1、2，相比独热编码可能引入什么问题？

自测答案

1. 20，使用训练集非缺失值的均值。不能用测试集中的 100 来填。
2. 均不能保证。标准化是中心化与缩放，测试集使用训练参数。
3. $IQR=20$，下界 $20-30=-10$，上界 $40+30=70$。
4. 每个验证折的填充值只能由该折的训练数据学习，避免泄漏。
5. 人为赋予类别顺序或距离；类别本身没有这些关系时会误导某些模型。

8. 来源与口径校正

• 课程：Data Preprocessing
• 课程：Decision Tree Prediction
• 课程：Full Pipeline
• 官方：StandardScaler：标准化的含义与训练参数。
• 官方：SimpleImputer：填充策略及默认值。
• 官方：Matplotlib boxplot：箱线图界限与箱须。

课件有关“标准正态分布”“中位数上下 1.5 IQR”的措辞在这里按上述定义校正；考试手算采用题目给定数据和明确的统计口径。

返回复习导航

本章复习顺序：沿树预测 → 计算纯度与信息增益 → 选择切分 → 限制复杂度 → 读懂训练代码。掌握小型手算比记住完整树图更重要。

1. 一棵树如何做预测

根节点（Root Node）提出第一个问题；内部节点（Internal Node）继续检查特征；叶节点（Leaf Node）给出最终结果。一个样本从根出发，沿条件分支走到一个叶节点。

分类树（Classification Tree）输出类别，常用叶内多数类作为预测；predict_proba() 根据叶内类别比例返回概率，在使用样本权重时是加权比例。

回归树（Regression Tree）输出数值；在平方误差准则下，叶节点预测该叶内训练目标的均值。

分类与回归树（Classification and Regression Trees, CART）可处理两类任务。课堂的 ID3 例子可按类别作多分支切分，而 scikit-learn 的 CART 实现使用二叉切分，不要把所有树都想成同一种分支结构。

Fare <= 30 ?
├─ True：预测 0
└─ False：Age <= 10 ?
           ├─ True：预测 1
           └─ False：预测 0

例如 Fare=50, Age=8 最终预测 1；Fare=20, Age=8 在第一层就到达叶节点，不再检查年龄。上图为自建示意，不是课堂数据训练结果。

2. 不纯度、熵与基尼不纯度

纯度（Purity）描述节点中的类别是否一致。只有一个类别的节点是纯节点；类别分布越均匀，通常越不纯。

设节点中共有 $K$ 个类别，第 $k$ 类占比为 $p_k$。

熵（Entropy）：

$H=-\sum_{k=1}^{K}p_k\log_2 p_k.$

约定 $0\log_2 0=0$。二分类纯节点的熵为 0；两类各一半时熵为 1。多分类熵的最大值是 $\log_2 K$，所以“熵最大为 1”只适用于这里的二分类情况。

基尼不纯度（Gini Impurity）：

$G=1-\sum_{k=1}^{K}p_k^2.$

二分类纯节点的 Gini 为 0；各一半时为 0.5。不要把 Gini 与准确率混为一谈。

scikit-learn 的 DecisionTreeClassifier 默认准则为 gini；课堂手算重点是 entropy。API 的另一个取值写作 "log_loss"，中间有下划线。

3. 信息增益必须按子节点大小加权

父节点有 $n$ 个样本，切分为多个子节点，第 $j$ 个子节点有 $n_j$ 个样本，其熵为 $H_j$。信息增益（Information Gain）为：

$IG=H_{parent}-\sum_j\frac{n_j}{n}H_j.$

比较同一父节点的候选切分，选择信息增益最大的切分，也就是切分后加权熵最小的切分。子节点数量不相同时，不能简单对其熵取算术平均。

如果采用 Gini，则把公式里的熵换成 Gini，得到对应的不纯度下降（Impurity Decrease）。

手算例题：选择哪种切分

以下是自建频数表。父节点有 10 个样本，正类 6 个、负类 4 个。

父节点熵：

$H_{parent}=-0.6\log_2 0.6-0.4\log_2 0.4\approx0.971.$

A 的左子节点纯，熵为 0；右子节点熵为：

$H_R=-\frac13\log_2\frac13-\frac23\log_2\frac23\approx0.918.$

于是：

$IG_A=0.971-\left(\frac4{10}\times0+\frac6{10}\times0.918\right)\approx0.420.$

B 的两个子节点比例都与父节点相同，故加权熵仍为 0.971，$IG_B=0$。应选择 A。

若改用 Gini，父节点为 $1-0.6^2-0.4^2=0.48$，A 的加权子节点 Gini 为 $(6/10)\times(4/9)\approx0.267$，下降约 0.213。这里两种准则都选择 A，但一般不保证所有候选切分的排序相同。

4. 对应课堂 Golf 数据的关键结果

课堂 Golf 数据有 9 个 yes、5 个 no，父节点熵约 0.940。按 Outlook 分组后的频数为：

按原始比例计算，加权熵为 $\frac5{14}H(3/5,2/5)+\frac4{14}\times0+\frac5{14}H(2/5,3/5)\approx0.693536$，保留三位小数为 0.694，信息增益约 0.247。课件显示的 0.693 是近似展示，手算以原始比例计算为准。

Outlook 在该例中优于 Humidity、Windy、Temp，所以成为根节点。后续只在相应子集内重新计算：

• overcast 全为 yes，直接成为叶节点。
• sunny 按 Windy 切分后变纯。
• rainy 按 Humidity 切分后变纯。

不同教材的经典 Golf 表可能交换 sunny 与 rainy 的命名；做本课题目应使用本课给定频数，不要套用背熟的另一张表。

5. 数值特征的切分点

对排序后的不同取值，可以考虑相邻不同值的中点。例如 [10, 20, 20, 40] 的候选中点为 15 和 30，而不是在重复的 20 之间制造有效分组。

每个候选阈值都形成“$x\leq t$”与“$x>t$”两个子集，再计算不纯度下降。也可先分箱（Binning），把数值转成区间类别，但可能损失细节。

贪心算法（Greedy Algorithm）在当前节点选择最佳切分，不保证得到所有可能树中全局最优的一棵树。

6. 为什么要剪枝

不断切分通常能降低训练误差，却可能记住偶然差异，导致过拟合（Overfitting）。限制树的复杂度属于正则化（Regularization）；虽然后续“多项式回归与正则化”章节被排除，树的剪枝仍在本章范围内。

预剪枝（Pre-pruning）在生长时限制树：

在二叉树中，根深度记为 0，max_depth=3 至多产生 $2^3=8$ 个叶节点；实际可能更少。浅树也可能含只覆盖一个样本的叶节点，因此深度限制与最小叶样本量不是同一约束。

min_impurity_decrease 的库实现还考虑当前节点占全部训练样本的权重；不要无条件把它等同于未加权的局部 $IG$。

默认不限制深度的树不保证所有叶节点都纯。例如两行特征完全相同但标签相反，就无法再通过特征将它们分开。默认树训练准确率可能达到 1，但不能据此保证测试表现。

后剪枝 ccp_alpha：课程标为可选（Optional）

代价复杂度剪枝（Cost-Complexity Pruning）权衡拟合误差与叶节点数量：

$R_\alpha(T)=R(T)+\alpha|L(T)|,$

其中 $R(T)$ 是叶节点按样本占比加权的不纯度，$|L(T)|$ 为叶节点数。更大的 ccp_alpha 使额外叶节点更“昂贵”，通常得到更小的树。具体最优值要由验证或交叉验证选择。

本小节在课件中标为可选；考试页没有单独明确排除，建议至少掌握方向和含义。

7. 最小训练代码与输出解释

以下代码使用自建数据，目的是读懂 fit、predict 和叶节点概率。

import pandas as pd
from sklearn.tree import DecisionTreeClassifier

X = pd.DataFrame({"fare": [5, 10, 20, 50, 60, 70]})
y = [0, 0, 0, 1, 1, 1]

model = DecisionTreeClassifier(
    criterion="entropy", max_depth=1, random_state=42
)
model.fit(X, y)

new = pd.DataFrame({"fare": [15, 55]})
print(model.predict(new))        # [0, 1]
print(model.classes_)            # [0, 1]
print(model.predict_proba(new))  # [[1., 0.], [0., 1.]]
print(model.get_depth())         # 1
print(model.get_n_leaves())      # 2

运行输出：

[0 1]
[0 1]
[[1. 0.]
 [0. 1.]]
1
2

把六条训练记录和两条新记录串起来看。 本例是人为简化的旅客数据：每行是一名旅客，fare 是票价，y=1 表示存活、0 表示未存活。低票价的三条标签均为 0，高票价的三条均为 1，因此深度为 1 的树可在 20 与 50 之间取中点 35 切分。

新旅客票价 15，满足 fare <= 35，进入左叶预测 0；票价 55 进入右叶预测 1。new 为 (2,1)，predict(new) 是长度为 2 的类别数组，predict_proba(new) 为 (2,2)：每行一名旅客，两列依 classes_ 对应类别 0、1。这里的极端概率来自小型纯叶，不表示现实中票价决定存活。

fit(X, y) 学习切分；predict(new) 使用已经学好的规则，不会重新训练。预测输入必须与训练时的特征定义和顺序一致。类别变量的编码与缺失值处理应纳入第 09 章的流水线。

叶中 100% 为某类，是当前训练数据支持的叶内比例，不表示未来预测具有绝对确定性。

8. 读树图的细节

• scikit-learn 图中 feature <= threshold 条件成立走左分支，不成立走右分支。
• Sex_female <= 0.5 表示该独热列为 0，即不是已编码的 female 类。只有数据确实只有男/女两类时，才能直接称为男性。
• 若数值特征先标准化，阈值也是标准化单位，需要按 $x=\mu+z\sigma$ 还原。
• samples 表示到达节点的训练样本数量或比例，取决于作图选项；value 的显示也受版本、权重和作图参数影响，应先读图例。
• class 是节点的预测类别；entropy 或 gini 是不纯度，不是预测错误率。

9. 纸笔自测

1. 二分类节点有 5 个正类和 5 个负类，熵和 Gini 分别为多少？
2. 两个子节点熵分别为 0 和 1，样本数分别为 90 和 10。加权熵是多少？
3. min_samples_split=10 能否保证每个叶节点至少有 10 个样本？
4. 为什么训练准确率为 1 不能说明模型已经足够好？
5. 一个叶节点有 3 个负类、7 个正类，在无权重设置下预测类别和正类概率是什么？

自测答案

1. 熵为 1，Gini 为 0.5。
2. $(90/100)\times0+(10/100)\times1=0.1$，不是 0.5。
3. 不能。它限制父节点能否尝试切分；最小叶节点样本量由 min_samples_leaf 控制。
4. 可能记住训练集噪声，需用未参与拟合与选择的独立数据检验泛化。
5. 预测正类 1，正类概率为 0.7。

10. 来源

• 课程：Decision Tree Basics
• 课程：Decision Tree Prediction
• 课程：Feature Importance
• 官方：Decision Trees
• 官方：DecisionTreeClassifier

返回复习导航

本章把前面内容连接成完整流程：定义指标 → 划分数据 → 选择模型与参数 → 重新拟合 → 最终测试 → 解释预测依据。下文将课件及作业中的明确要求与可选内容分别标注。

1. 先定义正类，再读混淆矩阵

混淆矩阵（Confusion Matrix）比较真实类别与预测类别。下面约定取消订单为正类：Canceled = 1，未取消为负类：Canceled = 0。

True/False 表示预测是否正确，Positive/Negative 表示预测成了哪一类。

• 假正例（FP）：误报，实际没取消却预测取消；对应第一类错误（Type I Error）。
• 假负例（FN）：漏报，实际取消却预测没取消；对应第二类错误（Type II Error）。

scikit-learn 在 labels=[0, 1] 时，行是真实值、列是预测值，排列为：

$\begin{bmatrix}TN&FP\\FN&TP\end{bmatrix}.$

课堂部分表格把正类放在第一行和第一列，位置会变成 [[TP, FN], [FP, TN]]。先读标签顺序，不要只背四个格子的位置。

2. 四个核心分类指标

记 $N=TP+TN+FP+FN$。

精确率的分母来自“预测正类”，召回率的分母来自“真实正类”。F1 不是 $(P+R)/2$，也不直接考虑 TN。

分母为 0 时，指标在数学上需要特殊处理。代码可设置 zero_division=0 采用明确的返回约定；不要把“没有预测正类”解释为精确率必然等于 1。

类别不平衡（Class Imbalance）时，准确率可能掩盖完全漏掉少数类的问题；应根据业务需求同时检查混淆矩阵、召回率、精确率与成本。

手算例题：指标与业务损失

自建例题，成本采用 Assignment 3。 某测试集有 100 个订单：

$\begin{bmatrix}TN&FP\\FN&TP\end{bmatrix}=\begin{bmatrix}65&5\\10&20\end{bmatrix}.$

因此：

$Accuracy=\frac{65+20}{100}=0.85,$

$P=\frac{20}{20+5}=0.8,\qquad R=\frac{20}{20+10}=\frac23\approx0.667,$

$F1=\frac{40}{40+5+10}=\frac8{11}\approx0.727.$

作业设定：酒店对预测会取消的订单超售；FP 导致客人到店却无房，成本约 400 美元；FN 导致空房，成本约 150 美元。因此：

$C=400FP+150FN=400\times5+150\times10=3500.$

若全部预测不取消，30 个实际取消订单全部成为 FN，成本为 $30\times150=4500$。这个模型相对该基线节省 1000 美元。

FP 更贵，因此需要重视精确率，减少错误触发超售。但最终应比较总成本；不能只因精确率更高就无条件选模型，因为漏报数量也会变化。

最小指标代码

from sklearn.metrics import (
    confusion_matrix, accuracy_score,
    precision_score, recall_score, f1_score,
)

y_true = [0] * 70 + [1] * 30
y_pred = [0] * 65 + [1] * 5 + [0] * 10 + [1] * 20

cm = confusion_matrix(y_true, y_pred, labels=[0, 1])
tn, fp, fn, tp = cm.ravel()
print(cm)
print(accuracy_score(y_true, y_pred))
print(precision_score(y_true, y_pred, zero_division=0))
print(recall_score(y_true, y_pred, zero_division=0))
print(f1_score(y_true, y_pred, zero_division=0))
print(400 * fp + 150 * fn)  # 3500

运行输出：

[[65  5]
 [10 20]]
0.85
0.8
0.6666666666666666
0.7272727272727273
3500

3. 留出法：训练、验证、测试各司其职

留出法（Holdout Validation）把有标签数据分成不同部分。

课程练习使用 60% / 20% / 20%。先取出总样本的 20% 作为测试集，再从剩余的 80% 中取出四分之一，得到总样本的 20% 作为验证集。

# 假设 X、y 已准备好，且每个类别有足够样本
from sklearn.model_selection import train_test_split

# X_dev, X_test, y_dev, y_test = train_test_split(
#     X, y, test_size=0.2, random_state=409
# )
# X_train, X_val, y_train, y_val = train_test_split(
#     X_dev, y_dev, test_size=0.25, random_state=409
# )

用人数理解两次拆分。 若原来有 1,000 条订单，第一次留下 200 条最终测试、800 条开发数据；第二次从 800 条里取 25%，即 200 条验证，剩 600 条训练。若第二次误写 test_size=0.2，只会取出 160 条验证数据，不能得到所需的 60%/20%/20%。X 与 y 同时传入，是为了让同一订单的特征和标签始终一起分到同一组。

这里保留课堂指定的随机划分方式；为了与作业的 2,709 个测试订单一致，不应自行添加 stratify 或提前删行。其他分类项目可考虑 stratify=y 保持类别比例，但那是另一种划分。

只看一次测试集的意义是：特征、预处理、参数和阈值都已固定。若根据测试结果修改模型，该数据实际上已参与选择，不能再把它当作完全独立的最终检验。

random_state 使随机划分可复现，不会让某个划分天然更可靠，也不应不断换种子直到分数最高。

补充理解：有时间先后关系或同一客户多行的数据，随机按行切分可能使信息跨集合流动，应根据预测场景考虑按时间或实体划分。此处用于理解泄漏，不扩展为新的考试章节。

4. 过拟合与欠拟合

这些是诊断线索，不是仅靠两行数字就能绝对判定的定理。训练和验证分数都低，也可能来自目标噪声、错误标签或不合适的指标。

交叉验证（Cross-Validation）帮助发现问题和选择参数；它本身不会把同一棵过深的树自动变简单。更多样本也不能保证修复一个表达能力不足的模型。

5. K 折交叉验证如何工作

先保留最终测试集。把剩余的开发数据（Development Data）划成 $K$ 折：每轮用 $K-1$ 折训练，剩下一折验证，轮流做 $K$ 次，得到 $K$ 个验证分数。

$\overline{s}_{CV}=\frac1K\sum_{k=1}^{K}s_k.$

一次 5 折交叉验证中，每个样本作为验证样本一次，作为训练样本四次；每个模型只看到开发数据的约 80%。最终选定参数后，要用全部开发数据重新拟合（Refit），而不是随便取其中一折的模型作为最终模型。

cross_validate(..., scoring="accuracy") 返回 test_score；若使用多指标列表，例如 scoring=["accuracy", "f1"]，则返回 test_accuracy、test_f1。这里的 test 指交叉验证的留出折，不是锁定的最终测试集。

设置 return_train_score=True 可获得每折训练分数，用于对比训练与验证差距。预处理器必须与模型一起放入流水线，让每折独立学习其训练部分的统计量。

具体到 800 条开发订单： 5 折各 160 条。第 1 轮用第 2–5 折的 640 条训练，在第 1 折 160 条上评分；第 2 轮换第 2 折验证。若比较深度 2 与深度 5，两种设置都使用相同五折，各得五个验证分数，再比较平均值。锁定的 200 条最终测试订单全程不参与这个比较。

6. 网格搜索：组合数、拟合次数、最优结果

网格搜索（Grid Search）穷举预先指定的超参数（Hyperparameters）组合，再用交叉验证比较。

例如 criterion 有 2 种、max_depth 有 5 种：

$\text{组合数}=2\times5=10.$

每组做 5 折交叉验证，需要 $10\times5=50$ 次拟合。在默认 refit=True 且正常完成时，最佳组合还会在全部传入训练数据上拟合一次：

$\text{总拟合次数}=\text{组合数}\times K+1=51.$

课堂完整流水线的网格是：填充策略 2 种 × 准则 2 种 × 深度 5 种 × 分类填充策略 1 种，配合 10 折交叉验证，总计 $20\times10+1=201$ 次树拟合。若 refit=False，没有最后的 $+1$。

这里数的是模型拟合次数，不是不同超参数组合数；每次拟合还会学习对应流水线中的预处理参数。

不要把所有候选组合的 mean_test_score 再取平均，当成最佳模型分数。课程有展示这个总体均值，但它与 best_score_ 回答的是不同问题。GridSearchCV 官方定义

参数路径使用双下划线：preprocessor__num_pipeline__imputer__strategy，表示依次进入预处理器、数值分支、填充器，再设置其 strategy。实际路径必须与自己定义的步骤名一致。

7. 可运行的完整流水线

下例用自建的 60 行旅客数据演示存活分类：一行一名旅客，Age 为年龄、Fare 为票价、Sex 为性别，target=1 表示本教学例子设定的存活标签。标签由下面的人工规则生成，只为演示代码，不代表真实 Titanic 数据或现实因果关系。本例的正类是存活，与前面酒店例子的“取消”含义不同。

需要解决的问题： 部分年龄与性别缺失，性别又不能直接作为字符串送入这段树训练代码；同时要比较填补策略与树参数，还要避免验证数据参与预处理。流水线将这些步骤绑在一起，每次给它原始旅客表即可。

import numpy as np
import pandas as pd
from sklearn.model_selection import (
    train_test_split, StratifiedKFold, GridSearchCV,
)
from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score, confusion_matrix

# 自建数据，先生成完整特征与标签
rng = np.random.default_rng(409)
n = 60
age = rng.integers(18, 70, size=n).astype(float)
fare = rng.uniform(10, 100, size=n)
sex = rng.choice(["female", "male"], size=n).astype(object)
target = (((sex == "female") & (age < 50)) | (fare > 70)).astype(int)
age[::11] = np.nan
sex[::13] = np.nan
X = pd.DataFrame({"Age": age, "Fare": fare, "Sex": sex})
y = pd.Series(target, name="target")

# 本示例使用分层划分，不复现作业指定测试集
X_dev, X_test, y_dev, y_test = train_test_split(
    X, y, test_size=0.2, random_state=409, stratify=y
)
num_features = ["Age", "Fare"]
cat_features = ["Sex"]

num_pipeline = Pipeline([
    ("imputer", SimpleImputer(strategy="median")),
    ("scaler", StandardScaler()),
])
cat_pipeline = Pipeline([
    ("imputer", SimpleImputer(strategy="most_frequent")),
    ("onehot", OneHotEncoder(handle_unknown="ignore")),
])
preprocessor = ColumnTransformer([
    ("num_pipeline", num_pipeline, num_features),
    ("cat_pipeline", cat_pipeline, cat_features),
])
pipeline = Pipeline([
    ("preprocessor", preprocessor),
    ("tree", DecisionTreeClassifier(random_state=409)),
])

param_grid = {
    "preprocessor__num_pipeline__imputer__strategy": ["mean", "median"],
    "tree__criterion": ["gini", "entropy"],
    "tree__max_depth": [1, 2, 3, 4, 5],
}
cv = StratifiedKFold(n_splits=3, shuffle=True, random_state=409)
search = GridSearchCV(pipeline, param_grid, cv=cv, scoring="accuracy")
search.fit(X_dev, y_dev)

# 20 个组合 × 3 折 + 1 次重拟合 = 61 次
best = search.best_estimator_
print(search.best_params_)
print(search.best_score_)

# 选择完成后再评估测试集
prediction = best.predict(X_test)
print(accuracy_score(y_test, prediction))
print(confusion_matrix(y_test, prediction, labels=[0, 1]))

运行输出：

{'preprocessor__num_pipeline__imputer__strategy': 'mean', 'tree__criterion': 'gini', 'tree__max_depth': 4}
0.8958333333333334
1.0
[[6 0]
 [0 6]]

沿着一批数据追踪形状：

例如性别为 female 的旅客会进入类别分支，得到 [1,0]；年龄缺失则进入数值分支，先用该次拟合学到的填充值补齐，再标准化。合并后的四列才送给树。四列的实际名字可以用下面的 get_feature_names_out() 检查，不能靠猜测拼接顺序。

拿到模型后，怎样预测一名新旅客？下面续接 best，无需重新 fit：

new_passenger = pd.DataFrame({"Age": [np.nan], "Fare": [80.0], "Sex": ["female"]})
new_prediction = best.predict(new_passenger)
print(new_prediction.shape)  # (1,)，一位旅客对应一个预测

运行输出：

(1,)

这条调用会自动执行填补、缩放、编码和预测。不要先手工把它变成四列，再传给仍期待原始三列的 best。

这段代码值得逐层解释：

1. ColumnTransformer 按列把数值特征和类别特征送入不同分支，再拼接输出。
2. Pipeline 按顺序执行各步骤，最后一步是模型。
3. 搜索的每个训练折都重新拟合填充器、标准化器、编码器和树。
4. best.predict(X_test) 自动执行已经学好的预处理，再预测；不用手动重复填充与编码。
5. 分类填充器明确设为 most_frequent，所以即使不运行网格搜索也能处理字符串。

原课件的分类分支先写 SimpleImputer()，后来通过网格设成 most_frequent；如果只复制前半段直接 fit，默认 mean 会导致字符串填充失败。这里把可用策略直接写入分支。

8. 特征重要性：模型为什么这样预测

基于不纯度下降的重要性（Mean Decrease in Impurity, MDI）统计某个特征在树中所有切分带来的加权不纯度下降。

设训练集总样本数为 $N$，内部节点 $t$ 有 $n_t$ 个样本，左右孩子分别为 $n_L,n_R$；节点贡献为：

$\Delta_t=\frac{n_t}{N}\left[I_t-\frac{n_L}{n_t}I_L-\frac{n_R}{n_t}I_R\right].$

某个特征 $j$ 的原始贡献为所有使用它的节点贡献之和，再除以所有特征的总贡献得到重要性：

$FI_j=\frac{\sum_{t:\,split(t)=j}\Delta_t}{\sum_t\Delta_t}.$

存在有效分裂时，通常归一化为总和 1；若树完全没有分裂，重要性可以全为 0。上式为无样本权重情形；带权训练使用相应加权计数。

自建手算。 特征 A 在根节点贡献 0.20，又在一个子节点贡献 0.05；特征 B 贡献 0.15。总贡献 0.40，所以 $FI_A=0.25/0.40=0.625$，$FI_B=0.375$。同一特征的贡献必须跨节点相加；根节点使用的特征不保证在所有树中都是最终最重要的。

编码后列数为什么更多

原始 3 个特征可能被变为 4 列：Age、Fare、Sex_female、Sex_male。重要性数组对应模型实际输入的编码后列，应按相同顺序取列名。

以下续接上一节的完整代码：

prep = best.named_steps["preprocessor"]
tree = best.named_steps["tree"]
names = prep.get_feature_names_out()

importance = pd.Series(tree.feature_importances_, index=names)
print(importance.sort_values(ascending=False))

# 将独热列按原始特征汇总
encoder = prep.named_transformers_["cat_pipeline"].named_steps["onehot"]
origins = num_features + [
    feature
    for feature, categories in zip(cat_features, encoder.categories_)
    for _ in categories
]
by_original = pd.Series(tree.feature_importances_).groupby(origins).sum()
print(by_original.sort_values(ascending=False))

运行输出：

num_pipeline__Fare          0.421692
cat_pipeline__Sex_male      0.299211
num_pipeline__Age           0.279096
cat_pipeline__Sex_female    0.000000
dtype: float64
Fare    0.421692
Sex     0.299211
Age     0.279096
dtype: float64

这里汇总代码适用于上例的“不丢弃类别、不合并低频类别、无全缺失列”设置。若变更编码策略，需要同步更新映射。不要简单取列名第一个下划线前的字符串：lead_time 这种原始名称本身就有下划线。

重要性不能说明什么

• 没有方向：0.6 的重要性不代表该特征越大，正类概率就越高。
• 不是因果效应（Causal Effect）：能预测取消的变量，不一定是取消的原因。
• 不是个体解释：总体重要性不等于某一个订单的具体决策原因。
• 零重要性不等于无用：另一相关特征可能已承担同样的信息，或树太浅没有使用它。
• 不是无偏的通用排名：不纯度重要性可能偏向可切分取值多的特征，且相关特征会分担或替代贡献。

比较分组结果可辅助理解方向，但更细的条件关系应直接读树的分支，不能只用总体分组比例替代模型解释。发现预测时不可能获得的变量异常重要，例如“退款已发生”，还应排查泄漏。

9. 置换重要性：与后续回归内容衔接

置换重要性（Permutation Importance）固定已训练模型，将某一输入列的值随机打乱，观察分数下降：

$PI_j=\text{原始分数}-\text{打乱特征 }j\text{ 后的分数}.$

它不需要重新训练模型，可用于多种模型。若使用 neg_root_mean_squared_error，分数下降对应 RMSE 增加。重要性接近 0 或小于 0 可能来自该特征贡献有限、噪声或样本波动；高度相关的特征可能互相替代，使各自的重要性偏低。置换重要性官方说明

以下代码续接已固定的 best，在测试集上只作最终报告解释；不能再据此筛特征、调模型后仍称该测试集完全独立。

from sklearn.inspection import permutation_importance

result = permutation_importance(
    best, X_test, y_test,
    scoring="accuracy", n_repeats=5, random_state=409,
)
print(pd.Series(result.importances_mean, index=X_test.columns))

运行输出：

Age     0.15
Fare    0.40
Sex     0.20
dtype: float64

打乱一列具体在做什么？ 假设原始测试准确率为 0.85，把年龄在旅客之间随机交换后降至 0.78，则该次年龄重要性为 0.85−0.78=0.07，即下降 7 个百分点。旅客行、真实标签和其他特征都保留，只破坏年龄与对应旅客的配对。若重新训练模型，它就有机会适应被打乱的数据，回答的便不再是“现有模型有多依赖年龄”。这些数值仅为手算说明。

因为传入的是完整流水线与原始 DataFrame，这里直接得到原始列层面的重要性。若重要性用于选择特征，应在训练/验证流程内进行，最终测试数据继续保留。

10. 阈值、PR 与 ROC/AUC：课件标为可选

本节在课程页面标题中标为可选（Optional），考试页未单独声明排除。先掌握核心指标和评估流程，再复习本节定义与方向。

对模型返回的正类分数 $s(x)$，可以规定阈值 $t$：$s(x)\geq t$ 时预测正类。概率列的顺序应查 classes_，不能对所有模型都假定第二列一定对应想要的正类。

提高阈值会使预测正类集合缩小，因此在同一组固定分数上，召回率不会上升；精确率通常会上升，但不保证单调上升。某一步若删除了较多真正例，精确率也可能下降。平票处理及默认预测规则可能依模型而异。

精确率—召回率曲线（Precision-Recall Curve, PR Curve）通常以召回率为横轴、精确率为纵轴，描述阈值变化下的表现。平均精确率（Average Precision, AP）可用作曲线的汇总指标；不必把它与所有实现中的几何面积完全等同。

受试者工作特征曲线（Receiver Operating Characteristic Curve, ROC Curve）：

$TPR=\frac{TP}{TP+FN}=Recall,\qquad FPR=\frac{FP}{FP+TN}.$

横轴是假正率（False Positive Rate, FPR），纵轴是真正率（True Positive Rate, TPR）。越靠近左上角通常越好。

曲线下面积（Area Under the ROC Curve, AUC）概括不同阈值下的排序能力：随机排序的期望约 0.5；完美排序为 1；也可能小于 0.5。更精确的概率解释是：随机选一正一负样本，正样本得分更高的概率，加上平分概率的一半。

计算 AUC 应使用概率或连续决策分数，而不是只传入最终 0/1 预测。AUC 高不保证当前阈值下成本低，也不直接保证概率校准准确。正类稀少时，应同时看 PR 曲线和业务指标，不能把 ROC/AUC 当作自动解决不平衡问题的办法。

# 续接上文 best；本例 classes_ 为 [0, 1]
from sklearn.metrics import roc_auc_score, precision_recall_curve

positive_column = list(best.classes_).index(1)
scores = best.predict_proba(X_test)[:, positive_column]
print(roc_auc_score(y_test, scores))
precision, recall, thresholds = precision_recall_curve(y_test, scores)

运行输出：

1.0

precision、recall 比 thresholds 多一个元素；画“阈值—指标”图时通常使用 precision[:-1] 与 recall[:-1] 配对阈值。

11. 纸笔自测

1. 有 confusion_matrix(..., labels=[0,1]) = [[40,10],[5,45]]，求准确率、精确率、召回率、F1。
2. 某网格含 3 个深度、2 个准则、2 个填充策略，做 5 折交叉验证且默认重新拟合，共拟合多少棵树？
3. 为什么 cv_results_["mean_test_score"].mean() 不是最佳模型的交叉验证分数？test_score 是否表示最终测试集分数？
4. 先用全体数据拟合标准化器，再对模型做交叉验证，有何问题？
5. 某特征重要性为 0，能否立刻断定应删除？提高分类阈值能否保证精确率升高？

自测答案

1. $Accuracy=85/100=0.85$；$P=45/55\approx0.818$；$R=45/50=0.9$；$F1=90/105\approx0.857$。
2. 组合数 $3\times2\times2=12$；总拟合次数 $12\times5+1=61$。
3. 它平均了所有候选组合；最佳组合对应 best_score_。CV 的 test_score 是验证折分数。
4. 验证折数据已参与均值和标准差估计，形成泄漏；应把预处理放进每折的流水线。
5. 均不能。重要性依赖当前模型和其他特征，应通过训练/验证流程检查删列效果；阈值升高时精确率可能局部下降。

12. 来源

• 课程：Model Evaluation Basics
• 课程：Model Evaluation and Selection
• 课程：Model Evaluation In-Class Exercise
• 课程：Model Tuning via Grid Search
• 课程：Full Pipeline
• 课程：Feature Importance
• 课程：Precision-Recall and ROC/AUC（Optional）
• 课程：Assignment 3，成本与流水线要求
• 官方：confusion_matrix 的行列定义

模型解释的边界、置换重要性及数据划分补充用于连接全课内容，不代表额外公布了考试题目或分值。

返回复习导航 · 下一章：梯度下降

复习目标：能写出预测式、核对矩阵维度、手算回归指标、解释系数，并区分“预测得准”和“业务赚钱”。正规方程推导与统计推断所在课程子页标为 optional；正文保留其边界。决定系数（R-squared）在作业 4 明确使用，应掌握定义与解释。

1. 模型在做什么

回归（Regression）预测数值目标，例如房价、二手手机价格；分类（Classification）预测类别，例如取消或不取消。

确定性函数关系（Functional relation）中，同一个输入直接决定输出；统计关系（Statistical relation）中，相同或相近输入仍可能有不同输出。线性回归用一条直线或一个平面概括总体趋势，允许残差存在。

单特征模型：

多特征模型：

两个特征的预测面是平面，更多特征对应超平面（Hyperplane）。课程把多个输入特征称为 multivariate regression；其他教材也常称 multiple regression。

2. 向量、矩阵与维度

设训练集有 $n$ 行、$d$ 个特征，用列向量书写参数：

因此 $\hat{\mathbf y}=\mathbf X\mathbf w+b$：$(n,d)@(d,1)\rightarrow(n,1)$。

为把截距一起写入正规方程，定义：

此时 $\mathbf X_b$ 为 $(n,d+1)$，$\boldsymbol\theta$ 为 $(d+1,1)$。课程有时仍把这个扩展参数向量写成 $\mathbf w$；本资料用 $\boldsymbol\theta$ 区分，避免漏掉截距。

NumPy 的 (d,) 是一维数组，严格说既不是二维行向量，也不是二维列向量；对它做 .T 仍是 (d,)。写手算矩阵与读代码时要分别核对形状。

import numpy as np

X = np.array([[1., 2.], [3., 4.], [5., 6.]])
w = np.array([[2.], [-1.]])
b = 3.
X_b = np.c_[np.ones(len(X)), X]  # 添加截距列
theta = np.vstack([[[b]], w])
print((X @ w + b).ravel())       # [3. 5. 7.]
print(X_b.shape, theta.shape)    # (3, 3) (3, 1)

运行输出：

[3. 5. 7.]
(3, 3) (3, 1)

3. 三种误差指标

三者都越小越好。因为平方根在非负范围单调递增，最小化 MSE 与最小化 RMSE 得到相同最优参数；MAE 的最优参数则不一定相同。

对同一批误差，$MAE\le RMSE$；所有误差的绝对值相等时取等号。RMSE 明显大于 MAE 提示部分误差偏大，但仍应看误差分布，不能只凭两个数定位异常样本。

手算例题 A（自编）：实际值 $y=[2,4,6]$，预测 $\hat y=[1,5,8]$。

1. 残差为 $[1,-1,-2]$。
2. $MSE=(1+1+4)/3=2$。
3. $RMSE=\sqrt2\approx1.414$。
4. $MAE=(1+1+2)/3=4/3\approx1.333$。

正负残差会抵消，不能用平均带符号残差代替上述误差指标。

4. 正规方程（Normal Equation）

对带截距的设计矩阵，普通最小二乘（Ordinary Least Squares, OLS）求解：

矩阵形状按顺序为：$(d+1,d+1)@(d+1,n)@(n,1)\rightarrow(d+1,1)$。

条件：上述“显式求逆”写法要求 $\mathbf X_b$ 满列秩（Full column rank）。完全重复或完全线性相关的列，会使 $\mathbf X_b^\top\mathbf X_b$ 不可逆；$n\ge d+1$ 是必要条件，但不足以保证满秩。

这不等于“线性回归不能训练”。伪逆（Pseudoinverse）、奇异值分解（Singular Value Decomposition, SVD）等方法仍可求最小二乘解；参数可能不唯一。

LinearRegression() 通常无需手工加 1 列。它求解相同的最小二乘问题，普通稠密输入使用数值最小二乘求解器；不要把其内部实现背成“直接调用 np.linalg.inv”。

手算例题 B（自编）：$(x,y)=(0,1),(1,3)$。

其逆为 $\begin{bmatrix}1&-1\\-1&2\end{bmatrix}$，因此 $\boldsymbol\theta=[1,2]^\top$，模型为 $\hat y=1+2x$。

可选推导：从 $J(\theta)=\frac1n\|\mathbf X_b\theta-\mathbf y\|^2$ 出发，令梯度 $\frac2n\mathbf X_b^\top(\mathbf X_b\theta-\mathbf y)=0$，得到正规方程组；只有满足可逆条件时，才进一步写成上面的逆矩阵公式。

5. 最小可运行代码

以下为自编模拟数据，只用于理解流程。训练均值基线（Mean baseline）必须使用 y_train.mean()。

import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score

rng = np.random.default_rng(409)
X = rng.uniform(0, 5, size=(100, 1))
y = 5 + 3 * X[:, 0] + rng.normal(0, 0.5, size=100)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=409
)
model = LinearRegression().fit(X_train, y_train)
pred = model.predict(X_test)
baseline = np.full(len(y_test), y_train.mean())  # 训练均值

print(model.intercept_, model.coef_)
print(np.sqrt(mean_squared_error(y_test, pred)))
print(mean_absolute_error(y_test, pred))
print(r2_score(y_test, pred))
print(np.sqrt(mean_squared_error(y_test, baseline)))

运行输出：

4.855537686983717 [3.04955243]
0.5461359526264463
0.44602283198394543
0.9758685739852215
3.640610722688897

代码中 y 为 (n,)，所以单目标模型的 coef_ 为 (d,)，intercept_ 为标量；若 y 为 (n,1)，属性形状会相应不同，但模型含义一致。

给上面的模拟代码补上业务含义： 可把 X[:,0] 理解为广告投入（千元），y 理解为销售额（千元）。生成式 5+3*x+噪声 代表我们人为设定的教学关系，不是真实广告数据。100 行拆成 80 行训练和 20 行测试；模型从训练行估计截距与系数，再对测试中的每个投入金额输出一个销售额。

new_spend = np.array([[2.0], [4.0]])  # 两个投放方案，单位千元
sales_prediction = model.predict(new_spend)
print(sales_prediction.shape)        # (2,)
print(sales_prediction.round(2))      # 约为 11、17 千元附近

运行输出：

(2,)
[10.95 17.05]

两行一列表示“两个方案、同一个特征”，不是一行两个特征。模型训练在有噪声且经过划分的数据上，所以结果不要求精确等于 11、17。baseline 则对所有测试行重复同一个训练均值；与它比较能看出使用投入信息是否改善预测。

6. 如何解释权重

假设 $\hat y=100+20x_1-5x_2$，价格单位为美元，$x_1$ 为存储容量单位数，$x_2$ 为使用年数。

• 在其他输入保持不变时，$x_1$ 增加 1，预测价格增加 20 美元。
• 在其他输入保持不变时，$x_2$ 增加 1，预测价格减少 5 美元。
• 截距 100 是所有输入为 0 时的预测；如果该组合不现实，截距不必有直接业务意义。
• 系数表达模型中的条件关联（Conditional association），不能直接解释为因果效应（Causal effect）。

输入单位不同，不能直接按原始系数绝对值排名重要性。若数值列已标准化，系数表示原特征增加一个训练集标准差时的预测变化，目标仍用原单位。

独热编码（One-hot encoding）中比较两个类别，可将其系数相减：例如“裂屏”系数 $-80$、“完好”系数 $20$，则其他条件相同下裂屏比完好低 $100$。保留所有类别又有截距时会存在冗余编码，单个类别系数不是相对一个被删除的参照组；类别差值更有解释性。

相关特征可能分摊或扰动系数。置换重要性（Permutation importance）衡量打乱某列后性能下降，与系数的正负方向是不同问题；它也不是因果结论。

7. 决定系数（R-squared）

对目标非恒定的一组评估样本：

其中 $\bar y$ 是当前被评分那组实际目标的均值。测试集 R² 的分母使用测试集实际目标均值，这是指标定义；真实可部署的均值基线仍应使用训练集均值，两者不能混为一谈。

例题 A 中 $\bar y=4$，$SST=4+0+4=8$，$SSE=6$，所以 $R^2=1-6/8=0.25$。若三条都预测 0，$SSE=56$，$R^2=1-56/8=-6$。

R² 不是分类准确率，也不是“25% 的预测正确”。测试 R² 可以为负，训练集表现良好也不保证测试集表现良好。

8. 统计输出与业务结果

可选统计子页：statsmodels.OLS 常需用 sm.add_constant(X) 显式加截距。输出中的 coef 是系数，P>|t| 是检验系数为 0 的 p 值，[0.025, 0.975] 是 95% 置信区间。

p 值是在零假设及统计模型假定下，出现至少这样极端检验统计量的概率；不是“零假设为真的概率”。显示 0.000 是舍入结果。统计显著（Statistically significant）不等于效果大、预测重要或存在因果。

95% 置信区间（Confidence interval）的长期含义是：重复抽样并用同一方法构造区间，约 95% 的区间覆盖固定的真实参数。考试优先会读系数、显著性与区间，不必扩展到完整推断课程。

作业 4 进一步强调：回归指标不能替代业务利润。以手机回收为例，报价 $o=r\hat y$，只有 $o\ge0.75y$ 时成交；成交利润为 $y-o$，未成交利润为 0。

例如实际价值 $100$、预测 $160$、报价比例 $0.75$：报价 $120$，成交后亏损 $20$。即使总体 R² 较高，某一类手机的系统性高估也可能导致亏损。用验证数据选择经营策略，最后用独立测试数据报告结果；反复看同一测试集挑报价，所得“最佳利润”会有选择偏差。

9. 易错点与纸笔自测

易错点：截距列漏加；把 * 当矩阵乘法；对 (d,) 转置后误认为是列向量；把 RMSE 说成平均带符号误差；不加条件地对奇异矩阵求逆；直接比较不同单位的系数；把 R² 当准确率或利润。

先遮住答案完成以下 5 题。

1. $n=50,d=4$，$\mathbf X_b^\top\mathbf X_b$ 是什么形状？
2. 所有误差绝对值都为 3，MAE、MSE、RMSE 各多少？
3. 标准化后的“房龄”系数为 2000，意味着每增加一年房价增加 2000 吗？
4. 测试集 $SSE=120,SST=100$，R² 为多少？
5. 两个特征列完全相同，正规方程的显式逆是否一定存在？

答案：1. (5,5)。2. 3、9、3。3. 不是，是增加一个训练集房龄标准差时，其他输入不变的预测变化。4. $-0.2$。5. 不存在满列秩，不能用该显式逆；仍可用最小二乘数值方法求解。

10. 本章 cheatsheet 候选与来源

优先手写：预测式；四个关键形状；MSE/RMSE/MAE；正规方程与可逆条件；系数的“其他不变／单位”；R² 与训练均值基线区别。推导细节与统计推断留在完整笔记中。

课程来源：线性回归、正规方程推导（optional）、模型解释、OLS 与 R²（optional）、作业 4。课程材料核对日期：2026-10-19。

返回复习导航 · 上一章：线性回归 · 下一章：集成学习

复习目标：分清模型和训练算法，手算一次参数更新，比较 BGD、SGD 与 mini-batch，并读懂学习率、迭代轮数、停止条件和标准化代码。

1. 模型、损失和训练算法

这三个问题要分开回答：

梯度下降不是一种回归模型。它通过反复调整参数来降低损失；同一种模型可以用不同算法训练，同一种优化算法也可以训练不同模型。

梯度（Gradient）收集损失对每个参数的偏导数，指向局部最陡上升方向，所以更新时沿负梯度方向走：

$\eta>0$ 是学习率（Learning rate），决定步长；$t$ 是更新步数。

• 某个偏导数为正，该参数本步减小。
• 某个偏导数为负，该参数本步增大。
• 偏导数为零，该方向本步不动；“梯度为零必为全局最小”不是对任意损失都成立。

线性回归的 MSE 对参数是凸函数（Convex function）；合适学习率下可收敛到全局最小。若设计矩阵不满列秩，最优参数可能不唯一。对非线性模型，MSE 不一定是凸函数，零梯度还可能对应鞍点等情况。

2. 线性回归 MSE 的梯度

本章用误差 $r_i=\hat y_i-y_i$，即预测减实际；上一章残差写作 $e_i=y_i-\hat y_i$。平方损失不受符号影响，但求导时必须保持一致。

权重偏导数是“误差 × 对应特征”的平均再乘 2；截距相当于一个值恒为 1 的特征。

把截距并入参数，令 $\mathbf X_b=[\mathbf1\ \mathbf X]$、$\boldsymbol\theta=[b,w_1,\ldots,w_d]^\top$，则：

形状核对：$(d+1,n)@(n,1)\rightarrow(d+1,1)$，梯度形状必须与参数相同。

某些教材把损失定义为 $\frac1{2n}\sum r_i^2$，梯度就没有前面的 2；应先看损失定义，再套梯度，不能混用。

3. 一次 BGD 手算（自编）

两条数据：$(x,y)=(1,3),(2,5)$；初始 $b=0,w=0$；学习率 $\eta=0.1$。

第一步：用同一组旧参数预测所有行。

第二步：求梯度。

第三步：同时更新。

新预测为 $[2.1,3.4]$，MSE 从 $(9+25)/2=17$ 降至 $(0.9^2+1.6^2)/2=1.685$。

“同时”指两个梯度都依据旧的 $b,w$ 计算。不能先更新 $b$，再用新 $b$ 计算同一步的 $w$ 梯度。

4. BGD、SGD 与 mini-batch

步（Step）是一次参数更新；轮（Epoch）是一次遍历训练数据。假设每轮恰好遍历 $n$ 行，mini-batch 大小为 $B$，最后一批不足 $B$ 也保留：

例如 $n=100$、10 轮：BGD 更新 10 次，SGD 更新 1000 次；若 $B=20$，mini-batch 更新 50 次。

课程手写 SGD 示例每轮有放回随机抽取 $n$ 次，因此某行可能被重复抽到，另一些行没被抽到；这里“一轮”按 $n$ 次抽取计。先打乱顺序再逐行遍历则会让每行每轮恰好出现一次。

单样本 SGD 梯度为：

BGD 是在同一参数点平均所有单行梯度；SGD 每处理一行就改变参数，因此跑完一轮通常不等于做一次 BGD。

接上例，顺序处理第 1 行再第 2 行。 第 1 行梯度为 $(-6,-6)$，更新后 $(b,w)=(0.6,0.6)$。第 2 行的新误差为 $0.6+2(0.6)-5=-3.2$，梯度为 $(-6.4,-12.8)$，再更新得 $(b,w)=(1.24,1.88)$，不同于 BGD 的 $(0.8,1.3)$。

5. 学习率、缩放与停止

学习率太小会收敛慢；太大可能在谷底两边震荡甚至发散。增加轮数不能修复一个持续发散的学习率。

学习率调度（Learning schedule）让步长随训练过程变化；退火（Annealing）通常指逐渐减小学习率，减少接近最优点时的跳动。SGD 固定步长时可能一直在最优点附近波动，单步损失不必单调下降。

特征缩放（Feature scaling）使不同量纲的特征更可比，改善损失面的形状，有助于 GD 更稳定、更快地优化。

StandardScaler 的均值与尺度必须从训练数据学习；在交叉验证（Cross-validation）中应置于流水线（Pipeline），在每个训练折内拟合。标准化不保证原分布变成正态分布。

两种停止条件不要混淆：

• 课程手写 BGD：可在 $\|\nabla J\|<\epsilon$ 时停止，另设最大轮数上限。
• SGDRegressor：max_iter 是最大训练轮数；tol 默认用于检查若干轮内损失改善是否足够，不是直接比较梯度范数。early_stopping=True 时还涉及验证得分。

默认 n_iter_no_change=5 表示连续若干轮改善不足后停止；n_iter_ 是实际运行轮数，可能小于 max_iter。官方参数说明

6. 可运行的 BGD 小例子

以下完整程序对应手算例题。线性回归可以从 0 初始化；随机初始化不是这里的必要条件。

import numpy as np

X = np.array([[1.], [2.]])
y = np.array([[3.], [5.]])
X_b = np.c_[np.ones(len(X)), X]
theta = np.zeros((2, 1))          # 顺序为 b、w
eta = 0.1

for epoch in range(1000):
    error = X_b @ theta - y       # 预测减实际
    gradient = 2 / len(X) * X_b.T @ error
    theta = theta - eta * gradient
    if np.linalg.norm(gradient) < 1e-8:
        break

print(theta.ravel())              # 约为 [1. 2.]
print(np.mean((X_b @ theta - y) ** 2))

运行输出：

[1.00000007 1.99999996]
5.043127849703739e-16

这段循环如何对应前面的手算？ 为便于理解，把两行数据看成两个广告方案：x 是投入，y 是销售额；数字与单位仅用于教学。开始 theta=[0,0]，两行都预测 0，因此必须根据误差调整截距与斜率。

第二轮继续用新参数对同样两条训练样本预测，再算误差；不是每一轮新增一条数据，也不是每一轮增加一个特征。循环结束输出的是学到的参数，预测新投入值还需代入 b+w*x。

代码先计算完整 gradient，再更新完整 theta，自然实现同一步的同时更新。这里的 theta 与 y 都是二维列向量，避免 (n,1)-(n,) 意外广播成 (n,n)。

7. sklearn：SGD 与线性回归对照

SGDRegressor(loss="squared_error") 拟合线性预测函数。若要与无惩罚 OLS 对照，应显式设置 penalty=None；默认 penalty="l2" 会增加正则项（Regularization term），优化目标已有变化。作业 4 按要求使用默认构造器时保留该默认，不应偷偷改写作业设置。官方说明

以下自编数据示例可独立运行；两者应得到接近的结果，不要求有限步 SGD 的小数逐位相同。

import numpy as np
from sklearn.linear_model import LinearRegression, SGDRegressor
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler

rng = np.random.default_rng(409)
X = rng.normal(size=(100, 2))
y = 5 + 3 * X[:, 0] - 2 * X[:, 1]
ols = LinearRegression().fit(X, y)
sgd = Pipeline([
    ("scale", StandardScaler()),
    ("model", SGDRegressor(
        loss="squared_error", penalty=None,
        max_iter=10000, tol=1e-8,
        eta0=0.01, random_state=409
    )),
]).fit(X, y)
print(np.max(np.abs(ols.predict(X) - sgd.predict(X))))

运行输出：

0.00033832065681593804

这里训练集对照是为了检验优化效果；实际比较泛化性能还需训练／测试拆分。OLS 在原始坐标下的系数与标准化后 SGD 的系数不能直接逐项比较，先统一特征尺度或比较预测值。

eta0 在默认 learning_rate="invscaling" 下是初始步长，后续还会衰减；显式设 learning_rate="constant" 才是恒定步长。参数值大并不自动表示模型更复杂或预测更准确。

8. 作业 4 的网格搜索如何读

SGD 搜索 max_iter 两个值、tol 两个值、eta0 两个值，共 $2\times2\times2=8$ 组。5 折交叉验证需要 40 次折内训练，默认再对最佳参数完整重拟合 1 次，共 41 次。

如果流水线的模型步骤叫 sgd_reg，参数键必须写成 sgd_reg__eta0 等；双下划线连接步骤名和参数名。

作业使用 scoring="neg_root_mean_squared_error"。搜索器始终选择得分最大者，因此 $-20$ 优于 $-50$，对应 RMSE 20 优于 50。若不指定 scoring，回归器默认 score 通常是 R²，不能擅自认为搜索在优化 RMSE。

SGD 调参主要解决收敛和所选目标的优化问题；若线性模型无法表达弯曲关系，继续增加轮数也不会自动让预测函数变成曲线。

9. 易错点与纸笔自测

易错点：把 GD 当模型；把梯度上升写成下降；漏掉损失定义中的 2；先更新一个参数再算同一步另一个梯度；把 epoch 当单样本更新；以为所有 MSE 都凸；以为增大 max_iter 必定改善；混淆标准化坐标与原坐标系数。

先作答，再看答案。

1. 旧参数 $\theta=[1,2]^\top$，梯度 $[4,-6]^\top$，$\eta=0.1$，新参数是什么？
2. 1000 行数据，batch size 为 128，mini-batch 每轮保留最后一批，有多少次更新？
3. SGD 某一步的全训练集损失上升，是否足以证明程序写错？
4. 两个设置均用线性预测函数，一个 OLS、一个默认 SGDRegressor，是否必定得到完全相同的最优参数？
5. best_score_=-80 表示“RMSE 为负数”吗？

答案：1. $[0.6,2.6]^\top$。2. $\lceil1000/128\rceil=8$。3. 否，单行随机梯度有噪声。4. 否；默认 SGD 有 L2，有限迭代与停止条件也影响结果。5. 否，负号是评分约定，对应平均交叉验证 RMSE 约为 80。

10. 本章 cheatsheet 候选与来源

优先手写：$\theta\leftarrow\theta-\eta g$；$g=\frac2nX_b^\top(X_b\theta-y)$；BGD/SGD/mini 的每步数据量和每轮步数；同时更新；scaling；eta0/max_iter/tol；负 RMSE 越大越好。

课程来源：梯度下降、线性回归、作业 4。课程材料核对日期：2026-10-19。

返回复习导航 · 上一章：梯度下降

复习目标：比较投票、装袋与提升，手算硬／软投票、OOB 概率和 AdaBoost 权重，并解释随机森林为何常比单棵深树稳定。Logistic Regression 和 SVM 在本章只作为“不同类型的基学习器”出现，不展开其独立章节。

1. 为什么组合模型

集成把多个基学习器（Base learner）的预测组合起来。有效的条件是：成员具有预测能力，而且错误不完全相同；数量多本身不保证优于最佳单模型。

对平方误差，在适当统计假定下，期望预测误差可分解为：

课程用噪声举例时也提到录入或测量错误；这些可通过数据清理减少，但不能据此说所有随机噪声都能清理掉。

浅树通常偏差较高、方差较低；深树通常偏差较低、方差较高。装袋主要降低方差，提升常通过逐步修正来降低偏差；这描述典型作用，不是所有数据和参数下的绝对定律。

2. 三类方法总览

随机森林（Random Forest）属于装袋思路；AdaBoost、梯度提升（Gradient Boosting）和 XGBoost 属于提升。

3. 硬投票与软投票

硬投票（Hard voting）数类别票数；软投票（Soft voting）先平均各模型的类别概率，再选平均概率最大的类别。加权投票还可给不同模型不同权重。

课程型手算题：三个模型给出类别 A 的概率为 $0.90,0.45,0.45$，B 的概率为其补数。

• 三个硬预测为 A、B、B，硬投票选择 B。
• A 的平均概率为 $(0.90+0.45+0.45)/3=0.60$，软投票选择 A。
• 软投票保留了模型“有多确信”的信息；概率估计不可靠时，并不保证优于硬投票。

软投票要求所有成员能够提供类别概率。课程对 SVC 使用概率校准（Probability calibration）；只提供 decision_function 得分还不等于直接具备 predict_proba。

下面代码可独立运行；它展示课程中的三类成员，不要求复习 Logistic Regression 或 SVM 的数学推导。

from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.calibration import CalibratedClassifierCV
from sklearn.ensemble import VotingClassifier
from sklearn.metrics import accuracy_score

X, y = make_moons(n_samples=300, noise=0.25, random_state=409)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, stratify=y, random_state=409
)
vote = VotingClassifier(
    estimators=[
        ("tree", DecisionTreeClassifier(max_depth=3, random_state=409)),
        ("lr", LogisticRegression()),
        ("svm", CalibratedClassifierCV(
            SVC(), cv=3, ensemble=False  # 得分转为概率
        )),
    ],
    voting="soft",
)
vote.fit(X_train, y_train)
print(accuracy_score(y_test, vote.predict(X_test)))

运行输出：

0.8833333333333333

投票代码中的数据如何流动？ make_moons 生成两群月牙形的二维点，每行一个点、两列为坐标，标签为所属类别。这是观察不同分类器如何组合的几何教学数据，并非酒店订单。训练集有 240 个点，测试集有 60 个点；三个成员都从训练数据学习，再分别为同一个测试点给出类别概率。

VotingClassifier(..., voting="soft") 在内部对每个点平均成员概率，vote.predict(X_test) 最后给出 60 个类别。因此它平均的是“同一条样本的多个模型意见”，不是把 60 个样本的概率混成一个数。

回归任务可平均成员的数值预测；例如三模型预测 $100,120,140$，等权平均结果为 $120$。

4. 装袋、自助采样与 OOB

自助采样（Bootstrap sampling）从原来 $n$ 行中有放回抽取；典型 bagging 每个样本包抽 $n$ 次，所以包的行数仍为 $n$，但会有重复行，也有未出现的原始行。

粘贴法（Pasting）采用无放回采样，不能与 bootstrap 混淆。

某一固定原始样本，在一次抽取中未被选中的概率为 $1-1/n$，独立抽 $n$ 次都未选中的概率为：

因此大样本下，每个包约含原始数据中 63.2% 的不同样本，约 36.8% 为袋外样本（Out-of-bag, OOB）。这两个百分数是期望近似，不是每一包都恰好如此；若抽取次数不同，公式也应改变。

手算题：原始数据仅有 5 行，每包抽 5 次。某行成为 OOB 的概率是 $(4/5)^5=0.32768$，不是精确的 0.368；包内不同原始行的期望数量为 $5(1-0.32768)=3.3616$。

用五条订单看清“有放回”。 给原始行编号 A、B、C、D、E。某棵树可能抽到 [A,A,C,D,D]：训练包有 5 行，但只含 3 个不同订单；B、E 是这棵树的 OOB。另一棵树若抽到 [B,C,C,E,A]，D 才是它的 OOB。由此可见，OOB 不是预先统一划出的某一组订单。以下抽样仅为示意，概率公式仍按随机抽取计算。

OOB 评估的正确思路：

1. 固定一个训练样本 $i$。
2. 只找训练时没有抽到 $i$ 的那些树。
3. 用这些树的预测组合出样本 $i$ 的 OOB 预测。
4. 对有可用 OOB 预测的训练样本汇总评分。

所以 OOB 分数不是森林直接在全部训练样本上的普通训练分数，也不是“每棵树自己的 OOB 准确率简单平均”。树太少时，有的样本可能没有足够 OOB 预测。

OOB 可作为训练数据内部的泛化估计；它并不保证与独立测试得分完全相同，也不授权反复看最终测试集调参。

5. 随机森林

随机森林让树之间产生差异的两个主要来源：

• 样本随机性：每棵树使用不同 bootstrap 样本。
• 特征随机性：每个节点分裂时，只从随机抽取的一部分候选特征中找分裂。

不是“每棵树开始时只抽一次特征，并在整棵树中固定使用”。减少树之间的相关性，使平均后的预测通常更稳定。

max_depth=None 表示没有显式深度上限，不代表任何数据都能得到纯叶；特征完全相同而标签冲突等情况仍会阻止进一步区分。

分类森林中，sklearn 先平均各树的类别概率，再选择概率最大的类别；不要将其实现绝对化为“每棵树给一张等权硬票”。回归森林平均各树的数值预测。RandomForestClassifier 官方说明

以下代码沿用第 3 节投票例子的数据拆分；只用训练数据拟合。

from sklearn.ensemble import RandomForestClassifier

forest = RandomForestClassifier(
    n_estimators=150, max_features="sqrt",
    bootstrap=True, oob_score=True, random_state=409
)
forest.fit(X_train, y_train)
print(forest.oob_score_)          # 训练数据内部评估
print(accuracy_score(y_test, forest.predict(X_test)))

运行输出：

0.9291666666666667
0.9166666666666666

作业 4 用 RandomForestRegressor 预测手机价格，搜索 2 个树数和 2 个深度，共 4 组参数，5 折为 20 次折内训练，默认再重拟合 1 次。

树可以刻画非线性与交互作用（Interaction）：同样的“裂屏”对旗舰机和低价机的预测影响可以不同；只有加性原始特征的线性模型则给出固定差额。森林是否更好仍须由验证数据判断。

6. AdaBoost：两类权重

自适应提升（Adaptive Boosting, AdaBoost）顺序训练弱学习器，重点关注之前容易错的样本。先区分：

• 样本权重 $w_i^{(t)}$：训练第 $t$ 个学习器时，第 $i$ 行算多重要。
• 学习器权重 $\alpha_t$：最终预测时，第 $t$ 个学习器的意见算多重要。

课程采用标签 $y_i\in\{-1,+1\}$，初始化每行权重为 $1/n$。第 $t$ 轮：